diff --git a/.project b/.project
new file mode 100644
index 0000000..ac4d70a
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.api.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/epl-v10.html b/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/jenkins.build.config.xml b/jenkins.build.config.xml
new file mode 100644
index 0000000..ed0c395
--- /dev/null
+++ b/jenkins.build.config.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)     					 			 -->
+<!--# All rights reserved. This program and the accompanying materials 		 -->
+<!--# are made available under the terms of the Eclipse Public License v1.0  -->
+<!--# which accompanies this distribution, and is available at               -->
+<!--# http://www.eclipse.org/legal/epl-v10.html                              -->
+<!--#                                                                        -->
+<!--# Contributors:                                                          -->
+<!--# Loetz GmbH&Co.KG - initial API and implementation                      -->
+<!--#======================================================================= -->
+<!--# Module specific parameters for the Jenkins Job 						 -->
+<!--#======================================================================= -->
+<jenkins>
+	<!-- DO NOT EDIT BELOW THIS LINE -->
+        <jenkins.build.dependencies>
+                <jenkins.build.dependency>org.eclipse.osbp.ecview.core</jenkins.build.dependency>
+                <jenkins.build.dependency>org.eclipse.osbp.runtime</jenkins.build.dependency>
+                <jenkins.build.dependency>org.eclipse.osbp.ui.api</jenkins.build.dependency>
+        </jenkins.build.dependencies>
+</jenkins>
diff --git a/notice.html b/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.api.feature/.project b/org.eclipse.osbp.ecview.extension.api.feature/.project
new file mode 100644
index 0000000..e229441
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.api.feature</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.FeatureBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.FeatureNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/LICENSE.txt b/org.eclipse.osbp.ecview.extension.api.feature/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/build.properties b/org.eclipse.osbp.ecview.extension.api.feature/build.properties
new file mode 100644
index 0000000..0ea4044
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/build.properties
@@ -0,0 +1,10 @@
+bin.includes = feature.xml,\
+               feature.properties,\
+               notice.html,\
+               license.html,\
+               LICENSE.txt,\
+               epl-v10.html
+src.includes = license.html,\
+               LICENSE.txt,\
+               notice.html,\
+               epl-v10.html			   
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/epl-v10.html b/org.eclipse.osbp.ecview.extension.api.feature/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/feature.properties b/org.eclipse.osbp.ecview.extension.api.feature/feature.properties
new file mode 100644
index 0000000..a21eb4e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/feature.properties
@@ -0,0 +1,172 @@
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+# Loetz GmbH&Co.KG - initial API and implementation 
+#=======================================================================
+# feature.properties
+# contains externalized strings for feature.xml
+# "%foo" in feature.xml corresponds to the key "foo" in this file
+# java.io.Properties file (ISO 8859-1 with "\" escapes)
+# This file should be translated.
+
+# "featureName" property - name of the feature
+featureName =OSBP ecview.extension.api 
+
+# "providerName" property - name of the company that provides the feature
+providerName=Eclipse OSBP
+
+# "description" property - description of the feature
+description=This feature provides the OSBP ecview.extension.api bundle.
+
+# "updateSiteName" property - label for the update site
+updateSiteName=
+
+# "copyright" property - text of the "Feature Update Copyright"
+copyright=\
+Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany). \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&amp;Co.KG - initial API and basis\n\
+
+################ end of copyright property ####################################
+
+# "licenseURL" property - URL of the "Feature License"
+# do not translate value - just change to point to a locale-specific HTML page
+licenseURL=license.html
+
+# "license" property - text of the "Feature Update License"
+# should be plain text version of license agreement pointed to be "licenseURL"
+license=\
+Eclipse Foundation Software User Agreement\n\
+February 1, 2011\n\
+\n\
+Usage Of Content\n\
+\n\
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
+OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
+USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
+AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
+NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU\n\
+AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
+AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
+OR NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE\n\
+TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
+OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
+BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
+\n\
+Applicable Licenses\n\
+\n\
+Unless otherwise indicated, all Content made available by the\n\
+Eclipse Foundation is provided to you under the terms and conditions of\n\
+the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is\n\
+provided with this Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
+For purposes of the EPL, "Program" will mean the Content.\n\
+\n\
+Content includes, but is not limited to, source code, object code,\n\
+documentation and other files maintained in the Eclipse Foundation source code\n\
+repository ("Repository") in software modules ("Modules") and made available\n\
+as downloadable archives ("Downloads").\n\
+\n\
+       - Content may be structured and packaged into modules to facilitate delivering,\n\
+         extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
+         plug-in fragments ("Fragments"), and features ("Features").\n\
+       - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java(TM) ARchive)\n\
+         in a directory named "plugins".\n\
+       - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
+         Each Feature may be packaged as a sub-directory in a directory named "features".\n\
+         Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
+         numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
+       - Features may also include other Features ("Included Features"). Within a Feature, files\n\
+         named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
+\n\
+The terms and conditions governing Plug-ins and Fragments should be\n\
+contained in files named "about.html" ("Abouts"). The terms and\n\
+conditions governing Features and Included Features should be contained\n\
+in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
+Licenses may be located in any directory of a Download or Module\n\
+including, but not limited to the following locations:\n\
+\n\
+       - The top-level (root) directory\n\
+       - Plug-in and Fragment directories\n\
+       - Inside Plug-ins and Fragments packaged as JARs\n\
+       - Sub-directories of the directory named "src" of certain Plug-ins\n\
+       - Feature directories\n\
+\n\
+Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
+Provisioning Technology (as defined below), you must agree to a license ("Feature \n\
+Update License") during the installation process. If the Feature contains\n\
+Included Features, the Feature Update License should either provide you\n\
+with the terms and conditions governing the Included Features or inform\n\
+you where you can locate them. Feature Update Licenses may be found in\n\
+the "license" property of files named "feature.properties" found within a Feature.\n\
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the\n\
+terms and conditions (or references to such terms and conditions) that\n\
+govern your use of the associated Content in that directory.\n\
+\n\
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER\n\
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
+SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
+\n\
+       - Eclipse Distribution License Version 1.0 (available at http://www.eclipse.org/licenses/edl-v1.0.html)\n\
+       - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
+       - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
+       - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
+       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
+       - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
+\n\
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
+TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License\n\
+is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
+govern that particular Content.\n\
+\n\
+\n\Use of Provisioning Technology\n\
+\n\
+The Eclipse Foundation makes available provisioning software, examples of which include,\n\
+but are not limited to, p2 and the Eclipse Update Manager ("Provisioning Technology") for\n\
+the purpose of allowing users to install software, documentation, information and/or\n\
+other materials (collectively "Installable Software"). This capability is provided with\n\
+the intent of allowing such users to install, extend and update Eclipse-based products.\n\
+Information about packaging Installable Software is available at\n\
+http://eclipse.org/equinox/p2/repository_packaging.html ("Specification").\n\
+\n\
+You may use Provisioning Technology to allow other parties to install Installable Software.\n\
+You shall be responsible for enabling the applicable license agreements relating to the\n\
+Installable Software to be presented to, and accepted by, the users of the Provisioning Technology\n\
+in accordance with the Specification. By using Provisioning Technology in such a manner and\n\
+making it available in accordance with the Specification, you further acknowledge your\n\
+agreement to, and the acquisition of all necessary rights to permit the following:\n\
+\n\
+       1. A series of actions may occur ("Provisioning Process") in which a user may execute\n\
+          the Provisioning Technology on a machine ("Target Machine") with the intent of installing,\n\
+          extending or updating the functionality of an Eclipse-based product.\n\
+       2. During the Provisioning Process, the Provisioning Technology may cause third party\n\
+          Installable Software or a portion thereof to be accessed and copied to the Target Machine.\n\
+       3. Pursuant to the Specification, you will provide to the user the terms and conditions that\n\
+          govern the use of the Installable Software ("Installable Software Agreement") and such\n\
+          Installable Software Agreement shall be accessed from the Target Machine in accordance\n\
+          with the Specification. Such Installable Software Agreement must inform the user of the\n\
+          terms and conditions that govern the Installable Software and must solicit acceptance by\n\
+          the end user in the manner prescribed in such Installable Software Agreement. Upon such\n\
+          indication of agreement by the user, the provisioning Technology will complete installation\n\
+          of the Installable Software.\n\
+\n\
+Cryptography\n\
+\n\
+Content may contain encryption software. The country in which you are\n\
+currently may have restrictions on the import, possession, and use,\n\
+and/or re-export to another country, of encryption software. BEFORE\n\
+using any encryption software, please check the country's laws,\n\
+regulations and policies concerning the import, possession, or use, and\n\
+re-export of encryption software, to see if this is permitted.\n\
+\n\
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.\n
+########### end of license property ##########################################
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/feature.xml b/org.eclipse.osbp.ecview.extension.api.feature/feature.xml
new file mode 100644
index 0000000..d5774e2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/feature.xml
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.osbp.ecview.extension.api.feature"
+      label="%featureName"
+      version="0.9.0.qualifier"
+      provider-name="%providerName">
+
+   <description>
+      %description
+   </description>
+
+   <copyright>
+      %copyright
+   </copyright>
+
+   <license url="%licenseURL">
+      %license
+   </license>
+
+   <plugin
+         id="org.eclipse.osbp.ecview.extension.api"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.osbp.ecview.extension.editparts"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.osbp.ecview.extension.grid.editparts"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.osbp.ecview.extension.grid.model"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.osbp.ecview.extension.grid.model.edit"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.osbp.ecview.extension.model"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.osbp.ecview.extension.model.edit"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+</feature>
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/license.html b/org.eclipse.osbp.ecview.extension.api.feature/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/notice.html b/org.eclipse.osbp.ecview.extension.api.feature/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.api.feature/pom.xml b/org.eclipse.osbp.ecview.extension.api.feature/pom.xml
new file mode 100644
index 0000000..e6f3b39
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/pom.xml
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+# 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/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.eclipse.osbp.ecview.extension.api</groupId>
+        <artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+        <version>0.9.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>org.eclipse.osbp.ecview.extension.api.feature</artifactId>
+    <packaging>eclipse-feature</packaging>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.eclipse.tycho.extras</groupId>
+                <artifactId>tycho-source-feature-plugin</artifactId>
+                <version>${tychoExtrasVersion}</version>
+                <executions>
+                    <execution>
+                        <id>source-feature</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>source-feature</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <labelSuffix> (source)</labelSuffix>
+                </configuration>
+            </plugin>
+            <plugin>
+                <!-- workaround while bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=398250 
+					is not fixed -->
+                <groupId>org.eclipse.tycho</groupId>
+                <artifactId>tycho-p2-plugin</artifactId>
+                <version>${tycho-version}</version>
+                <executions>
+                    <execution>
+                        <id>attached-p2-metadata</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>p2-metadata</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+			<plugin>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>javadoc-jar</id>
+						<phase>package</phase>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.eclipse.osbp.ecview.extension.api</groupId>
+            <artifactId>org.eclipse.osbp.ecview.extension.api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/src/main/javadoc/README.txt b/org.eclipse.osbp.ecview.extension.api.feature/src/main/javadoc/README.txt
new file mode 100644
index 0000000..831da7e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/src/main/javadoc/README.txt
@@ -0,0 +1 @@
+Resource folder for javadoc resources.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api.feature/src/overview.html b/org.eclipse.osbp.ecview.extension.api.feature/src/overview.html
new file mode 100644
index 0000000..06163c2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api.feature/src/overview.html
@@ -0,0 +1,9 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+<head>
+	<title>OSBP ecview.extension.api</title>
+</head>
+<body>
+<p>The <strong>OSBP&nbsp;ecview.extension.api</strong> provides bundles for the OSBP ecview.extension.api functionality.</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.ecview.extension.api/.project b/org.eclipse.osbp.ecview.extension.api/.project
new file mode 100644
index 0000000..93f1fb4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/.project
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.api</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ds.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.api/LICENSE.txt b/org.eclipse.osbp.ecview.extension.api/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api/META-INF/MANIFEST.MF b/org.eclipse.osbp.ecview.extension.api/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..03d449b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.ecview.extension.api
+Bundle-SymbolicName: org.eclipse.osbp.ecview.extension.api
+Bundle-Version: 0.9.0.qualifier
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Import-Package: org.osgi.framework;version="1.8.0",
+ org.osgi.service.component;version="1.2.0",
+ org.osgi.service.component.annotations;version="1.2.0"
+Bundle-ActivationPolicy: lazy
+Export-Package: org.eclipse.osbp.ecview.extension.api;version="0.9.0"
+Bundle-Vendor: Eclipse OSBP
+Require-Bundle: org.slf4j.api;bundle-version="1.7.2",
+ com.vaadin.server;bundle-version="[7.5.7,7.7.0)",
+ org.eclipse.core.databinding;bundle-version="1.4.1",
+ org.eclipse.osbp.ecview.core.common;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.runtime.common;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.ecview.core.common.model;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.ecview.core.util.emf;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.ecview.extension.model;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.gitinfo;bundle-version="[0.9.0,0.10.0)"
+Bundle-Activator: org.eclipse.osbp.ecview.extension.api.Activator
diff --git a/org.eclipse.osbp.ecview.extension.api/about.html b/org.eclipse.osbp.ecview.extension.api/about.html
new file mode 100644
index 0000000..64c0598
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/about.html
@@ -0,0 +1,28 @@
+<!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>June 1, 2016</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &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>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api/about.ini b/org.eclipse.osbp.ecview.extension.api/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/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.ecview.extension.api/about.mappings b/org.eclipse.osbp.ecview.extension.api/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/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.ecview.extension.api/about.properties b/org.eclipse.osbp.ecview.extension.api/about.properties
new file mode 100644
index 0000000..ab23863
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/about.properties
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.ecview.extension.api
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - implementation\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.ecview.extension.api/build.properties b/org.eclipse.osbp.ecview.extension.api/build.properties
new file mode 100644
index 0000000..ff0bb4f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/build.properties
@@ -0,0 +1,12 @@
+bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
+               .,\
+               .settings/,\
+               .classpath,\
+               license.html,\
+               LICENSE.txt,\
+               epl-v10.html
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
+               LICENSE.txt,\
+               epl-v10.html			   
+output.. = target/classes
+source.. = src/
diff --git a/org.eclipse.osbp.ecview.extension.api/epl-v10.html b/org.eclipse.osbp.ecview.extension.api/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api/license.html b/org.eclipse.osbp.ecview.extension.api/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.api/notice.html b/org.eclipse.osbp.ecview.extension.api/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.api/pom.xml b/org.eclipse.osbp.ecview.extension.api/pom.xml
new file mode 100644
index 0000000..a592f8b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/pom.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial 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.ecview.extension.api</groupId>
+		<artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.ecview.extension.api</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<description>Contains the API for ui controller</description>
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/Activator.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/Activator.java
new file mode 100644
index 0000000..8278b27
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/Activator.java
@@ -0,0 +1,56 @@
+/*
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ *     Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation                               
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.api;
+
+
+import org.eclipse.osbp.gitinfo.Loginfo;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+
+/**
+ * The Class Activator.
+ */
+public class Activator implements BundleActivator {
+
+	/** The context. */
+	private static BundleContext context;
+
+	/**
+	 * Gets the context.
+	 *
+	 * @return the context
+	 */
+	static BundleContext getContext() {
+		return context;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
+	 */
+	public void start(BundleContext bundleContext) throws Exception {
+		Activator.context = bundleContext;
+		Loginfo li = new Loginfo();
+		li.print( Activator.class.getCanonicalName(), Activator.class.getClassLoader());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)
+	 */
+	public void stop(BundleContext bundleContext) throws Exception {
+		Activator.context = null;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IContextSensitiveLayoutSelector.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IContextSensitiveLayoutSelector.java
new file mode 100644
index 0000000..2cb42ad
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IContextSensitiveLayoutSelector.java
@@ -0,0 +1,52 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.api;
+
+/**
+ * Implementation needs to return a "selector" String for the given dto. The
+ * selector String is related with a single component contained in the context
+ * sensitive layout.<br>
+ * The component associated with the returned selector will become visible. All
+ * other components will become invisible.
+ */
+public interface IContextSensitiveLayoutSelector {
+
+	/**
+	 * If implementations are using the function dsl, so this function group
+	 * needs to be used.
+	 */
+	static final String FUNCTION_GROUP = "ContextSensitiveLayout";
+
+	/**
+	 * If implementations are using the function dsl, so this function name
+	 * needs to be used. The input parameter for the dto needs to be Object in
+	 * this version.  
+	 * 
+	 * TODO make function DSL allow same function name with different signature.
+	 */
+	static final String FUNCTION_NAME = "selectComponent";
+
+	/**
+	 * Needs to return a "selector" String for the given dto. The selector
+	 * String is related with a single component contained in the context
+	 * sensitive layout.<br>
+	 * The component associated with the returned selector will become visible.
+	 * All other components will become invisible.
+	 * 
+	 * @param dto
+	 * @return
+	 */
+	String selectComponent(Object dto);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingEnhancer.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingEnhancer.java
new file mode 100644
index 0000000..769a1ea
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingEnhancer.java
@@ -0,0 +1,39 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.api;
+
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+
+/**
+ * Is used to fill all required focusing strategies to the strategy layout for
+ * default behaviour.
+ */
+public interface IFocusingEnhancer {
+
+	/** The Constant PROPERTY__OSGI_SERVICE. */
+	public static final String PROPERTY__OSGI_SERVICE = "ecview.focusing.enhancer.id";
+	
+	/** The Constant PROPERTY__DEFAULT_OSGI_SERVICE. */
+	public static final String PROPERTY__DEFAULT_OSGI_SERVICE = "ecview.focusing.enhancer.default";
+
+	/**
+	 * Is called before the strategy layout will become rendered. And any time,
+	 * the focusing strategies should be set to default.
+	 *
+	 * @param yLayout
+	 *            the y layout
+	 */
+	void enhanceFocusing(YStrategyLayout yLayout);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategy.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategy.java
new file mode 100644
index 0000000..e328ef7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategy.java
@@ -0,0 +1,57 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.api;
+
+import org.eclipse.osbp.ecview.core.common.services.IWidgetAssocationsService;
+import org.eclipse.osbp.runtime.common.keystroke.KeyStrokeDefinition;
+
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+
+/**
+ * Is used to set the focus to a field.
+ */
+public interface IFocusingStrategy {
+
+	/**
+	 * Calculates the next focused field and sets the focus. The passed source
+	 * and target parameter are the UI-Kit specific UI-elements that are
+	 * involved in the key stroke event. To support hybrid applications based on
+	 * ECView and native UI-Code, the original objects are passed.
+	 * <p>
+	 * Use {@link IWidgetAssocationsService} to map the given elements to their
+	 * model elements.
+	 *
+	 * @param source
+	 *            - the element the keystroke listener was registered at. Type
+	 *            is the original type of the UI-element sent the event. So it
+	 *            is UI-Kit specific.
+	 * @param target
+	 *            - the element where the keystroke occurred. Type is the
+	 *            original type of the UI-element sent the event. So it is
+	 *            UI-Kit specific.
+	 * @param yLayout
+	 *            the y layout
+	 */
+	void focus(Object source, Object target, YStrategyLayout yLayout);
+
+	/**
+	 * Needs to return the keystroke definition used to observe key strokes that
+	 * invoke focusing at this strategy. These key strokes are being ignored, if
+	 * there is a more special definition of them in the StrategyLayout.
+	 *
+	 * @return the key stroke definition
+	 */
+	KeyStrokeDefinition getKeyStrokeDefinition();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategyProvider.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategyProvider.java
new file mode 100644
index 0000000..c897d6e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategyProvider.java
@@ -0,0 +1,38 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.api;
+
+/**
+ * Is used to provide the default strategy. It needs to be passed in
+ * IViewContext.
+ */
+public interface IFocusingStrategyProvider {
+
+	/**
+	 * do not use anymore! The DefaultFocusingStrategyProvider was removed.
+	 */
+	@Deprecated()
+	public static final String ACTIVE_PROVIDER_TOPIC = "org/eclipse/osbp/ecview/focusing/strategyprovider";
+
+	/** The Constant PROPERTY__OSGI_SERVICE. */
+	public static final String PROPERTY__OSGI_SERVICE = "ecview.focusing.id";
+
+	/**
+	 * Returns the IFocusingStrategy.
+	 *
+	 * @return the strategy
+	 */
+	IFocusingStrategy getStrategy();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategy.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategy.java
new file mode 100644
index 0000000..92468f5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategy.java
@@ -0,0 +1,255 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.api;
+
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+
+/**
+ * Is used to layout the given model properly.
+ */
+public interface ILayoutingStrategy {
+
+	/** The Constant TAG__TEXT. */
+	public static final String TAG__TEXT = "text";
+
+	/** The Constant TAG__SUGGEST_TEXT. */
+	public static final String TAG__SUGGEST_TEXT = "suggestText";
+
+	/** The Constant TAG__TEXTAREA. */
+	public static final String TAG__TEXTAREA = "textarea";
+
+	/** The Constant TAG__NUMBER. */
+	public static final String TAG__NUMBER = "number";
+
+	/**
+	 * Attributes tagged with this property are being presented by a
+	 * RichTextField using value-Binding (String).
+	 */
+	public final static String TAG__RICH_TEXT__STRING = "richText__String";
+	
+	/**
+	 * Attributes tagged with this property are being presented by a
+	 * MaskedTextField.
+	 */
+	public final static String TAG__MASKED_TEXT_FIELD = "maskedTextField";
+	
+	/**
+	 * Attributes tagged with this property are being presented by a
+	 * MaskedDecimalField.
+	 */
+	public final static String TAG__MASKED_DECIMAL_FIELD = "maskedDecimalField";
+
+	/**
+	 * Attributes tagged with this property are being presented by a
+	 * RichTextField using blob-Value-Binding (byte[]).
+	 */
+	public final static String TAG__RICH_TEXT__BLOB = "richText__Blob";
+
+	/**
+	 * Attributes tagged with this property are being presented by a
+	 * PasswordField using value-Binding (String).
+	 */
+	public final static String TAG__PASSWORD = "password";
+
+	/** The Constant TAG__DECIMAL. */
+	public static final String TAG__DECIMAL = "decimal";
+
+	/** The Constant TAG__BOOLEAN. */
+	public static final String TAG__BOOLEAN = "boolean";
+
+	/** The Constant TAG__DATE. */
+	public static final String TAG__DATE = "date";
+
+	/** The Constant TAG__ENUM_OPTIONS. */
+	public static final String TAG__ENUM_OPTIONS = "enumOptions";
+
+	/** The Constant TAG_ENUM_COMBO. */
+	public final static String TAG__ENUM_COMBO = "enumCombo";
+
+	/** The Constant TAG__ORGANIZATION_COMBO. */
+	public final static String TAG__ORGANIZATION_COMBO = "organizationCombo";
+
+	/** The Constant TAG__PERSPECTIVE_COMBO. */
+	public final static String TAG__PERSPECTIVE_COMBO = "perpectiveCombo";
+
+	/** The Constant TAG__BLOB. */
+	public static final String TAG__BLOB = "blob";
+
+	/** The Constant TAG__BEAN_REFERENCE. */
+	public static final String TAG__BEAN_REFERENCE = "beanReference";
+
+	/** The Constant TAG__GRID. */
+	public static final String TAG__GRID = "grid";
+
+	/** The Constant TAG__TABLE. */
+	public static final String TAG__TABLE = "table";
+
+	/** The Constant TAG__CONSTRAINT. */
+	public static final String TAG__CONSTRAINT = "constraint";
+
+	/**
+	 * The Constant TAG__DTO. Suspects of this type define suspects for a whole
+	 * dto.
+	 */
+	public static final String TAG__DTO = "dto";
+
+	/**
+	 * The Constant TAG__SUBTYPE. <br>
+	 * Suspects and beanslots of this type are DTO Suspects for sub classes of
+	 * the main dto. Their visiblity needs to be controlled.
+	 * */
+	public static final String TAG__SUBTYPE = "dto_subtype";
+
+	/**
+	 * The Constant TAG__SUBTYPES_ROOT. <br>
+	 * Suspects of this type contain further compound suspects. One for each
+	 * direct subclass.
+	 * */
+	public static final String TAG__SUBTYPES_ROOT = "dto_subtypes_root";
+
+	/**
+	 * Model elements tagged with this tag need to be removed / disposed before
+	 * next {@link #layout(YLayoutingInfo)}.
+	 */
+	public static final String TAG__TO_BE_CLEANED = "strategylayout__toBeCleaned";
+
+	/**
+	 * The Constant PROPERTY__SUBTYPE. The autowirehelper passes the classname
+	 * of the sub type in this property.
+	 * */
+	public static final String PROPERTY__SUBTYPE_CLASS = "dto_subtype_className";
+
+	/** The Constant TAG__IMAGE_PICKER. */
+	public static final String TAG__IMAGE_PICKER = "imagePicker";
+	// public static final String TAG__CATEGORY_1 = "category1";
+	// public static final String TAG__CATEGORY_2 = "category2";
+	/** The Constant PROPERTY_TEXTAREA. */
+	// Constants
+	public final static String PROPERTY_TEXTAREA = "textarea";
+
+	/** The Constant PROPERTY_BLOB. */
+	public final static String PROPERTY_BLOB = "blob";
+
+	/** The Constant PROPERTY_BLOB_FIRMLY_LINKED. */
+	public final static String PROPERTY_BLOB_FIRMLY_LINKED = "blobfirmlylinked";
+
+	/** The Constant PROPERTY_BLOB_UNIQUE_NAMED. */
+	public final static String PROPERTY_BLOB_UNIQUE_NAMED = "blobuniquenamed";
+
+	/**
+	 * Together with the key {@link #PROPERTY_KEY__FIELD_TYPE} it indicates that
+	 * the field from data model should be presented by a RichTextArea. <br>
+	 * Eg: <code>key="type" value="richTextArea"</code>
+	 * <p>
+	 * Whether value-binding (String) or blob-Value-Binding (byte[]) is used,
+	 * depends on the underlying data model. String-binding for String and
+	 * Blob-Binding for byte[].
+	 */
+	public final static String PROPERTY_RICH_TEXT = "richTextArea";
+	
+	/**
+	 * Together with the key {@link #PROPERTY_KEY__FIELD_TYPE} it indicates that
+	 * the field from data model should be presented by a MaskedTextField. <br>
+	 * Eg: <code>key="type" value="maskedText"</code><p>
+	 * This type need to be used together with the key "mask".
+	 * Eg:  <code>var MaskedText text properties (key="mask" value="UUU-###")</code><p>
+	 */
+	public final static String PROPERTY_MASKED_TEXT = "maskedText";
+	
+	/**
+	 * Together with the key {@link #PROPERTY_KEY__FIELD_TYPE} it indicates that
+	 * the field from data model should be presented by a MaskedDecimalField. <br>
+	 * Eg: <code>key="type" value="maskedDecimal"</code><p>
+	 * This type need to be used together with the key "mask".
+	 * Eg:  <code>var MaskedDecimal text properties (key="mask" value="#,#00.000")</code><p>
+	 */
+	public final static String PROPERTY_MASKED_DECIMAL = "maskedDecimal";
+	
+	/**
+	 * See {@link #PROPERTY_MASKED_TEXT}
+	 */
+	public final static String PROPERTY_MASK = "mask";
+
+	/**
+	 * Together with the key {@link #PROPERTY_KEY__FIELD_TYPE} it indicates that
+	 * the field from data model should be presented by a PasswordField. <br>
+	 * Eg: <code>key="type" value="Password"</code>
+	 */
+	public final static String PROPERTY_PASSWORD = "password";
+
+	/**
+	 * The key value for properties.<br>
+	 * Eg: <code>key="type" value="RichTextArea"</code> creates a RichTextArea
+	 * for the given data model attribute.
+	 */
+	public final static String PROPERTY_KEY__FIELD_TYPE = "type";
+
+	/** The Constant PROPERTY_GRID. */
+	public final static String PROPERTY_OPTION_GROUP = "optionGroup";
+
+	/** The Constant PROPERTY_GRID. */
+	public final static String PROPERTY_GRID = "grid";
+
+	/** The Constant PROPERTY_TABLE. */
+	public final static String PROPERTY_TABLE = "table";
+
+	/** The Constant PROPERTY_DECIMALFORMAT. */
+	public final static String PROPERTY_DECIMALFORMAT = "decimalformat";
+
+	/** The Constant PROPERTY_CLASS. */
+	public final static String PROPERTY_CLASS = "class";
+
+	/** The Constant PROPERTY_NAME. */
+	public final static String PROPERTY_NAME = "name";
+
+	/**
+	 * Defines the caption property name to be used in combo boxes, suggest text
+	 * fields,...
+	 */
+	public static final String PROPERTY__ITEM_CAPTION = "itemCaptionProperty";
+
+	/**
+	 * Defines the description property name to be used in combo boxes, suggest
+	 * text fields,...
+	 */
+	public static final String PROPERTY__ITEM_DESCRIPTION = "itemDescriptionProperty";
+
+	/**
+	 * Defines the filter property name to be used in suggest text fields,...
+	 */
+	public static final String PROPERTY__ITEM_FILTER = "itemFilterProperty";
+
+	/**
+	 * Defines the uuid property name to be used in suggest text fields,...
+	 */
+	public static final String PROPERTY__ITEM_UUID = "itemUUIDProperty";
+
+	/** The Constant PROPERTY_ORGANIZATION. */
+	public final static String PROPERTY_ORGANIZATION = "organization";
+
+	/** The Constant PROPERTY_PERSPECTIVE. */
+	public final static String PROPERTY_PERSPECTIVE = "perspective";
+
+	/** The Constant PROPERTY_SUGGESTTEXT. */
+	public final static String PROPERTY_SUGGESTTEXT = "suggestion";
+
+	/**
+	 * Does the layouting for model.
+	 *
+	 * @param layoutingInfo
+	 *            the layouting info
+	 */
+	void layout(YLayoutingInfo layoutingInfo);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategyProvider.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategyProvider.java
new file mode 100644
index 0000000..2b6abff
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategyProvider.java
@@ -0,0 +1,33 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.api;
+
+/**
+ * Is used to provide the default strategy. It needs to be passed in
+ * IViewContext.
+ */
+public interface ILayoutingStrategyProvider {
+
+	/** The Constant ACTIVE_PROVIDER_TOPIC. */
+	public static final String ACTIVE_PROVIDER_TOPIC = "org/eclipse/osbp/ecview/layouting/strategyprovider";
+
+	/**
+	 * Returns the ILayoutingStrategy that is assigned to this provider.
+	 *
+	 * @return the strategy
+	 */
+	ILayoutingStrategy getStrategy();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/.project b/org.eclipse.osbp.ecview.extension.editparts/.project
new file mode 100644
index 0000000..395434b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/.project
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.editparts</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.editparts/LICENSE.txt b/org.eclipse.osbp.ecview.extension.editparts/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.editparts/META-INF/MANIFEST.MF b/org.eclipse.osbp.ecview.extension.editparts/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..1f0d485
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/META-INF/MANIFEST.MF
@@ -0,0 +1,26 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.ecview.extension.editparts
+Bundle-SymbolicName: org.eclipse.osbp.ecview.extension.editparts
+Bundle-Version: 0.9.0.qualifier
+Bundle-Vendor: Eclipse OSBP
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Import-Package: org.osgi.service.component;version="1.2.0",
+ org.slf4j
+Bundle-ActivationPolicy: lazy
+Export-Package: org.eclipse.osbp.ecview.extension.editparts;
+  uses:="org.eclipse.osbp.ecview.core.common.editpart.binding,
+   org.eclipse.osbp.ecview.core.common.editpart";version="0.9.0",
+ org.eclipse.osbp.ecview.extension.editparts.components;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.editparts.converter;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.editparts.presentation;
+  uses:="org.eclipse.osbp.ecview.core.common.editpart.binding,
+   org.eclipse.osbp.ecview.core.common.presentation,
+   org.eclipse.osbp.ecview.extension.editparts";version="0.9.0",
+ org.eclipse.osbp.ecview.extension.editparts.strategies;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.editparts.visibility;version="0.9.0"
+Require-Bundle: org.eclipse.osbp.ecview.core.common;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.core.databinding;bundle-version="1.4.1",
+ org.eclipse.osbp.ecview.core.extension.editparts;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.runtime.common;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.ecview.extension.api;bundle-version="[0.9.0,0.10.0)"
diff --git a/org.eclipse.osbp.ecview.extension.editparts/about.html b/org.eclipse.osbp.ecview.extension.editparts/about.html
new file mode 100644
index 0000000..64c0598
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/about.html
@@ -0,0 +1,28 @@
+<!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>June 1, 2016</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &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>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.editparts/about.ini b/org.eclipse.osbp.ecview.extension.editparts/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/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.ecview.extension.editparts/about.mappings b/org.eclipse.osbp.ecview.extension.editparts/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/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.ecview.extension.editparts/about.properties b/org.eclipse.osbp.ecview.extension.editparts/about.properties
new file mode 100644
index 0000000..fe983b7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/about.properties
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.ecview.extension.editparts
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - implementation\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.ecview.extension.editparts/build.properties b/org.eclipse.osbp.ecview.extension.editparts/build.properties
new file mode 100644
index 0000000..61c9f3a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/build.properties
@@ -0,0 +1,9 @@
+source.. = src/
+bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
+               .settings/,\
+               .,\
+               LICENSE.txt,\
+               license.html
+output.. = target/classes
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
+               LICENSE.txt
diff --git a/org.eclipse.osbp.ecview.extension.editparts/epl-v10.html b/org.eclipse.osbp.ecview.extension.editparts/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.editparts/license.html b/org.eclipse.osbp.ecview.extension.editparts/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.editparts/notice.html b/org.eclipse.osbp.ecview.extension.editparts/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.editparts/pom.xml b/org.eclipse.osbp.ecview.extension.editparts/pom.xml
new file mode 100644
index 0000000..bea8261
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/pom.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial 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.ecview.extension.api</groupId>
+		<artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.ecview.extension.editparts</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<description>Contains the API for ui controller</description>
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+		<plugins>
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<source>1.6</source>
+					<target>1.6</target>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IContentSensitiveLayoutEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IContentSensitiveLayoutEditpart.java
new file mode 100644
index 0000000..b56f389
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IContentSensitiveLayoutEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IEmbeddableEditpart;
+
+/**
+ * The abstraction for a content sensitive layout.
+ */
+public interface IContentSensitiveLayoutEditpart extends IEmbeddableEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalFocusingEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalFocusingEditpart.java
new file mode 100644
index 0000000..4a3374a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalFocusingEditpart.java
@@ -0,0 +1,30 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.extension.editparts.strategies.IFocusingStrategyEditpart;
+
+/**
+ * For internal use only!.
+ */
+public interface IInternalFocusingEditpart extends IFocusingStrategyEditpart {
+
+	/**
+	 * Activates the focusing strategy. Should only be called from
+	 * IStrategyLayoutEditpart.
+	 */
+	void activate();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalLayoutingInfoEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalLayoutingInfoEditpart.java
new file mode 100644
index 0000000..52d28c1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalLayoutingInfoEditpart.java
@@ -0,0 +1,32 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+/**
+ * For internal use only!.
+ */
+public interface IInternalLayoutingInfoEditpart extends ILayoutingInfoEditpart {
+
+	/**
+	 * Activates the layout info. Should only be called from
+	 * IStrategyLayoutEditpart. Use {@link #requestActivate()} instead.
+	 */
+	void activate();
+	
+	/**
+	 * Activates the visibility processors.
+	 */
+	void postActivate();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalSuspectLayoutingInfoEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalSuspectLayoutingInfoEditpart.java
new file mode 100644
index 0000000..4301c6d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IInternalSuspectLayoutingInfoEditpart.java
@@ -0,0 +1,32 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+/**
+ * For internal use only!.
+ */
+public interface IInternalSuspectLayoutingInfoEditpart extends ISuspectLayoutingInfoEditpart {
+
+	/**
+	 * Activates the layout info. Should only be called from
+	 * IStrategyLayoutEditpart. Use {@link #requestActivate()} instead.
+	 */
+	void activate();
+
+	/**
+	 * Activates the visibility processors
+	 */
+	void postActivate();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ILayoutingInfoEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ILayoutingInfoEditpart.java
new file mode 100644
index 0000000..cbaf34e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ILayoutingInfoEditpart.java
@@ -0,0 +1,57 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+import org.eclipse.osbp.ecview.core.common.editpart.IEmbeddableEditpart;
+import org.eclipse.osbp.ecview.core.common.editpart.IViewEditpart;
+
+/**
+ * Is used to set the focus to a field.
+ * <p>
+ * Attention: Do not call {@link #dispose()}! Its for internal use only. Use
+ * {@link #requestDispose()}.
+ */
+public interface ILayoutingInfoEditpart extends IElementEditpart {
+
+	/**
+	 * Returns the view edit part of this editpart.<br>
+	 * May be <code>null</code> as far as this element and no of its parents are
+	 * attached to a view.
+	 * 
+	 * @return editpart The view editpart
+	 */
+	IViewEditpart getView();
+
+	/**
+	 * Returns the parent that contains this editpart.
+	 *
+	 * @return the parent
+	 */
+	IStrategyLayoutEditpart getParent();
+
+	/**
+	 * Returns the content editpart.
+	 *
+	 * @return the content
+	 */
+	IEmbeddableEditpart getContent();
+
+	/**
+	 * Requests disposal of the current editpart. This method will forward the
+	 * request to the parent if available and the parent will handle the steps
+	 * required to disposal the editpart properly.
+	 */
+	void requestDispose();
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedDecimalFieldEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedDecimalFieldEditpart.java
new file mode 100644
index 0000000..405eccb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedDecimalFieldEditpart.java
@@ -0,0 +1,20 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+public interface IMaskedDecimalFieldEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedNumericFieldEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedNumericFieldEditpart.java
new file mode 100644
index 0000000..bb5c920
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedNumericFieldEditpart.java
@@ -0,0 +1,20 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+public interface IMaskedNumericFieldEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedTextFieldEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedTextFieldEditpart.java
new file mode 100644
index 0000000..7948b36
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IMaskedTextFieldEditpart.java
@@ -0,0 +1,20 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+public interface IMaskedTextFieldEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IPrefixedMaskedTextFieldEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IPrefixedMaskedTextFieldEditpart.java
new file mode 100644
index 0000000..e374622
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IPrefixedMaskedTextFieldEditpart.java
@@ -0,0 +1,20 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+public interface IPrefixedMaskedTextFieldEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IQuantityTextFieldEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IQuantityTextFieldEditpart.java
new file mode 100644
index 0000000..cf95714
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IQuantityTextFieldEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+
+/**
+ * The Interface IQuantityTextFieldEditpart.
+ */
+public interface IQuantityTextFieldEditpart extends IElementEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IRichTextAreaEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IRichTextAreaEditpart.java
new file mode 100644
index 0000000..b0479c0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IRichTextAreaEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+/**
+ * The Interface IQuantityTextFieldEditpart.
+ */
+public interface IRichTextAreaEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IStrategyLayoutEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IStrategyLayoutEditpart.java
new file mode 100644
index 0000000..95a7084
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/IStrategyLayoutEditpart.java
@@ -0,0 +1,108 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import java.util.List;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IEmbeddableEditpart;
+import org.eclipse.osbp.ecview.core.common.services.IWidgetAssocationsService;
+
+import org.eclipse.osbp.ecview.extension.api.IFocusingEnhancer;
+import org.eclipse.osbp.ecview.extension.editparts.strategies.IFocusingStrategyEditpart;
+
+/**
+ * The abstraction for a strategy layout.
+ */
+public interface IStrategyLayoutEditpart extends IEmbeddableEditpart {
+
+	/**
+	 * Returns an unmodifiable list with all suspects contained in the layout.
+	 * 
+	 * @return elements The suspect editparts contained in this layout.
+	 */
+	List<ISuspectEditpart> getSuspects();
+
+	/**
+	 * Deactivates the info editpart.
+	 *
+	 * @param info
+	 *            the info
+	 */
+	void deactivate(ILayoutingInfoEditpart info);
+
+	/**
+	 * Activates the info editpart.
+	 *
+	 * @param info
+	 *            the info
+	 */
+	void activate(ILayoutingInfoEditpart info);
+
+	/**
+	 * Requests a new layouting for the whole layout.
+	 */
+	void requestLayouting();
+
+	/**
+	 * Calculates the next focused field and sets the focus. The passed source
+	 * and target parameter are the UI-Kit specific UI-elements that are
+	 * involved in the key stroke event. To support hybrid applications based on
+	 * ECView and native UI-Code, the original objects are passed.
+	 * <p>
+	 * Use {@link IWidgetAssocationsService} to map the given elements to their
+	 * model elements.
+	 * 
+	 * @param source
+	 *            - the source element the key stroke listener was registered at
+	 * @param target
+	 *            - the element the key stroke happened at
+	 * @param strategy
+	 *            - the strategy that requests focusing
+	 */
+	void requestFocusing(Object source, Object target,
+			IFocusingStrategyEditpart strategy);
+
+	/**
+	 * Will reset the current focusing strategies and applies the default one.
+	 */
+	void resetToDefaultFocusing();
+
+	/**
+	 * Requests a refresh of the strategy. Something internally changed. The key
+	 * stroke listener need to be removed and registered again.
+	 *
+	 * @param strategy
+	 *            the strategy
+	 */
+	void requestRefresh(IFocusingStrategyEditpart strategy);
+
+	/**
+	 * Find focusing enhancer service.
+	 *
+	 * @param id
+	 *            the id
+	 * @return the i focusing enhancer
+	 */
+	//TODO
+	public IFocusingEnhancer findFocusingEnhancerService(String id);
+	
+	/**
+	 * Find default focusing enhancer service.
+	 *
+	 * @return the i focusing enhancer
+	 */
+	//TODO
+	public IFocusingEnhancer findDefaultFocusingEnhancerService();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ISuspectEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ISuspectEditpart.java
new file mode 100644
index 0000000..4d40dbc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ISuspectEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+
+/**
+ * Is used to deal with suspects.
+ */
+public interface ISuspectEditpart extends IElementEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ISuspectLayoutingInfoEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ISuspectLayoutingInfoEditpart.java
new file mode 100644
index 0000000..f1c04b4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/ISuspectLayoutingInfoEditpart.java
@@ -0,0 +1,48 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+import org.eclipse.osbp.ecview.core.common.editpart.IViewEditpart;
+
+/**
+ * Is used to set the focus to a field.
+ */
+public interface ISuspectLayoutingInfoEditpart extends IElementEditpart {
+
+	/**
+	 * Returns the view edit part of this editpart.<br>
+	 * May be <code>null</code> as far as this element and no of its parents are
+	 * attached to a view.
+	 * 
+	 * @return editpart The view editpart
+	 */
+	IViewEditpart getView();
+
+	/**
+	 * Requests disposal of the current editpart. This method will forward the
+	 * request to the parent if available and the parent will handle the steps
+	 * required to dispose the editpart properly.
+	 */
+	void requestDispose();
+
+	/**
+	 * Returns the parent that contains this editpart.
+	 *
+	 * @return the parent
+	 */
+	ILayoutingInfoEditpart getParent();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IBlobUploadComponentEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IBlobUploadComponentEditpart.java
new file mode 100644
index 0000000..5d42200
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IBlobUploadComponentEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.components;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+/**
+ * The Interface IBlobUploadComponentEditpart.
+ */
+public interface IBlobUploadComponentEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/ICustomDecimalFieldEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/ICustomDecimalFieldEditpart.java
new file mode 100644
index 0000000..60ed220
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/ICustomDecimalFieldEditpart.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.ecview.extension.editparts.components;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+/**
+ * An edit part for text fields.
+ */
+public interface ICustomDecimalFieldEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IIconComboBoxEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IIconComboBoxEditpart.java
new file mode 100644
index 0000000..a4de845
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IIconComboBoxEditpart.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.ecview.extension.editparts.components;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+/**
+ * An edit part for icon combobox.
+ */
+public interface IIconComboBoxEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IPairComboBoxEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IPairComboBoxEditpart.java
new file mode 100644
index 0000000..77b9320
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/components/IPairComboBoxEditpart.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.ecview.extension.editparts.components;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IFieldEditpart;
+
+/**
+ * An edit part for icon combobox.
+ */
+public interface IPairComboBoxEditpart extends IFieldEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/ICustomDecimalConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/ICustomDecimalConverterEditpart.java
new file mode 100644
index 0000000..ae61a62
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/ICustomDecimalConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface ICustomDecimalConverterEditpart.
+ */
+public interface ICustomDecimalConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IDecimalToUomoConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IDecimalToUomoConverterEditpart.java
new file mode 100644
index 0000000..31a9432
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IDecimalToUomoConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface IDecimalToUomoConverterEditpart.
+ */
+public interface IDecimalToUomoConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/INumericToResourceConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/INumericToResourceConverterEditpart.java
new file mode 100644
index 0000000..7dbcc69
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/INumericToResourceConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface INumericToResourceConverterEditpart.
+ */
+public interface INumericToResourceConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/INumericToUomoConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/INumericToUomoConverterEditpart.java
new file mode 100644
index 0000000..4345fad
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/INumericToUomoConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface INumericToUomoConverterEditpart.
+ */
+public interface INumericToUomoConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IObjectToStringConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IObjectToStringConverterEditpart.java
new file mode 100644
index 0000000..f9272dc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IObjectToStringConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface IObjectToStringConverterEditpart.
+ */
+public interface IObjectToStringConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IPriceToStringConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IPriceToStringConverterEditpart.java
new file mode 100644
index 0000000..ed58b62
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IPriceToStringConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface IPriceToStringConverterEditpart.
+ */
+public interface IPriceToStringConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IQuantityToStringConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IQuantityToStringConverterEditpart.java
new file mode 100644
index 0000000..07d8e55
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IQuantityToStringConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface IQuantityToStringConverterEditpart.
+ */
+public interface IQuantityToStringConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/ISimpleDecimalConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/ISimpleDecimalConverterEditpart.java
new file mode 100644
index 0000000..ff91a08
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/ISimpleDecimalConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface ISimpleDecimalConverterEditpart.
+ */
+public interface ISimpleDecimalConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IStringToResourceConverterEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IStringToResourceConverterEditpart.java
new file mode 100644
index 0000000..50efcec
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/converter/IStringToResourceConverterEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.converter;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IConverterEditpart;
+
+/**
+ * The Interface IStringToResourceConverterEditpart.
+ */
+public interface IStringToResourceConverterEditpart extends IConverterEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/presentation/IStrategyLayoutPresentation.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/presentation/IStrategyLayoutPresentation.java
new file mode 100644
index 0000000..6532299
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/presentation/IStrategyLayoutPresentation.java
@@ -0,0 +1,59 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.presentation;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IEmbeddableEditpart;
+import org.eclipse.osbp.ecview.core.common.editpart.IKeyStrokeDefinitionEditpart;
+import org.eclipse.osbp.ecview.core.common.presentation.IWidgetPresentation;
+import org.eclipse.osbp.runtime.common.keystroke.KeyStrokeCallback;
+
+/**
+ * An presentation abstraction for the StrategyLayout.
+ *
+ * @param <C>
+ *            the generic type
+ */
+public interface IStrategyLayoutPresentation<C> extends IWidgetPresentation<C> {
+
+	/**
+	 * Sets the content editpart.
+	 *
+	 * @param contentEditpart
+	 *            the new content
+	 */
+	void setContent(IEmbeddableEditpart contentEditpart);
+
+	/**
+	 * Registers a keystroke handler for the given callback. If a handler is
+	 * already installed, for the given callback, the call will be ignored.
+	 *
+	 * @param keyStrokeDefEditpart
+	 *            the key stroke def editpart
+	 * @param callback
+	 *            - the callback that should be invoked, if the key stroke was
+	 *            pressed.
+	 */
+	void registerKeyStroke(IKeyStrokeDefinitionEditpart keyStrokeDefEditpart,
+			KeyStrokeCallback callback);
+
+	/**
+	 * Unregisters the keystroke for the given callback.
+	 *
+	 * @param callback
+	 *            the callback
+	 */
+	void unregisterKeyStroke(KeyStrokeCallback callback);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDefaultFocusingStrategyEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDefaultFocusingStrategyEditpart.java
new file mode 100644
index 0000000..bb95cdd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDefaultFocusingStrategyEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.strategies;
+
+
+/**
+ * Is used to set the focus to a field.
+ */
+public interface IDefaultFocusingStrategyEditpart extends IFocusingStrategyEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDefaultLayoutingStrategyEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDefaultLayoutingStrategyEditpart.java
new file mode 100644
index 0000000..ebbfc9d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDefaultLayoutingStrategyEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.strategies;
+
+
+/**
+ * Is used to set the focus to a field.
+ */
+public interface IDefaultLayoutingStrategyEditpart extends ILayoutingStrategyEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDelegatingFocusingStrategyEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDelegatingFocusingStrategyEditpart.java
new file mode 100644
index 0000000..48c6a5c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDelegatingFocusingStrategyEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.strategies;
+
+
+/**
+ * Is used to set the focus to a field.
+ */
+public interface IDelegatingFocusingStrategyEditpart extends IFocusingStrategyEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDelegatingLayoutingStrategyEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDelegatingLayoutingStrategyEditpart.java
new file mode 100644
index 0000000..78b48ba
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IDelegatingLayoutingStrategyEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.strategies;
+
+/**
+ * Is used to set the layout.
+ */
+public interface IDelegatingLayoutingStrategyEditpart extends
+		ILayoutingStrategyEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IFocusingStrategyEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IFocusingStrategyEditpart.java
new file mode 100644
index 0000000..fbd3767
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/IFocusingStrategyEditpart.java
@@ -0,0 +1,66 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.strategies;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+import org.eclipse.osbp.ecview.core.common.editpart.IKeyStrokeDefinitionEditpart;
+import org.eclipse.osbp.ecview.core.common.editpart.IViewEditpart;
+import org.eclipse.osbp.ecview.core.common.services.IWidgetAssocationsService;
+
+/**
+ * Is used to set the focus to a field.
+ */
+public interface IFocusingStrategyEditpart extends IElementEditpart {
+
+	/**
+	 * Calculates the next focused field and sets the focus. The passed source
+	 * and target parameter are the UI-Kit specific UI-elements that are
+	 * involved in the key stroke event. To support hybrid applications based on
+	 * ECView and native UI-Code, the original objects are passed.
+	 * <p>
+	 * Use {@link IWidgetAssocationsService} to map the given elements to their
+	 * model elements.
+	 * 
+	 * @param source
+	 *            - the source element the key stroke listener was registered at
+	 * @param target
+	 *            - the element the key stroke happened at
+	 */
+	void focus(Object source, Object target);
+
+	/**
+	 * Returns the view edit part of this editpart.<br>
+	 * May be <code>null</code> as far as this element and no of its parents are
+	 * attached to a view.
+	 * 
+	 * @return editpart The view editpart
+	 */
+	IViewEditpart getView();
+
+	/**
+	 * Returns the parent that contains this editpart.
+	 *
+	 * @return the parent
+	 */
+	IElementEditpart getParent();
+
+	/**
+	 * Returns the keystroke definition that will trigger this focusing
+	 * strategy.
+	 *
+	 * @return the key stroke definition
+	 */
+	IKeyStrokeDefinitionEditpart getKeyStrokeDefinition();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/ILayoutingStrategyEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/ILayoutingStrategyEditpart.java
new file mode 100644
index 0000000..2afc21c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/strategies/ILayoutingStrategyEditpart.java
@@ -0,0 +1,54 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.strategies;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+import org.eclipse.osbp.ecview.core.common.editpart.IViewEditpart;
+
+import org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart;
+
+/**
+ * Is used to layout the given model properly.
+ */
+public interface ILayoutingStrategyEditpart extends IElementEditpart {
+
+	/**
+	 * Does the layouting for the model.
+	 */
+	void layout();
+
+	/**
+	 * Returns the view edit part of this editpart.<br>
+	 * May be <code>null</code> as far as this element and no of its parents are
+	 * attached to a view.
+	 * 
+	 * @return editpart The view editpart
+	 */
+	IViewEditpart getView();
+
+	/**
+	 * Requests disposal of the current editpart. This method will forward the
+	 * request to the parent if available and the parent will handle the steps
+	 * required to dispose the editpart properly.
+	 */
+	void requestDispose();
+
+	/**
+	 * Returns the parent that contains this editpart.
+	 *
+	 * @return the parent
+	 */
+	IStrategyLayoutEditpart getParent();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/visibility/IAuthorizationVisibilityProcessorEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/visibility/IAuthorizationVisibilityProcessorEditpart.java
new file mode 100644
index 0000000..1f57719
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/visibility/IAuthorizationVisibilityProcessorEditpart.java
@@ -0,0 +1,24 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.visibility;
+
+import org.eclipse.osbp.ecview.core.common.editpart.visibility.IVisibilityProcessorEditpart;
+
+/**
+ * The Interface IAuthorizationVisibilityProcessorEditpart.
+ */
+public interface IAuthorizationVisibilityProcessorEditpart extends
+		IVisibilityProcessorEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/visibility/ISubTypeVisibilityProcessorEditpart.java b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/visibility/ISubTypeVisibilityProcessorEditpart.java
new file mode 100644
index 0000000..b186a59
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.editparts/src/org/eclipse/osbp/ecview/extension/editparts/visibility/ISubTypeVisibilityProcessorEditpart.java
@@ -0,0 +1,24 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.editparts.visibility;
+
+import org.eclipse.osbp.ecview.core.common.editpart.visibility.IVisibilityProcessorEditpart;
+
+/**
+ * The Interface ISubTypeVisibilityProcessorEditpart.
+ */
+public interface ISubTypeVisibilityProcessorEditpart extends
+		IVisibilityProcessorEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/.project b/org.eclipse.osbp.ecview.extension.grid.editparts/.project
new file mode 100644
index 0000000..624fc95
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/.project
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.grid.editparts</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ds.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/LICENSE.txt b/org.eclipse.osbp.ecview.extension.grid.editparts/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/META-INF/MANIFEST.MF b/org.eclipse.osbp.ecview.extension.grid.editparts/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..ecfadf1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/META-INF/MANIFEST.MF
@@ -0,0 +1,26 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.ecview.extension.grid.editparts
+Bundle-SymbolicName: org.eclipse.osbp.ecview.extension.grid.editparts
+Bundle-Version: 0.9.0.qualifier
+Bundle-Vendor: Eclipse OSBP
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Import-Package: org.osgi.service.component;version="1.2.0",
+ org.osgi.service.component.annotations;version="1.2.0",
+ org.slf4j
+Bundle-ActivationPolicy: lazy
+Export-Package: org.eclipse.osbp.ecview.extension.grid.editparts;
+  uses:="org.eclipse.osbp.ecview.core.common.editpart.binding,
+   org.eclipse.osbp.ecview.core.common.editpart";version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.editparts.presentation;
+  uses:="org.eclipse.osbp.ecview.core.common.editpart.binding,
+   org.eclipse.osbp.ecview.core.common.presentation,
+   org.eclipse.osbp.ecview.extension.editparts";version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.editparts.renderer;version="0.9.0"
+Require-Bundle: org.eclipse.osbp.ecview.core.common;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.core.databinding;bundle-version="1.4.1",
+ org.eclipse.osbp.ecview.core.extension.editparts;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.runtime.common;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.emf.ecore;bundle-version="2.10.2"
+Service-Component: OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.renderer.DelegatingGridRendererFactory$ServiceComponent.xml,
+ OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.DelegatingGridCellStyleGeneratorFactory$ServiceComponent.xml
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.DelegatingGridCellStyleGeneratorFactory$ServiceComponent.xml b/org.eclipse.osbp.ecview.extension.grid.editparts/OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.DelegatingGridCellStyleGeneratorFactory$ServiceComponent.xml
new file mode 100644
index 0000000..edc1dde
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.DelegatingGridCellStyleGeneratorFactory$ServiceComponent.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" activate="activate" deactivate="deactivate" immediate="true" name="org.eclipse.osbp.ecview.extension.grid.editparts.DelegatingGridCellStyleGeneratorFactory$ServiceComponent">
+   <reference bind="addDelegate" cardinality="0..n" interface="org.eclipse.osbp.ecview.extension.grid.editparts.presentation.IGridCellStyleGeneratorFactory" name="Delegate" policy="dynamic" unbind="removeDelegate"/>
+   <implementation class="org.eclipse.osbp.ecview.extension.grid.editparts.DelegatingGridCellStyleGeneratorFactory$ServiceComponent"/>
+</scr:component>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.renderer.DelegatingGridRendererFactory$ServiceComponent.xml b/org.eclipse.osbp.ecview.extension.grid.editparts/OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.renderer.DelegatingGridRendererFactory$ServiceComponent.xml
new file mode 100644
index 0000000..43094a0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/OSGI-INF/org.eclipse.osbp.ecview.extension.grid.editparts.renderer.DelegatingGridRendererFactory$ServiceComponent.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" activate="activate" deactivate="deactivate" immediate="true" name="org.eclipse.osbp.ecview.extension.grid.editparts.renderer.DelegatingGridRendererFactory$ServiceComponent">
+   <reference bind="addDelegate" cardinality="0..n" interface="org.eclipse.osbp.ecview.extension.grid.editparts.renderer.IGridRendererFactory" name="Delegate" policy="dynamic" unbind="removeDelegate"/>
+   <implementation class="org.eclipse.osbp.ecview.extension.grid.editparts.renderer.DelegatingGridRendererFactory$ServiceComponent"/>
+</scr:component>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/about.html b/org.eclipse.osbp.ecview.extension.grid.editparts/about.html
new file mode 100644
index 0000000..64c0598
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/about.html
@@ -0,0 +1,28 @@
+<!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>June 1, 2016</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &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>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/about.ini b/org.eclipse.osbp.ecview.extension.grid.editparts/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/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.ecview.extension.grid.editparts/about.mappings b/org.eclipse.osbp.ecview.extension.grid.editparts/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/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.ecview.extension.grid.editparts/about.properties b/org.eclipse.osbp.ecview.extension.grid.editparts/about.properties
new file mode 100644
index 0000000..97e3e7e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/about.properties
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.ecview.extension.grid.editparts
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - implementation\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/build.properties b/org.eclipse.osbp.ecview.extension.grid.editparts/build.properties
new file mode 100644
index 0000000..0a87dff
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/build.properties
@@ -0,0 +1,11 @@
+source.. = src/
+bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
+               .,\
+               OSGI-INF/,\
+               license.html,\
+               LICENSE.txt,\
+               epl-v10.html
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
+               LICENSE.txt,\
+               epl-v10.html			   
+output.. = target/classes
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/epl-v10.html b/org.eclipse.osbp.ecview.extension.grid.editparts/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/license.html b/org.eclipse.osbp.ecview.extension.grid.editparts/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/notice.html b/org.eclipse.osbp.ecview.extension.grid.editparts/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.grid.editparts/pom.xml b/org.eclipse.osbp.ecview.extension.grid.editparts/pom.xml
new file mode 100644
index 0000000..0b4d59e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/pom.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial 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.ecview.extension.api</groupId>
+		<artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.ecview.extension.grid.editparts</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<description>Contains the API for Vaadin Grid</description>
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+		<plugins>
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<source>1.6</source>
+					<target>1.6</target>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/DelegatingGridCellStyleGeneratorFactory.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/DelegatingGridCellStyleGeneratorFactory.java
new file mode 100644
index 0000000..3e04aaa
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/DelegatingGridCellStyleGeneratorFactory.java
@@ -0,0 +1,206 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.osbp.ecview.core.common.context.IViewContext;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferenceCardinality;
+import org.osgi.service.component.annotations.ReferencePolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.eclipse.osbp.ecview.extension.grid.editparts.presentation.IGridCellStyleGeneratorFactory;
+
+/**
+ * Delegates the calls to the implementing services provided by OSGi-DS.
+ */
+public final class DelegatingGridCellStyleGeneratorFactory implements
+		IGridCellStyleGeneratorFactory {
+
+	private static final Logger LOGGER = LoggerFactory
+			.getLogger(DelegatingGridCellStyleGeneratorFactory.class);
+	private static DelegatingGridCellStyleGeneratorFactory instance = new DelegatingGridCellStyleGeneratorFactory();
+
+	private final List<IGridCellStyleGeneratorFactory> delegates = Collections
+			.synchronizedList(new ArrayList<IGridCellStyleGeneratorFactory>());
+	private List<IGridCellStyleGeneratorFactory> stashed;
+
+	private DelegatingGridCellStyleGeneratorFactory() {
+	}
+
+	/**
+	 * Returns the instance of that manager.
+	 * 
+	 * @return the instance
+	 */
+	public static DelegatingGridCellStyleGeneratorFactory getInstance() {
+		return instance;
+	}
+
+	/**
+	 * Removes all factories. Should only be used very carefully
+	 */
+	public void clear() {
+		delegates.clear();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public boolean isFor(IViewContext uiContext,
+			IGridCellStyleGeneratorEditpart editpart) {
+		for (IGridCellStyleGeneratorFactory factory : delegates
+				.toArray(new IGridCellStyleGeneratorFactory[delegates.size()])) {
+			if (factory.isFor(uiContext, editpart)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public Object createCellStyleGenerator(IViewContext uiContext,
+			IGridCellStyleGeneratorEditpart editpart)
+			throws IllegalArgumentException {
+		for (IGridCellStyleGeneratorFactory factory : delegates
+				.toArray(new IGridCellStyleGeneratorFactory[delegates.size()])) {
+			if (factory.isFor(uiContext, editpart)) {
+				try {
+					Object result = factory
+							.createCellStyleGenerator(uiContext, editpart);
+					if (result != null) {
+						return result;
+					}
+				} catch (IllegalArgumentException e) {
+					// nothing to do. Try the next factory
+				}
+			}
+		}
+		LOGGER.error("No proper converterFactory found for elements {} {}",
+				new Object[] { uiContext, editpart });
+		return null;
+	}
+
+	/**
+	 * Will stash the current state. ONLY FOR TESTS!
+	 */
+	public void stash() {
+		if (stashed != null) {
+			return;
+		}
+		stashed = new ArrayList<IGridCellStyleGeneratorFactory>(delegates);
+	}
+
+	/**
+	 * Will unstash the stashed state. ONLY FOR TESTS!
+	 */
+	public void unstash() {
+		if (stashed == null) {
+			return;
+		}
+		delegates.clear();
+		delegates.addAll(stashed);
+		stashed = null;
+	}
+
+	/**
+	 * Adds a new factory to the manager.
+	 * 
+	 * @param factory
+	 *            Factory to be added.
+	 */
+	public void addDelegate(IGridCellStyleGeneratorFactory factory) {
+		if (!delegates.contains(factory)) {
+			delegates.add(factory);
+		}
+	}
+
+	/**
+	 * Removes the factory from the manager.
+	 * 
+	 * @param factory
+	 *            Factory to be removed.
+	 */
+	public void removeDelegate(IGridCellStyleGeneratorFactory factory) {
+		if (factory == null) {
+			return;
+		}
+		delegates.remove(factory);
+	}
+
+	/**
+	 * OSGi-DS component.
+	 */
+	@Component(immediate=true, service={})
+	public static class ServiceComponent {
+
+		/**
+		 * Called by OSGi-DS.
+		 * 
+		 * @param context
+		 *            Component context
+		 * @param properties
+		 *            Map of properties
+		 */
+		@Activate
+		public void activate(ComponentContext context,
+				Map<String, Object> properties) {
+			LOGGER.debug("DelegatingPresenterFactory activated");
+		}
+
+		/**
+		 * Called by OSGi-DS.
+		 * 
+		 * @param context
+		 *            Component context
+		 * @param properties
+		 *            Map of properties
+		 */
+		@Deactivate
+		public void deactivate(ComponentContext context,
+				Map<String, Object> properties) {
+			LOGGER.debug("DelegatingPresenterFactory deactivated");
+		}
+
+		/**
+		 * Called by OSGi DS.
+		 * 
+		 * @param factory
+		 *            Factory to be added
+		 */
+		@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC, unbind = "removeDelegate")
+		protected void addDelegate(IGridCellStyleGeneratorFactory factory) {
+			DelegatingGridCellStyleGeneratorFactory.getInstance().addDelegate(
+					factory);
+		}
+
+		/**
+		 * Called by OSGi DS.
+		 * 
+		 * @param factory
+		 *            Factory to be added
+		 */
+		protected void removeDelegate(IGridCellStyleGeneratorFactory factory) {
+			DelegatingGridCellStyleGeneratorFactory.getInstance()
+					.removeDelegate(factory);
+		}
+	}
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridCellStyleGeneratorEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridCellStyleGeneratorEditpart.java
new file mode 100644
index 0000000..1aa0917
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridCellStyleGeneratorEditpart.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+
+public interface IGridCellStyleGeneratorEditpart extends IElementEditpart {
+
+	/**
+	 * Create and returns the UI-Kit specific converter.
+	 * 
+	 * @return
+	 */
+	Object getDelegate();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridColumnEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridColumnEditpart.java
new file mode 100644
index 0000000..69d8a1d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridColumnEditpart.java
@@ -0,0 +1,80 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+import org.eclipse.osbp.runtime.common.dispose.IDisposable;
+
+/**
+ * The abstraction for a grid column.
+ */
+public interface IGridColumnEditpart extends IElementEditpart {
+
+	/**
+	 * Is called from the grid presentation and sets the reference to the UI
+	 * column.
+	 *
+	 * @param column
+	 *            the new column reference
+	 */
+	void setColumnReference(ColumnReference column);
+
+	/**
+	 * Returns a reference to the column.
+	 *
+	 * @return the column reference
+	 */
+	ColumnReference getColumnReference();
+
+	/**
+	 * Initializes the column.
+	 */
+	void initializeColumn();
+
+	/**
+	 * The Interface ColumnReference.
+	 */
+	interface ColumnReference extends IDisposable {
+
+		/**
+		 * Sets the new converter for the column.
+		 *
+		 * @param converter
+		 *            the new converter
+		 */
+		void setConverter(Object converter);
+
+		/**
+		 * Sets the new renderer for the column. If datatypes of model and
+		 * renderer do not match, a proper converter need to be passed too.
+		 *
+		 * @param renderer
+		 *            the renderer
+		 * @param converter
+		 *            the converter
+		 */
+		void setRenderer(Object renderer, Object converter);
+
+		/**
+		 * Updates the properties.
+		 */
+		void updateProperties();
+
+		/**
+		 * Updates the editor field.
+		 */
+		void updateEditorField();
+	}
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridDelegateCellStyleGeneratorEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridDelegateCellStyleGeneratorEditpart.java
new file mode 100644
index 0000000..45fc6db
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridDelegateCellStyleGeneratorEditpart.java
@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+public interface IGridDelegateCellStyleGeneratorEditpart extends
+		IGridCellStyleGeneratorEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridEditpart.java
new file mode 100644
index 0000000..69722f1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridEditpart.java
@@ -0,0 +1,35 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+import java.util.Map;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IEmbeddableEditpart;
+
+/**
+ * The abstraction for a grid element.
+ */
+public interface IGridEditpart extends IEmbeddableEditpart {
+
+	/**
+	 * Sets the filter properties and their value. Map#key is a nested property
+	 * path. Map#value is the filter value.<br>
+	 * All entries will be used as Equals-Filter and will be joined by And.
+	 *
+	 * @param filterProps
+	 *            the filter props
+	 */
+	void setFilter(Map<String, Object> filterProps);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridFooterRowEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridFooterRowEditpart.java
new file mode 100644
index 0000000..fd8077a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridFooterRowEditpart.java
@@ -0,0 +1,21 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+/**
+ * The Interface IGridFooterRowEditpart.
+ */
+public interface IGridFooterRowEditpart extends IGridMetaRowEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridHeaderRowEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridHeaderRowEditpart.java
new file mode 100644
index 0000000..622abcf
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridHeaderRowEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+
+/**
+ * The Interface IGridHeaderRowEditpart.
+ */
+public interface IGridHeaderRowEditpart extends IGridMetaRowEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridMetaCellEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridMetaCellEditpart.java
new file mode 100644
index 0000000..ceb9fb4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridMetaCellEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+
+/**
+ * The Interface IGridMetaCellEditpart.
+ */
+public interface IGridMetaCellEditpart extends IElementEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridMetaRowEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridMetaRowEditpart.java
new file mode 100644
index 0000000..380cecf
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/IGridMetaRowEditpart.java
@@ -0,0 +1,23 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+
+/**
+ * The Interface IGridMetaRowEditpart.
+ */
+public interface IGridMetaRowEditpart extends IElementEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/presentation/IGridCellStyleGeneratorFactory.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/presentation/IGridCellStyleGeneratorFactory.java
new file mode 100644
index 0000000..c646203
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/presentation/IGridCellStyleGeneratorFactory.java
@@ -0,0 +1,51 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.presentation;
+
+import org.eclipse.osbp.ecview.core.common.context.IViewContext;
+import org.eclipse.osbp.ecview.core.common.presentation.IWidgetPresentation;
+
+import org.eclipse.osbp.ecview.extension.grid.editparts.IGridCellStyleGeneratorEditpart;
+
+/**
+ * Is used to create UI-Kit specific cellStyleGenerators.
+ */
+public interface IGridCellStyleGeneratorFactory {
+
+	/**
+	 * Returns true, if the factory can be used for the given element.
+	 * 
+	 * @param uiContext
+	 *            contains information about the current ui instance
+	 * @param editpart
+	 *            the editpart for which a cellStyleGenerator should be created.
+	 * @return result
+	 */
+	boolean isFor(IViewContext uiContext, IGridCellStyleGeneratorEditpart editpart);
+
+	/**
+	 * Is used to create a new instance of a cellStyleGenerator.
+	 *
+	 * @param uiContext
+	 *            contains information about the current ui instance
+	 * @param editpart
+	 *            the editpart for which a cellStyleGenerator should be created.
+	 * @return cellStyleGenerator
+	 * @throws IllegalArgumentException
+	 *             if no presentation could be created.
+	 */
+	Object createCellStyleGenerator(IViewContext uiContext,
+			IGridCellStyleGeneratorEditpart editpart)
+			throws IllegalArgumentException;
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/presentation/IGridPresentation.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/presentation/IGridPresentation.java
new file mode 100644
index 0000000..3b57bb7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/presentation/IGridPresentation.java
@@ -0,0 +1,69 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.presentation;
+
+import java.util.Map;
+
+import org.eclipse.osbp.ecview.core.common.presentation.IWidgetPresentation;
+import org.eclipse.osbp.runtime.common.memento.IMementoHandler;
+
+/**
+ * An presentation abstraction for the StrategyLayout.
+ *
+ * @param <C>
+ *            the generic type
+ */
+public interface IGridPresentation<C> extends IWidgetPresentation<C>,
+		IMementoHandler {
+
+	/**
+	 * Is used by the editpart to update the header.
+	 */
+	public void updateHeader();
+
+	/**
+	 * Is used by the editpart to update the footer.
+	 */
+	public void updateFooter();
+
+	/**
+	 * Is used by the editpart to update the columns.
+	 */
+	public void updateColumns();
+
+	/**
+	 * Updates the selection type based on the underlying model.
+	 */
+	public void updateSelectionType();
+
+	/**
+	 * Updates the filter in the grid.
+	 */
+	public void updateFilter();
+
+	/**
+	 * Updates the cell style generator.
+	 */
+	public void updateCellStyleGenerator();
+
+	/**
+	 * Sets a UI Kit specific filter. All properties will resolved to
+	 * Equals-Filter and be joined by ADD.
+	 *
+	 * @param filter
+	 *            the filter
+	 */
+	public void setFilter(Map<String, Object> filter);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/DelegatingGridRendererFactory.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/DelegatingGridRendererFactory.java
new file mode 100644
index 0000000..f3a9885
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/DelegatingGridRendererFactory.java
@@ -0,0 +1,215 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.osbp.ecview.core.common.context.IViewContext;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferenceCardinality;
+import org.osgi.service.component.annotations.ReferencePolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Delegates the calls to the implementing services provided by OSGi-DS.
+ */
+public final class DelegatingGridRendererFactory implements
+		IGridRendererFactory {
+
+	/** The Constant LOGGER. */
+	private static final Logger LOGGER = LoggerFactory
+			.getLogger(DelegatingGridRendererFactory.class);
+	
+	/** The instance. */
+	private static DelegatingGridRendererFactory instance = new DelegatingGridRendererFactory();
+
+	/** The delegates. */
+	private final List<IGridRendererFactory> delegates = Collections
+			.synchronizedList(new ArrayList<IGridRendererFactory>());
+	
+	/** The stashed. */
+	private List<IGridRendererFactory> stashed;
+
+	/**
+	 * Instantiates a new delegating grid renderer factory.
+	 */
+	private DelegatingGridRendererFactory() {
+	}
+
+	/**
+	 * Returns the instance of that manager.
+	 * 
+	 * @return the instance
+	 */
+	public static DelegatingGridRendererFactory getInstance() {
+		return instance;
+	}
+
+	/**
+	 * Removes all factories. Should only be used very carefully
+	 */
+	public void clear() {
+		delegates.clear();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public boolean isFor(IViewContext uiContext, IGridRendererEditpart editpart) {
+		for (IGridRendererFactory factory : delegates
+				.toArray(new IGridRendererFactory[delegates.size()])) {
+			if (factory.isFor(uiContext, editpart)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.editparts.renderer.IGridRendererFactory#createRenderer(org.eclipse.osbp.ecview.core.common.context.IViewContext, org.eclipse.osbp.ecview.extension.grid.editparts.renderer.IGridRendererEditpart)
+	 */
+	@Override
+	public Object createRenderer(IViewContext uiContext,
+			IGridRendererEditpart editpart) throws IllegalArgumentException {
+		for (IGridRendererFactory factory : delegates
+				.toArray(new IGridRendererFactory[delegates.size()])) {
+			if (factory.isFor(uiContext, editpart)) {
+				try {
+					Object result = factory.createRenderer(uiContext, editpart);
+					if (result != null) {
+						return result;
+					}
+				} catch (IllegalArgumentException e) {
+					// nothing to do. Try the next factory
+				}
+			}
+		}
+		LOGGER.error("No proper converterFactory found for elements {} {}",
+				new Object[] { uiContext, editpart });
+		return null;
+	}
+
+	/**
+	 * Will stash the current state. ONLY FOR TESTS!
+	 */
+	public void stash() {
+		if (stashed != null) {
+			return;
+		}
+		stashed = new ArrayList<IGridRendererFactory>(delegates);
+	}
+
+	/**
+	 * Will unstash the stashed state. ONLY FOR TESTS!
+	 */
+	public void unstash() {
+		if (stashed == null) {
+			return;
+		}
+		delegates.clear();
+		delegates.addAll(stashed);
+		stashed = null;
+	}
+
+	/**
+	 * Adds a new factory to the manager.
+	 * 
+	 * @param factory
+	 *            Factory to be added.
+	 */
+	public void addDelegate(IGridRendererFactory factory) {
+		if (!delegates.contains(factory)) {
+			delegates.add(factory);
+		}
+	}
+
+	/**
+	 * Removes the factory from the manager.
+	 * 
+	 * @param factory
+	 *            Factory to be removed.
+	 */
+	public void removeDelegate(IGridRendererFactory factory) {
+		if (factory == null) {
+			return;
+		}
+		delegates.remove(factory);
+	}
+
+	/**
+	 * OSGi-DS component.
+	 */
+	@Component(immediate = true, service = {})
+	public static class ServiceComponent {
+
+		/**
+		 * Called by OSGi-DS.
+		 * 
+		 * @param context
+		 *            Component context
+		 * @param properties
+		 *            Map of properties
+		 */
+		@Activate
+		public void activate(ComponentContext context,
+				Map<String, Object> properties) {
+			LOGGER.debug("DelegatingPresenterFactory activated");
+		}
+
+		/**
+		 * Called by OSGi-DS.
+		 * 
+		 * @param context
+		 *            Component context
+		 * @param properties
+		 *            Map of properties
+		 */
+		@Deactivate
+		public void deactivate(ComponentContext context,
+				Map<String, Object> properties) {
+			LOGGER.debug("DelegatingPresenterFactory deactivated");
+		}
+
+		/**
+		 * Called by OSGi DS.
+		 * 
+		 * @param factory
+		 *            Factory to be added
+		 */
+		@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC, unbind = "removeDelegate")
+		protected void addDelegate(IGridRendererFactory factory) {
+			DelegatingGridRendererFactory.getInstance().addDelegate(factory);
+		}
+
+		/**
+		 * Called by OSGi DS.
+		 * 
+		 * @param factory
+		 *            Factory to be added
+		 */
+		protected void removeDelegate(IGridRendererFactory factory) {
+			DelegatingGridRendererFactory.getInstance().removeDelegate(factory);
+		}
+	}
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridBooleanRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridBooleanRendererEditpart.java
new file mode 100644
index 0000000..964434b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridBooleanRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridBooleanRendererEditpart.
+ */
+public interface IGridBooleanRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridButtonRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridButtonRendererEditpart.java
new file mode 100644
index 0000000..824a169
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridButtonRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridButtonRendererEditpart.
+ */
+public interface IGridButtonRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridDateRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridDateRendererEditpart.java
new file mode 100644
index 0000000..e427313
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridDateRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridDateRendererEditpart.
+ */
+public interface IGridDateRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridHtmlRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridHtmlRendererEditpart.java
new file mode 100644
index 0000000..d992bc7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridHtmlRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridHtmlRendererEditpart.
+ */
+public interface IGridHtmlRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridImageRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridImageRendererEditpart.java
new file mode 100644
index 0000000..e7cb972
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridImageRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridImageRendererEditpart.
+ */
+public interface IGridImageRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridIndicatorRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridIndicatorRendererEditpart.java
new file mode 100644
index 0000000..94cbe95
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridIndicatorRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridIndicatorRendererEditpart.
+ */
+public interface IGridIndicatorRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridNumberRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridNumberRendererEditpart.java
new file mode 100644
index 0000000..f18112b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridNumberRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridNumberRendererEditpart.
+ */
+public interface IGridNumberRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridPriceRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridPriceRendererEditpart.java
new file mode 100644
index 0000000..8a810b4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridPriceRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridPriceRendererEditpart.
+ */
+public interface IGridPriceRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridProgressbarRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridProgressbarRendererEditpart.java
new file mode 100644
index 0000000..799c2ba
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridProgressbarRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridProgressbarRendererEditpart.
+ */
+public interface IGridProgressbarRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridQuantityRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridQuantityRendererEditpart.java
new file mode 100644
index 0000000..c242bbd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridQuantityRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridQuantityRendererEditpart.
+ */
+public interface IGridQuantityRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererEditpart.java
new file mode 100644
index 0000000..7d18642
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererEditpart.java
@@ -0,0 +1,31 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+import org.eclipse.osbp.ecview.core.common.editpart.IElementEditpart;
+
+/**
+ * The Interface IGridRendererEditpart.
+ */
+public interface IGridRendererEditpart extends IElementEditpart {
+
+	/**
+	 * Create and returns the UI-Kit specific renderer.
+	 *
+	 * @return the object
+	 */
+	Object createDelegate();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererFactory.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererFactory.java
new file mode 100644
index 0000000..3f77cdc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererFactory.java
@@ -0,0 +1,48 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+import org.eclipse.osbp.ecview.core.common.context.IViewContext;
+import org.eclipse.osbp.ecview.core.common.presentation.IWidgetPresentation;
+
+/**
+ * Is used to create UI-Kit specific renderers.
+ */
+public interface IGridRendererFactory {
+
+	/**
+	 * Returns true, if the factory can be used for the given element.
+	 * 
+	 * @param uiContext
+	 *            contains information about the current ui instance
+	 * @param editpart
+	 *            the editpart for which a renderer should be created.
+	 * @return result
+	 */
+	boolean isFor(IViewContext uiContext, IGridRendererEditpart editpart);
+
+	/**
+	 * Is used to create a new instance of a renderer.
+	 *
+	 * @param uiContext
+	 *            contains information about the current ui instance
+	 * @param editpart
+	 *            the editpart for which a renderer should be created.
+	 * @return renderer
+	 * @throws IllegalArgumentException
+	 *             if no presentation could be created.
+	 */
+	Object createRenderer(IViewContext uiContext,
+			IGridRendererEditpart editpart) throws IllegalArgumentException;
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererRefreshHandler.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererRefreshHandler.java
new file mode 100644
index 0000000..7cbf8cf
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridRendererRefreshHandler.java
@@ -0,0 +1,26 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+/**
+ * The Interface IGridRendererRefreshHandler.
+ */
+public interface IGridRendererRefreshHandler {
+
+	/**
+	 * Is called to refresh the renderer.
+	 */
+	void refreshRenderer();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridTextRendererEditpart.java b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridTextRendererEditpart.java
new file mode 100644
index 0000000..60c9788
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.editparts/src/org/eclipse/osbp/ecview/extension/grid/editparts/renderer/IGridTextRendererEditpart.java
@@ -0,0 +1,22 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.editparts.renderer;
+
+
+/**
+ * The Interface IGridTextRendererEditpart.
+ */
+public interface IGridTextRendererEditpart extends IGridRendererEditpart {
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/.project b/org.eclipse.osbp.ecview.extension.grid.model.edit/.project
new file mode 100644
index 0000000..3743a3e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/.project
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.grid.model.edit</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/LICENSE.txt b/org.eclipse.osbp.ecview.extension.grid.model.edit/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/META-INF/MANIFEST.MF b/org.eclipse.osbp.ecview.extension.grid.model.edit/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..ff6ad9d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.ecview.extension.grid.model.edit
+Bundle-SymbolicName: org.eclipse.osbp.ecview.extension.grid.model.edit;singleton:=true
+Bundle-Version: 0.9.0.qualifier
+Bundle-ClassPath: .
+Bundle-Activator: org.eclipse.osbp.ecview.extension.grid.provider.CxGridEditPlugin$Implementation
+Bundle-Vendor: Eclipse OSBP
+ Germany)
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.ecview.extension.grid.memento.provider;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.provider;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.renderer.provider;version="0.9.0"
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.osbp.ecview.extension.grid.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.emf.edit;visibility:=reexport,
+ org.eclipse.osbp.ecview.core.common.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.common.model.edit;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.extension.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.extension.model.edit;bundle-version="[0.9.0,0.10.0)";visibility:=reexport
+Bundle-ActivationPolicy: lazy
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/about.html b/org.eclipse.osbp.ecview.extension.grid.model.edit/about.html
new file mode 100644
index 0000000..64c0598
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/about.html
@@ -0,0 +1,28 @@
+<!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>June 1, 2016</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &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>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/about.ini b/org.eclipse.osbp.ecview.extension.grid.model.edit/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/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.ecview.extension.grid.model.edit/about.mappings b/org.eclipse.osbp.ecview.extension.grid.model.edit/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/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.ecview.extension.grid.model.edit/about.properties b/org.eclipse.osbp.ecview.extension.grid.model.edit/about.properties
new file mode 100644
index 0000000..152630a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/about.properties
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.ecview.extension.grid.model.edit
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - implementation\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/build.properties b/org.eclipse.osbp.ecview.extension.grid.model.edit/build.properties
new file mode 100644
index 0000000..0b5aacb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/build.properties
@@ -0,0 +1,19 @@
+# All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+# 
+# Contributors:
+#       Florian Pirchner - initial API and implementation
+
+bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  .,\
+               icons/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               license.html,\
+               LICENSE.txt,\
+               epl-v10.html
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
+               LICENSE.txt,\
+               epl-v10.html			   
+jars.compile.order = .
+source.. = src/
+output.. = target.classes/
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/epl-v10.html b/org.eclipse.osbp.ecview.extension.grid.model.edit/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridButtonRenderer_lastClickEvent_CxGridRendererClickEvent.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridButtonRenderer_lastClickEvent_CxGridRendererClickEvent.gif
new file mode 100644
index 0000000..1dd69bb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridButtonRenderer_lastClickEvent_CxGridRendererClickEvent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YBooleanSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YBooleanSearchField.gif
new file mode 100644
index 0000000..5ea562b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YBooleanSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YNumericSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YNumericSearchField.gif
new file mode 100644
index 0000000..f1e2d49
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YNumericSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YReferenceSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YReferenceSearchField.gif
new file mode 100644
index 0000000..16048d0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YReferenceSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YTextSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YTextSearchField.gif
new file mode 100644
index 0000000..223e215
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridColumn_searchField_YTextSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridImageRenderer_lastClickEvent_CxGridRendererClickEvent.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridImageRenderer_lastClickEvent_CxGridRendererClickEvent.gif
new file mode 100644
index 0000000..3cce056
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridImageRenderer_lastClickEvent_CxGridRendererClickEvent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMemento_columns_CxGridMementoColumn.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMemento_columns_CxGridMementoColumn.gif
new file mode 100644
index 0000000..e500955
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMemento_columns_CxGridMementoColumn.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMemento_sortOrders_CxGridMementoSortable.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMemento_sortOrders_CxGridMementoSortable.gif
new file mode 100644
index 0000000..3730559
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMemento_sortOrders_CxGridMementoSortable.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_CxGrid.gif
new file mode 100644
index 0000000..8640819
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YAbsoluteLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YAbsoluteLayout.gif
new file mode 100644
index 0000000..ca2bd0d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YAbsoluteLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YAction.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YAction.gif
new file mode 100644
index 0000000..ec9eed4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YAction.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBeanReferenceField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBeanReferenceField.gif
new file mode 100644
index 0000000..1e01c87
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBeanReferenceField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBooleanSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBooleanSearchField.gif
new file mode 100644
index 0000000..0d3869b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBooleanSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBrowser.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBrowser.gif
new file mode 100644
index 0000000..c3c4510
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YBrowser.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YButton.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YButton.gif
new file mode 100644
index 0000000..5c7bfbe
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YButton.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YCheckBox.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YCheckBox.gif
new file mode 100644
index 0000000..7d18f38
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YCheckBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YComboBox.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YComboBox.gif
new file mode 100644
index 0000000..69db0cd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YCssLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YCssLayout.gif
new file mode 100644
index 0000000..9043d2a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YCssLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YDateTime.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YDateTime.gif
new file mode 100644
index 0000000..9043d2a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YDateTime.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YDecimalField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YDecimalField.gif
new file mode 100644
index 0000000..651acbd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumComboBox.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumComboBox.gif
new file mode 100644
index 0000000..79263fb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumList.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumList.gif
new file mode 100644
index 0000000..3636fe0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumList.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumOptionsGroup.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumOptionsGroup.gif
new file mode 100644
index 0000000..56be9a9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YEnumOptionsGroup.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YField.gif
new file mode 100644
index 0000000..880f257
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YFormLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YFormLayout.gif
new file mode 100644
index 0000000..0d3869b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YFormLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YGridLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YGridLayout.gif
new file mode 100644
index 0000000..9043d2a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YGridLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YHelperLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YHelperLayout.gif
new file mode 100644
index 0000000..a021a81
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YHelperLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YHorizontalLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YHorizontalLayout.gif
new file mode 100644
index 0000000..8fd571a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YHorizontalLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YImage.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YImage.gif
new file mode 100644
index 0000000..048c96b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YImage.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YLabel.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YLabel.gif
new file mode 100644
index 0000000..dd1f51d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YLabel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YLayout.gif
new file mode 100644
index 0000000..880f257
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YList.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YList.gif
new file mode 100644
index 0000000..4fdd589
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YList.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YMasterDetail.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YMasterDetail.gif
new file mode 100644
index 0000000..bf19516
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YMasterDetail.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YNumericField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YNumericField.gif
new file mode 100644
index 0000000..27dbe98
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YNumericSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YNumericSearchField.gif
new file mode 100644
index 0000000..4023703
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YNumericSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YOptionsGroup.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YOptionsGroup.gif
new file mode 100644
index 0000000..fffcb5b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YOptionsGroup.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YPanel.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YPanel.gif
new file mode 100644
index 0000000..7d18f38
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YPanel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YPasswordField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YPasswordField.gif
new file mode 100644
index 0000000..b8d07e0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YPasswordField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YProgressBar.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YProgressBar.gif
new file mode 100644
index 0000000..bb27d46
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YProgressBar.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YReferenceSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YReferenceSearchField.gif
new file mode 100644
index 0000000..c51ddff
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YReferenceSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSearchPanel.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSearchPanel.gif
new file mode 100644
index 0000000..5a66bf4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSearchPanel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSlider.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSlider.gif
new file mode 100644
index 0000000..17776a1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSlider.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSplitPanel.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSplitPanel.gif
new file mode 100644
index 0000000..f3e037f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSplitPanel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSuggestTextField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSuggestTextField.gif
new file mode 100644
index 0000000..8fd571a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YSuggestTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTabSheet.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTabSheet.gif
new file mode 100644
index 0000000..4fdd589
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTabSheet.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTable.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTable.gif
new file mode 100644
index 0000000..8640819
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTable.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextArea.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextArea.gif
new file mode 100644
index 0000000..90b42b5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextField.gif
new file mode 100644
index 0000000..56be9a9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextSearchField.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextSearchField.gif
new file mode 100644
index 0000000..50ac6da
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTextSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YToggleButton.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YToggleButton.gif
new file mode 100644
index 0000000..a021a81
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YToggleButton.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTree.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTree.gif
new file mode 100644
index 0000000..c3c4510
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YTree.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YVerticalLayout.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YVerticalLayout.gif
new file mode 100644
index 0000000..4fdd589
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGridMetaCell_element_YVerticalLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_cellStyleGenerator_CxGridDelegateCellStyleGenerator.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_cellStyleGenerator_CxGridDelegateCellStyleGenerator.gif
new file mode 100644
index 0000000..11943a3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_cellStyleGenerator_CxGridDelegateCellStyleGenerator.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_columns_CxGridColumn.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_columns_CxGridColumn.gif
new file mode 100644
index 0000000..8707122
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_columns_CxGridColumn.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_footers_CxGridFooterRow.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_footers_CxGridFooterRow.gif
new file mode 100644
index 0000000..0a43661
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_footers_CxGridFooterRow.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_headers_CxGridHeaderRow.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_headers_CxGridHeaderRow.gif
new file mode 100644
index 0000000..3de4a50
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_headers_CxGridHeaderRow.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_sortOrder_CxGridSortable.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_sortOrder_CxGridSortable.gif
new file mode 100644
index 0000000..f7cfbc9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateCxGrid_sortOrder_CxGridSortable.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYDialog_content_CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYDialog_content_CxGrid.gif
new file mode 100644
index 0000000..b55cd92
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYDialog_content_CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYLayout_elements_CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYLayout_elements_CxGrid.gif
new file mode 100644
index 0000000..d7743e1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYLayout_elements_CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_CxGrid.gif
new file mode 100644
index 0000000..803d12d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_CxGrid.gif
new file mode 100644
index 0000000..803d12d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYTab_embeddable_CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYTab_embeddable_CxGrid.gif
new file mode 100644
index 0000000..0e886ec
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYTab_embeddable_CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYView_content_CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYView_content_CxGrid.gif
new file mode 100644
index 0000000..0d55746
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/ctool16/CreateYView_content_CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGrid.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGrid.gif
new file mode 100644
index 0000000..b99b45c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGrid.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridBooleanRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridBooleanRenderer.gif
new file mode 100644
index 0000000..badaab0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridBooleanRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridButtonRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridButtonRenderer.gif
new file mode 100644
index 0000000..4365960
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridButtonRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridColumn.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridColumn.gif
new file mode 100644
index 0000000..14af8aa
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridColumn.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDateRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDateRenderer.gif
new file mode 100644
index 0000000..420eee1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDateRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDelegateCellStyleGenerator.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDelegateCellStyleGenerator.gif
new file mode 100644
index 0000000..9250fec
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDelegateCellStyleGenerator.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDelegateRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDelegateRenderer.gif
new file mode 100644
index 0000000..1e5345f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridDelegateRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridFilterRow.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridFilterRow.gif
new file mode 100644
index 0000000..420eee1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridFilterRow.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridFooterRow.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridFooterRow.gif
new file mode 100644
index 0000000..c414fe9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridFooterRow.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridGroupedCell.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridGroupedCell.gif
new file mode 100644
index 0000000..10d2229
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridGroupedCell.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridHeaderRow.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridHeaderRow.gif
new file mode 100644
index 0000000..ef56c14
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridHeaderRow.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridHtmlRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridHtmlRenderer.gif
new file mode 100644
index 0000000..db7414e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridHtmlRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridImageRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridImageRenderer.gif
new file mode 100644
index 0000000..c8d381f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridImageRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridIndicatorRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridIndicatorRenderer.gif
new file mode 100644
index 0000000..136e3b2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridIndicatorRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMemento.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMemento.gif
new file mode 100644
index 0000000..33a997a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMemento.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMementoColumn.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMementoColumn.gif
new file mode 100644
index 0000000..338fb8d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMementoColumn.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMementoSortable.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMementoSortable.gif
new file mode 100644
index 0000000..c8d381f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMementoSortable.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMetaCell.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMetaCell.gif
new file mode 100644
index 0000000..7b7c428
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridMetaCell.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridNumberRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridNumberRenderer.gif
new file mode 100644
index 0000000..338fb8d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridNumberRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridPriceRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridPriceRenderer.gif
new file mode 100644
index 0000000..afb82ea
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridPriceRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridProgressBarRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridProgressBarRenderer.gif
new file mode 100644
index 0000000..14af8aa
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridProgressBarRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridQuantityRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridQuantityRenderer.gif
new file mode 100644
index 0000000..5a9bc75
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridQuantityRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridRendererClickEvent.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridRendererClickEvent.gif
new file mode 100644
index 0000000..b1f8afa
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridRendererClickEvent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridSortable.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridSortable.gif
new file mode 100644
index 0000000..c4a8af4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridSortable.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridTextRenderer.gif b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridTextRenderer.gif
new file mode 100644
index 0000000..caf2804
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/icons/full/obj16/CxGridTextRenderer.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/license.html b/org.eclipse.osbp.ecview.extension.grid.model.edit/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/notice.html b/org.eclipse.osbp.ecview.extension.grid.model.edit/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.grid.model.edit/plugin.properties b/org.eclipse.osbp.ecview.extension.grid.model.edit/plugin.properties
new file mode 100644
index 0000000..e3e7931
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/plugin.properties
@@ -0,0 +1,155 @@
+# All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+# 
+# Contributors:
+#       Florian Pirchner - initial API and implementation
+
+pluginName = CxGrid Edit Support
+providerName = www.example.org
+
+_UI_CreateChild_text = {0}
+_UI_CreateChild_text2 = {1} {0}
+_UI_CreateChild_text3 = {1}
+_UI_CreateChild_tooltip = Create New {0} Under {1} Feature
+_UI_CreateChild_description = Create a new child of type {0} for the {1} feature of the selected {2}.
+_UI_CreateSibling_description = Create a new sibling of type {0} for the selected {2}, under the {1} feature of their parent.
+
+_UI_PropertyDescriptor_description = The {0} of the {1}
+
+_UI_CxGrid_type = Cx Grid
+_UI_CxGridProvider_type = Provider
+_UI_CxGridMetaRow_type = Meta Row
+_UI_CxGridHeaderRow_type = Header Row
+_UI_CxGridFooterRow_type = Footer Row
+_UI_CxGridFilterRow_type = Filter Row
+_UI_CxGridGroupable_type = Groupable
+_UI_CxGridMetaCell_type = Meta Cell
+_UI_CxGridGroupedCell_type = Grouped Cell
+_UI_CxGridColumn_type = Column
+_UI_CxGridCellStyleGenerator_type = Cell Style Generator
+_UI_CxGridDelegateCellStyleGenerator_type = Delegate Cell Style Generator
+_UI_CxGridSortable_type = Sortable
+_UI_CxGridRenderer_type = Cx Grid Renderer
+_UI_CxGridDelegateRenderer_type = Cx Grid Delegate Renderer
+_UI_CxGridDateRenderer_type = Cx Grid Date Renderer
+_UI_CxGridHtmlRenderer_type = Cx Grid Html Renderer
+_UI_CxGridNumberRenderer_type = Cx Grid Number Renderer
+_UI_CxGridProgressBarRenderer_type = Cx Grid Progress Bar Renderer
+_UI_CxGridTextRenderer_type = Cx Grid Text Renderer
+_UI_CxGridButtonRenderer_type = Cx Grid Button Renderer
+_UI_CxGridImageRenderer_type = Cx Grid Image Renderer
+_UI_CxGridRendererClickEvent_type = Click Event
+_UI_CxGridBooleanRenderer_type = Cx Grid Boolean Renderer
+_UI_CxGridQuantityRenderer_type = Cx Grid Quantity Renderer
+_UI_CxGridPriceRenderer_type = Cx Grid Price Renderer
+_UI_CxGridIndicatorRenderer_type = Cx Grid Indicator Renderer
+_UI_CxGridMemento_type = Cx Grid Memento
+_UI_CxGridMementoColumn_type = Column
+_UI_CxGridMementoSortable_type = Sortable
+_UI_Unknown_type = Object
+
+_UI_Unknown_datatype= Value
+
+_UI_CxGrid_label_feature = Label
+_UI_CxGrid_labelI18nKey_feature = Label I1 8n Key
+_UI_CxGrid_selectionType_feature = Selection Type
+_UI_CxGrid_selectionEventTopic_feature = Selection Event Topic
+_UI_CxGrid_selection_feature = Selection
+_UI_CxGrid_multiSelection_feature = Multi Selection
+_UI_CxGrid_collection_feature = Collection
+_UI_CxGrid_type_feature = Type
+_UI_CxGrid_emfNsURI_feature = Emf Ns URI
+_UI_CxGrid_typeQualifiedName_feature = Type Qualified Name
+_UI_CxGrid_columns_feature = Columns
+_UI_CxGrid_sortOrder_feature = Sort Order
+_UI_CxGrid_columnReorderingAllowed_feature = Column Reordering Allowed
+_UI_CxGrid_cellStyleGenerator_feature = Cell Style Generator
+_UI_CxGrid_filteringVisible_feature = Filtering Visible
+_UI_CxGrid_customFilters_feature = Custom Filters
+_UI_CxGrid_headers_feature = Headers
+_UI_CxGrid_headerVisible_feature = Header Visible
+_UI_CxGrid_footers_feature = Footers
+_UI_CxGrid_footerVisible_feature = Footer Visible
+_UI_CxGrid_editorEnabled_feature = Editor Enabled
+_UI_CxGrid_editorCancelI18nLabelKey_feature = Editor Cancel I1 8n Label Key
+_UI_CxGrid_editorSaveI18nLabelKey_feature = Editor Save I1 8n Label Key
+_UI_CxGridMetaRow_groupings_feature = Groupings
+_UI_CxGridMetaRow_customCells_feature = Custom Cells
+_UI_CxGridMetaCell_target_feature = Target
+_UI_CxGridMetaCell_label_feature = Label
+_UI_CxGridMetaCell_labelI18nKey_feature = Label I1 8n Key
+_UI_CxGridMetaCell_useHTML_feature = Use HTML
+_UI_CxGridMetaCell_element_feature = Element
+_UI_CxGridGroupedCell_groupables_feature = Groupables
+_UI_CxGridGroupedCell_label_feature = Label
+_UI_CxGridGroupedCell_labelI18nKey_feature = Label I1 8n Key
+_UI_CxGridGroupedCell_useHTML_feature = Use HTML
+_UI_CxGridColumn_propertyId_feature = Property Id
+_UI_CxGridColumn_label_feature = Label
+_UI_CxGridColumn_labelI18nKey_feature = Label I1 8n Key
+_UI_CxGridColumn_editable_feature = Editable
+_UI_CxGridColumn_converter_feature = Converter
+_UI_CxGridColumn_renderer_feature = Renderer
+_UI_CxGridColumn_editorField_feature = Editor Field
+_UI_CxGridColumn_searchField_feature = Search Field
+_UI_CxGridColumn_headerCaption_feature = Header Caption
+_UI_CxGridColumn_headerCaptionI18nKey_feature = Header Caption I1 8n Key
+_UI_CxGridColumn_expandRatio_feature = Expand Ratio
+_UI_CxGridColumn_hidden_feature = Hidden
+_UI_CxGridColumn_hideable_feature = Hideable
+_UI_CxGridColumn_sortable_feature = Sortable
+_UI_CxGridColumn_propertyPath_feature = Property Path
+_UI_CxGridColumn_width_feature = Width
+_UI_CxGridColumn_minWidthPixels_feature = Min Width Pixels
+_UI_CxGridColumn_maxWidthPixels_feature = Max Width Pixels
+_UI_CxGridColumn_usedInMetaCells_feature = Used In Meta Cells
+_UI_CxGridDelegateCellStyleGenerator_delegateId_feature = Delegate Id
+_UI_CxGridSortable_descending_feature = Descending
+_UI_CxGridSortable_column_feature = Column
+_UI_CxGridDelegateRenderer_delegateId_feature = Delegate Id
+_UI_CxGridDateRenderer_dateFormat_feature = Date Format
+_UI_CxGridHtmlRenderer_nullRepresentation_feature = Null Representation
+_UI_CxGridNumberRenderer_numberFormat_feature = Number Format
+_UI_CxGridNumberRenderer_nullRepresentation_feature = Null Representation
+_UI_CxGridProgressBarRenderer_maxValue_feature = Max Value
+_UI_CxGridTextRenderer_nullRepresentation_feature = Null Representation
+_UI_CxGridButtonRenderer_nullRepresentation_feature = Null Representation
+_UI_CxGridButtonRenderer_lastClickEvent_feature = Last Click Event
+_UI_CxGridButtonRenderer_eventTopic_feature = Event Topic
+_UI_CxGridImageRenderer_lastClickEvent_feature = Last Click Event
+_UI_CxGridImageRenderer_eventTopic_feature = Event Topic
+_UI_CxGridRendererClickEvent_renderer_feature = Renderer
+_UI_CxGridRendererClickEvent_lastClickTime_feature = Last Click Time
+_UI_CxGridQuantityRenderer_valuePropertyPath_feature = Value Property Path
+_UI_CxGridQuantityRenderer_uomPropertyPath_feature = Uom Property Path
+_UI_CxGridQuantityRenderer_nullRepresentation_feature = Null Representation
+_UI_CxGridQuantityRenderer_htmlPattern_feature = Html Pattern
+_UI_CxGridQuantityRenderer_numberFormat_feature = Number Format
+_UI_CxGridPriceRenderer_valuePropertyPath_feature = Value Property Path
+_UI_CxGridPriceRenderer_currencyPropertyPath_feature = Currency Property Path
+_UI_CxGridPriceRenderer_nullRepresentation_feature = Null Representation
+_UI_CxGridPriceRenderer_htmlPattern_feature = Html Pattern
+_UI_CxGridPriceRenderer_numberFormat_feature = Number Format
+_UI_CxGridIndicatorRenderer_greenStarts_feature = Green Starts
+_UI_CxGridIndicatorRenderer_redStarts_feature = Red Starts
+_UI_CxGridMemento_gridId_feature = Grid Id
+_UI_CxGridMemento_headerVisible_feature = Header Visible
+_UI_CxGridMemento_filterVisible_feature = Filter Visible
+_UI_CxGridMemento_footerVisible_feature = Footer Visible
+_UI_CxGridMemento_editorEnabled_feature = Editor Enabled
+_UI_CxGridMemento_columns_feature = Columns
+_UI_CxGridMemento_sortOrders_feature = Sort Orders
+_UI_CxGridMementoColumn_propertyId_feature = Property Id
+_UI_CxGridMementoColumn_editable_feature = Editable
+_UI_CxGridMementoColumn_expandRatio_feature = Expand Ratio
+_UI_CxGridMementoColumn_hidden_feature = Hidden
+_UI_CxGridMementoColumn_hideable_feature = Hideable
+_UI_CxGridMementoColumn_sortable_feature = Sortable
+_UI_CxGridMementoColumn_width_feature = Width
+_UI_CxGridMementoSortable_descending_feature = Descending
+_UI_CxGridMementoSortable_column_feature = Column
+_UI_Unknown_feature = Unspecified
+
+_UI_CxGridIndicatorRenderer_redEnds_feature = Red Ends
+_UI_CxGrid_editorSaved_feature = Editor Saved
+_UI_CxGridColumn_type_feature = Type
+_UI_CxGridColumn_typeQualifiedName_feature = Type Qualified Name
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/plugin.xml b/org.eclipse.osbp.ecview.extension.grid.model.edit/plugin.xml
new file mode 100644
index 0000000..0c26017
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/plugin.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+ All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+ 
+ Contributors:
+       Florian Pirchner - initial API and implementation
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated cxgrid -->
+      <factory
+            uri="http://osbp.de/ecview/v1/extension/grid"
+            class="org.eclipse.osbp.ecview.extension.grid.provider.CxGridItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.edit.childCreationExtenders">
+      <!-- @generated cxgrid -->
+      <extender
+            uri="http://osbp.eclipse.org/ecview/v1/core/view"
+            class="org.eclipse.osbp.ecview.extension.grid.provider.CxGridItemProviderAdapterFactory$CoreModelChildCreationExtender"/>
+      <extender
+            uri="http://osbp.eclipse.org/ecview/v1/extension/view"
+            class="org.eclipse.osbp.ecview.extension.grid.provider.CxGridItemProviderAdapterFactory$ExtensionModelChildCreationExtender"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated cxgrid -->
+      <factory
+            uri="http://osbp.de/ecview/v1/extension/grid/renderer"
+            class="org.eclipse.osbp.ecview.extension.grid.renderer.provider.CxGridRendererItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated cxgrid -->
+      <factory
+            uri="http://osbp.de/ecview/v1/extension/grid/memento"
+            class="org.eclipse.osbp.ecview.extension.grid.memento.provider.CxGridMementoItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+</plugin>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/pom.xml b/org.eclipse.osbp.ecview.extension.grid.model.edit/pom.xml
new file mode 100644
index 0000000..f49a6e7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/pom.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial 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.ecview.extension.api</groupId>
+		<artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.ecview.extension.grid.model.edit</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+	</build>
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoColumnItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoColumnItemProvider.java
new file mode 100644
index 0000000..f347a0b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoColumnItemProvider.java
@@ -0,0 +1,340 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.memento.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+
+import org.eclipse.osbp.ecview.extension.grid.provider.CxGridEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridMementoColumnItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridMementoColumnItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addPropertyIdPropertyDescriptor(object);
+			addEditablePropertyDescriptor(object);
+			addExpandRatioPropertyDescriptor(object);
+			addHiddenPropertyDescriptor(object);
+			addHideablePropertyDescriptor(object);
+			addSortablePropertyDescriptor(object);
+			addWidthPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Property Id feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addPropertyIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoColumn_propertyId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoColumn_propertyId_feature", "_UI_CxGridMementoColumn_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN__PROPERTY_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editable feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEditablePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoColumn_editable_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoColumn_editable_feature", "_UI_CxGridMementoColumn_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN__EDITABLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Expand Ratio feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addExpandRatioPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoColumn_expandRatio_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoColumn_expandRatio_feature", "_UI_CxGridMementoColumn_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Hidden feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHiddenPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoColumn_hidden_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoColumn_hidden_feature", "_UI_CxGridMementoColumn_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN__HIDDEN,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Hideable feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHideablePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoColumn_hideable_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoColumn_hideable_feature", "_UI_CxGridMementoColumn_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN__HIDEABLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Sortable feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addSortablePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoColumn_sortable_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoColumn_sortable_feature", "_UI_CxGridMementoColumn_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN__SORTABLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Width feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addWidthPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoColumn_width_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoColumn_width_feature", "_UI_CxGridMementoColumn_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN__WIDTH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridMementoColumn.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridMementoColumn"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridMementoColumn)object).getPropertyId();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridMementoColumn_type") :
+			getString("_UI_CxGridMementoColumn_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridMementoColumn.class)) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__PROPERTY_ID:
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EDITABLE:
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO:
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDDEN:
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDEABLE:
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__SORTABLE:
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__WIDTH:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return CxGridEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoItemProvider.java
new file mode 100644
index 0000000..a944d2c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoItemProvider.java
@@ -0,0 +1,425 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.memento.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoFactory;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+
+import org.eclipse.osbp.ecview.extension.grid.provider.CxGridEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridMementoItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridMementoItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addGridIdPropertyDescriptor(object);
+			addHeaderVisiblePropertyDescriptor(object);
+			addFilterVisiblePropertyDescriptor(object);
+			addFooterVisiblePropertyDescriptor(object);
+			addEditorEnabledPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Grid Id feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addGridIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMemento_gridId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMemento_gridId_feature", "_UI_CxGridMemento_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO__GRID_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Header Visible feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHeaderVisiblePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMemento_headerVisible_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMemento_headerVisible_feature", "_UI_CxGridMemento_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO__HEADER_VISIBLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Filter Visible feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addFilterVisiblePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMemento_filterVisible_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMemento_filterVisible_feature", "_UI_CxGridMemento_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO__FILTER_VISIBLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Footer Visible feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addFooterVisiblePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMemento_footerVisible_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMemento_footerVisible_feature", "_UI_CxGridMemento_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO__FOOTER_VISIBLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editor Enabled feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEditorEnabledPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMemento_editorEnabled_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMemento_editorEnabled_feature", "_UI_CxGridMemento_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO__EDITOR_ENABLED,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(CxGridMementoPackage.Literals.CX_GRID_MEMENTO__COLUMNS);
+			childrenFeatures.add(CxGridMementoPackage.Literals.CX_GRID_MEMENTO__SORT_ORDERS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridMemento.gif. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the image
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridMemento"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridMemento)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridMemento_type") :
+			getString("_UI_CxGridMemento_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridMemento.class)) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO__TAGS:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__ID:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__NAME:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__GRID_ID:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__HEADER_VISIBLE:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FILTER_VISIBLE:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FOOTER_VISIBLE:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__EDITOR_ENABLED:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__PROPERTIES:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__COLUMNS:
+			case CxGridMementoPackage.CX_GRID_MEMENTO__SORT_ORDERS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridMementoPackage.Literals.CX_GRID_MEMENTO__COLUMNS,
+				 CxGridMementoFactory.eINSTANCE.createCxGridMementoColumn()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridMementoPackage.Literals.CX_GRID_MEMENTO__SORT_ORDERS,
+				 CxGridMementoFactory.eINSTANCE.createCxGridMementoSortable()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return CxGridEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoItemProviderAdapterFactory.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoItemProviderAdapterFactory.java
new file mode 100644
index 0000000..671c4dc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoItemProviderAdapterFactory.java
@@ -0,0 +1,268 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.memento.provider;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.util.CxGridMementoAdapterFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support Viewers.
+ * The adapters generated by this factory convert EMF adapter notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}.
+ * The adapters also support Eclipse property sheets.
+ * Note that most of the adapters are shared among multiple instances.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridMementoItemProviderAdapterFactory extends CxGridMementoAdapterFactory implements ComposeableAdapterFactory, IChangeNotifier, IDisposable {
+	
+	/**
+	 * This keeps track of the root adapter factory that delegates to this adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement {@link org.eclipse.emf.edit.provider.IChangeNotifier}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This keeps track of all the supported types checked by {@link #isFactoryForType isFactoryForType}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridMementoItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridMementoItemProvider cxGridMementoItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridMementoAdapter() {
+		if (cxGridMementoItemProvider == null) {
+			cxGridMementoItemProvider = new CxGridMementoItemProvider(this);
+		}
+
+		return cxGridMementoItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridMementoColumnItemProvider cxGridMementoColumnItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridMementoColumnAdapter() {
+		if (cxGridMementoColumnItemProvider == null) {
+			cxGridMementoColumnItemProvider = new CxGridMementoColumnItemProvider(this);
+		}
+
+		return cxGridMementoColumnItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridMementoSortableItemProvider cxGridMementoSortableItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridMementoSortableAdapter() {
+		if (cxGridMementoSortableItemProvider == null) {
+			cxGridMementoSortableItemProvider = new CxGridMementoSortableItemProvider(this);
+		}
+
+		return cxGridMementoSortableItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the root adapter factory
+	 * @generated
+	 */
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param parentAdapterFactory
+	 *            the new this keeps track of the root adapter factory that
+	 *            delegates to this adapter factory
+	 * @generated
+	 */
+	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param type
+	 *            the type
+	 * @return true, if is factory for type
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the adapter.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param type
+	 *            the type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>) || (((Class<?>)type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * This adds a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to
+	 * {@link #parentAdapterFactory}. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param notification
+	 *            the notification
+	 * @generated
+	 */
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory. 
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void dispose() {
+		if (cxGridMementoItemProvider != null) cxGridMementoItemProvider.dispose();
+		if (cxGridMementoColumnItemProvider != null) cxGridMementoColumnItemProvider.dispose();
+		if (cxGridMementoSortableItemProvider != null) cxGridMementoSortableItemProvider.dispose();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoSortableItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoSortableItemProvider.java
new file mode 100644
index 0000000..f224142
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/memento/provider/CxGridMementoSortableItemProvider.java
@@ -0,0 +1,207 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.memento.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable;
+
+import org.eclipse.osbp.ecview.extension.grid.provider.CxGridEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridMementoSortableItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridMementoSortableItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addDescendingPropertyDescriptor(object);
+			addColumnPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Descending feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDescendingPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoSortable_descending_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoSortable_descending_feature", "_UI_CxGridMementoSortable_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_SORTABLE__DESCENDING,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Column feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addColumnPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMementoSortable_column_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMementoSortable_column_feature", "_UI_CxGridMementoSortable_type"),
+				 CxGridMementoPackage.Literals.CX_GRID_MEMENTO_SORTABLE__COLUMN,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridMementoSortable.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridMementoSortable"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		CxGridMementoSortable cxGridMementoSortable = (CxGridMementoSortable)object;
+		return getString("_UI_CxGridMementoSortable_type") + " " + cxGridMementoSortable.isDescending();
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridMementoSortable.class)) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__DESCENDING:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return CxGridEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridCellStyleGeneratorItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridCellStyleGeneratorItemProvider.java
new file mode 100644
index 0000000..aa6c113
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridCellStyleGeneratorItemProvider.java
@@ -0,0 +1,265 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridCellStyleGeneratorItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridCellStyleGeneratorItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridCellStyleGenerator)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridCellStyleGenerator_type") :
+			getString("_UI_CxGridCellStyleGenerator_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridCellStyleGenerator.class)) {
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__TAGS:
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__ID:
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridColumnItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridColumnItemProvider.java
new file mode 100644
index 0000000..8579ac7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridColumnItemProvider.java
@@ -0,0 +1,704 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridColumnItemProvider extends CxGridGroupableItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridColumnItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addPropertyIdPropertyDescriptor(object);
+			addLabelPropertyDescriptor(object);
+			addLabelI18nKeyPropertyDescriptor(object);
+			addEditablePropertyDescriptor(object);
+			addConverterPropertyDescriptor(object);
+			addRendererPropertyDescriptor(object);
+			addEditorFieldPropertyDescriptor(object);
+			addHeaderCaptionPropertyDescriptor(object);
+			addHeaderCaptionI18nKeyPropertyDescriptor(object);
+			addExpandRatioPropertyDescriptor(object);
+			addHiddenPropertyDescriptor(object);
+			addHideablePropertyDescriptor(object);
+			addSortablePropertyDescriptor(object);
+			addPropertyPathPropertyDescriptor(object);
+			addWidthPropertyDescriptor(object);
+			addMinWidthPixelsPropertyDescriptor(object);
+			addMaxWidthPixelsPropertyDescriptor(object);
+			addUsedInMetaCellsPropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+			addTypeQualifiedNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Property Id feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addPropertyIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_propertyId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_propertyId_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__PROPERTY_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_label_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_label_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__LABEL,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label I1 8n Key feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelI18nKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_labelI18nKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_labelI18nKey_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__LABEL_I1_8N_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editable feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEditablePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_editable_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_editable_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__EDITABLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Converter feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addConverterPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_converter_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_converter_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__CONVERTER,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Renderer feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addRendererPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_renderer_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_renderer_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__RENDERER,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editor Field feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEditorFieldPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_editorField_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_editorField_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__EDITOR_FIELD,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Header Caption feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHeaderCaptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_headerCaption_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_headerCaption_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__HEADER_CAPTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Header Caption I1 8n Key feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addHeaderCaptionI18nKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_headerCaptionI18nKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_headerCaptionI18nKey_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Expand Ratio feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addExpandRatioPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_expandRatio_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_expandRatio_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__EXPAND_RATIO,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Hidden feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHiddenPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_hidden_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_hidden_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__HIDDEN,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Hideable feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHideablePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_hideable_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_hideable_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__HIDEABLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Sortable feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addSortablePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_sortable_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_sortable_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__SORTABLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Property Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addPropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_propertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_propertyPath_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Width feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addWidthPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_width_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_width_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__WIDTH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Min Width Pixels feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addMinWidthPixelsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_minWidthPixels_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_minWidthPixels_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__MIN_WIDTH_PIXELS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Max Width Pixels feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addMaxWidthPixelsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_maxWidthPixels_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_maxWidthPixels_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__MAX_WIDTH_PIXELS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Used In Meta Cells feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addUsedInMetaCellsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_usedInMetaCells_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_usedInMetaCells_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__USED_IN_META_CELLS,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_type_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridColumn_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridColumn_typeQualifiedName_feature", "_UI_CxGridColumn_type"),
+				 CxGridPackage.Literals.CX_GRID_COLUMN__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_COLUMN__SEARCH_FIELD);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridColumn.gif. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the image
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridColumn"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridColumn)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridColumn_type") :
+			getString("_UI_CxGridColumn_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridColumn.class)) {
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_ID:
+			case CxGridPackage.CX_GRID_COLUMN__LABEL:
+			case CxGridPackage.CX_GRID_COLUMN__LABEL_I1_8N_KEY:
+			case CxGridPackage.CX_GRID_COLUMN__EDITABLE:
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION:
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY:
+			case CxGridPackage.CX_GRID_COLUMN__EXPAND_RATIO:
+			case CxGridPackage.CX_GRID_COLUMN__HIDDEN:
+			case CxGridPackage.CX_GRID_COLUMN__HIDEABLE:
+			case CxGridPackage.CX_GRID_COLUMN__SORTABLE:
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_PATH:
+			case CxGridPackage.CX_GRID_COLUMN__WIDTH:
+			case CxGridPackage.CX_GRID_COLUMN__MIN_WIDTH_PIXELS:
+			case CxGridPackage.CX_GRID_COLUMN__MAX_WIDTH_PIXELS:
+			case CxGridPackage.CX_GRID_COLUMN__TYPE:
+			case CxGridPackage.CX_GRID_COLUMN__TYPE_QUALIFIED_NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_COLUMN__SEARCH_FIELD,
+				 ExtensionModelFactory.eINSTANCE.createYTextSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_COLUMN__SEARCH_FIELD,
+				 ExtensionModelFactory.eINSTANCE.createYBooleanSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_COLUMN__SEARCH_FIELD,
+				 ExtensionModelFactory.eINSTANCE.createYNumericSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_COLUMN__SEARCH_FIELD,
+				 ExtensionModelFactory.eINSTANCE.createYReferenceSearchField()));
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridDelegateCellStyleGeneratorItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridDelegateCellStyleGeneratorItemProvider.java
new file mode 100644
index 0000000..eebf040
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridDelegateCellStyleGeneratorItemProvider.java
@@ -0,0 +1,155 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridDelegateCellStyleGeneratorItemProvider extends CxGridCellStyleGeneratorItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridDelegateCellStyleGeneratorItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addDelegateIdPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Delegate Id feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDelegateIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridDelegateCellStyleGenerator_delegateId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridDelegateCellStyleGenerator_delegateId_feature", "_UI_CxGridDelegateCellStyleGenerator_type"),
+				 CxGridPackage.Literals.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridDelegateCellStyleGenerator.gif.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridDelegateCellStyleGenerator"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridDelegateCellStyleGenerator)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridDelegateCellStyleGenerator_type") :
+			getString("_UI_CxGridDelegateCellStyleGenerator_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridDelegateCellStyleGenerator.class)) {
+			case CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridEditPlugin.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridEditPlugin.java
new file mode 100644
index 0000000..2b3d31c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridEditPlugin.java
@@ -0,0 +1,107 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+import org.eclipse.emf.common.EMFPlugin;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.provider.ECViewCoreEditPlugin;
+
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.provider.ExtensionEditPlugin;
+
+/**
+ * This is the central singleton for the CxGrid edit plugin.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public final class CxGridEditPlugin extends EMFPlugin {
+	
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final CxGridEditPlugin INSTANCE = new CxGridEditPlugin();
+
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static Implementation plugin;
+
+	/**
+	 * Create the instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridEditPlugin() {
+		super
+		  (new ResourceLocator [] {
+		     ECViewCoreEditPlugin.INSTANCE,
+		     ExtensionEditPlugin.INSTANCE,
+		   });
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getPluginResourceLocator() {
+		return plugin;
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	public static Implementation getPlugin() {
+		return plugin;
+	}
+
+	/**
+	 * The actual implementation of the Eclipse <b>Plugin</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static class Implementation extends EclipsePlugin {
+		/**
+		 * Creates an instance.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public Implementation() {
+			super();
+
+			// Remember the static instance.
+			//
+			plugin = this;
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridFilterRowItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridFilterRowItemProvider.java
new file mode 100644
index 0000000..6056652
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridFilterRowItemProvider.java
@@ -0,0 +1,291 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridFilterRowItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridFilterRowItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_META_ROW__GROUPINGS);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_META_ROW__CUSTOM_CELLS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridFilterRow.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridFilterRow"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridFilterRow)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridFilterRow_type") :
+			getString("_UI_CxGridFilterRow_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridFilterRow.class)) {
+			case CxGridPackage.CX_GRID_FILTER_ROW__TAGS:
+			case CxGridPackage.CX_GRID_FILTER_ROW__ID:
+			case CxGridPackage.CX_GRID_FILTER_ROW__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__PROPERTIES:
+			case CxGridPackage.CX_GRID_FILTER_ROW__GROUPINGS:
+			case CxGridPackage.CX_GRID_FILTER_ROW__CUSTOM_CELLS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_ROW__GROUPINGS,
+				 CxGridFactory.eINSTANCE.createCxGridGroupedCell()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_ROW__CUSTOM_CELLS,
+				 CxGridFactory.eINSTANCE.createCxGridMetaCell()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridFooterRowItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridFooterRowItemProvider.java
new file mode 100644
index 0000000..4f91b8b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridFooterRowItemProvider.java
@@ -0,0 +1,291 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridFooterRowItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridFooterRowItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_META_ROW__GROUPINGS);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_META_ROW__CUSTOM_CELLS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridFooterRow.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridFooterRow"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridFooterRow)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridFooterRow_type") :
+			getString("_UI_CxGridFooterRow_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridFooterRow.class)) {
+			case CxGridPackage.CX_GRID_FOOTER_ROW__TAGS:
+			case CxGridPackage.CX_GRID_FOOTER_ROW__ID:
+			case CxGridPackage.CX_GRID_FOOTER_ROW__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__PROPERTIES:
+			case CxGridPackage.CX_GRID_FOOTER_ROW__GROUPINGS:
+			case CxGridPackage.CX_GRID_FOOTER_ROW__CUSTOM_CELLS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_ROW__GROUPINGS,
+				 CxGridFactory.eINSTANCE.createCxGridGroupedCell()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_ROW__CUSTOM_CELLS,
+				 CxGridFactory.eINSTANCE.createCxGridMetaCell()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridGroupableItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridGroupableItemProvider.java
new file mode 100644
index 0000000..35ddb1b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridGroupableItemProvider.java
@@ -0,0 +1,265 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupable;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupable} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridGroupableItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridGroupableItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridGroupable)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridGroupable_type") :
+			getString("_UI_CxGridGroupable_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridGroupable.class)) {
+			case CxGridPackage.CX_GRID_GROUPABLE__TAGS:
+			case CxGridPackage.CX_GRID_GROUPABLE__ID:
+			case CxGridPackage.CX_GRID_GROUPABLE__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_GROUPABLE__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridGroupedCellItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridGroupedCellItemProvider.java
new file mode 100644
index 0000000..ae406f0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridGroupedCellItemProvider.java
@@ -0,0 +1,232 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridGroupedCellItemProvider extends CxGridGroupableItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridGroupedCellItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addGroupablesPropertyDescriptor(object);
+			addLabelPropertyDescriptor(object);
+			addLabelI18nKeyPropertyDescriptor(object);
+			addUseHTMLPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Groupables feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addGroupablesPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridGroupedCell_groupables_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridGroupedCell_groupables_feature", "_UI_CxGridGroupedCell_type"),
+				 CxGridPackage.Literals.CX_GRID_GROUPED_CELL__GROUPABLES,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridGroupedCell_label_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridGroupedCell_label_feature", "_UI_CxGridGroupedCell_type"),
+				 CxGridPackage.Literals.CX_GRID_GROUPED_CELL__LABEL,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label I1 8n Key feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelI18nKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridGroupedCell_labelI18nKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridGroupedCell_labelI18nKey_feature", "_UI_CxGridGroupedCell_type"),
+				 CxGridPackage.Literals.CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Use HTML feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addUseHTMLPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridGroupedCell_useHTML_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridGroupedCell_useHTML_feature", "_UI_CxGridGroupedCell_type"),
+				 CxGridPackage.Literals.CX_GRID_GROUPED_CELL__USE_HTML,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridGroupedCell.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridGroupedCell"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridGroupedCell)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridGroupedCell_type") :
+			getString("_UI_CxGridGroupedCell_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridGroupedCell.class)) {
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL:
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY:
+			case CxGridPackage.CX_GRID_GROUPED_CELL__USE_HTML:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridHeaderRowItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridHeaderRowItemProvider.java
new file mode 100644
index 0000000..4782ca1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridHeaderRowItemProvider.java
@@ -0,0 +1,291 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridHeaderRowItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridHeaderRowItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_META_ROW__GROUPINGS);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_META_ROW__CUSTOM_CELLS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridHeaderRow.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridHeaderRow"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridHeaderRow)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridHeaderRow_type") :
+			getString("_UI_CxGridHeaderRow_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridHeaderRow.class)) {
+			case CxGridPackage.CX_GRID_HEADER_ROW__TAGS:
+			case CxGridPackage.CX_GRID_HEADER_ROW__ID:
+			case CxGridPackage.CX_GRID_HEADER_ROW__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__PROPERTIES:
+			case CxGridPackage.CX_GRID_HEADER_ROW__GROUPINGS:
+			case CxGridPackage.CX_GRID_HEADER_ROW__CUSTOM_CELLS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_ROW__GROUPINGS,
+				 CxGridFactory.eINSTANCE.createCxGridGroupedCell()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_ROW__CUSTOM_CELLS,
+				 CxGridFactory.eINSTANCE.createCxGridMetaCell()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridItemProvider.java
new file mode 100644
index 0000000..ed42300
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridItemProvider.java
@@ -0,0 +1,753 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import java.util.Collection;
+import java.util.List;
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGrid} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridItemProvider extends YInputItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addCollectionBindingEndpointPropertyDescriptor(object);
+			addSelectionBindingEndpointPropertyDescriptor(object);
+			addMultiSelectionBindingEndpointPropertyDescriptor(object);
+			addUseBeanServicePropertyDescriptor(object);
+			addSelectionTypePropertyDescriptor(object);
+			addSelectionEventTopicPropertyDescriptor(object);
+			addSelectionPropertyDescriptor(object);
+			addMultiSelectionPropertyDescriptor(object);
+			addCollectionPropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+			addEmfNsURIPropertyDescriptor(object);
+			addTypeQualifiedNamePropertyDescriptor(object);
+			addColumnReorderingAllowedPropertyDescriptor(object);
+			addFilteringVisiblePropertyDescriptor(object);
+			addCustomFiltersPropertyDescriptor(object);
+			addHeaderVisiblePropertyDescriptor(object);
+			addFooterVisiblePropertyDescriptor(object);
+			addEditorEnabledPropertyDescriptor(object);
+			addEditorCancelI18nLabelKeyPropertyDescriptor(object);
+			addEditorSaveI18nLabelKeyPropertyDescriptor(object);
+			addEditorSavedPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Collection Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addCollectionBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YCollectionBindable_collectionBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YCollectionBindable_collectionBindingEndpoint_feature", "_UI_YCollectionBindable_type"),
+				 CoreModelPackage.Literals.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addSelectionBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSelectionBindable_selectionBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSelectionBindable_selectionBindingEndpoint_feature", "_UI_YSelectionBindable_type"),
+				 CoreModelPackage.Literals.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Multi Selection Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addMultiSelectionBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMultiSelectionBindable_multiSelectionBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMultiSelectionBindable_multiSelectionBindingEndpoint_feature", "_UI_YMultiSelectionBindable_type"),
+				 CoreModelPackage.Literals.YMULTI_SELECTION_BINDABLE__MULTI_SELECTION_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Use Bean Service feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addUseBeanServicePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YBeanServiceConsumer_useBeanService_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YBeanServiceConsumer_useBeanService_feature", "_UI_YBeanServiceConsumer_type"),
+				 ExtensionModelPackage.Literals.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection Type feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addSelectionTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_selectionType_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_selectionType_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__SELECTION_TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection Event Topic feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addSelectionEventTopicPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_selectionEventTopic_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_selectionEventTopic_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__SELECTION_EVENT_TOPIC,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addSelectionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_selection_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_selection_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__SELECTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Multi Selection feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addMultiSelectionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_multiSelection_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_multiSelection_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__MULTI_SELECTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Collection feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addCollectionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_collection_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_collection_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__COLLECTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_type_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Emf Ns URI feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEmfNsURIPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_emfNsURI_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_emfNsURI_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__EMF_NS_URI,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_typeQualifiedName_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Column Reordering Allowed feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addColumnReorderingAllowedPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_columnReorderingAllowed_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_columnReorderingAllowed_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__COLUMN_REORDERING_ALLOWED,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Filtering Visible feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addFilteringVisiblePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_filteringVisible_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_filteringVisible_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__FILTERING_VISIBLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Custom Filters feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addCustomFiltersPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_customFilters_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_customFilters_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__CUSTOM_FILTERS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Header Visible feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHeaderVisiblePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_headerVisible_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_headerVisible_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__HEADER_VISIBLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Footer Visible feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addFooterVisiblePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_footerVisible_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_footerVisible_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__FOOTER_VISIBLE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editor Enabled feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEditorEnabledPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_editorEnabled_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_editorEnabled_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__EDITOR_ENABLED,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editor Cancel I1 8n Label Key feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addEditorCancelI18nLabelKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_editorCancelI18nLabelKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_editorCancelI18nLabelKey_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editor Save I1 8n Label Key feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addEditorSaveI18nLabelKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_editorSaveI18nLabelKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_editorSaveI18nLabelKey_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Editor Saved feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEditorSavedPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGrid_editorSaved_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGrid_editorSaved_feature", "_UI_CxGrid_type"),
+				 CxGridPackage.Literals.CX_GRID__EDITOR_SAVED,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID__COLUMNS);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID__SORT_ORDER);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID__CELL_STYLE_GENERATOR);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID__HEADERS);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID__FOOTERS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGrid.gif.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGrid"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGrid)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGrid_type") :
+			getString("_UI_CxGrid_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGrid.class)) {
+			case CxGridPackage.CX_GRID__USE_BEAN_SERVICE:
+			case CxGridPackage.CX_GRID__SELECTION_TYPE:
+			case CxGridPackage.CX_GRID__SELECTION_EVENT_TOPIC:
+			case CxGridPackage.CX_GRID__SELECTION:
+			case CxGridPackage.CX_GRID__MULTI_SELECTION:
+			case CxGridPackage.CX_GRID__COLLECTION:
+			case CxGridPackage.CX_GRID__TYPE:
+			case CxGridPackage.CX_GRID__EMF_NS_URI:
+			case CxGridPackage.CX_GRID__TYPE_QUALIFIED_NAME:
+			case CxGridPackage.CX_GRID__COLUMN_REORDERING_ALLOWED:
+			case CxGridPackage.CX_GRID__FILTERING_VISIBLE:
+			case CxGridPackage.CX_GRID__CUSTOM_FILTERS:
+			case CxGridPackage.CX_GRID__HEADER_VISIBLE:
+			case CxGridPackage.CX_GRID__FOOTER_VISIBLE:
+			case CxGridPackage.CX_GRID__EDITOR_ENABLED:
+			case CxGridPackage.CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY:
+			case CxGridPackage.CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY:
+			case CxGridPackage.CX_GRID__EDITOR_SAVED:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID__COLUMNS:
+			case CxGridPackage.CX_GRID__SORT_ORDER:
+			case CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR:
+			case CxGridPackage.CX_GRID__HEADERS:
+			case CxGridPackage.CX_GRID__FOOTERS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID__COLUMNS,
+				 CxGridFactory.eINSTANCE.createCxGridColumn()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID__SORT_ORDER,
+				 CxGridFactory.eINSTANCE.createCxGridSortable()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID__CELL_STYLE_GENERATOR,
+				 CxGridFactory.eINSTANCE.createCxGridDelegateCellStyleGenerator()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID__HEADERS,
+				 CxGridFactory.eINSTANCE.createCxGridHeaderRow()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID__FOOTERS,
+				 CxGridFactory.eINSTANCE.createCxGridFooterRow()));
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridItemProviderAdapterFactory.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridItemProviderAdapterFactory.java
new file mode 100644
index 0000000..912a68a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridItemProviderAdapterFactory.java
@@ -0,0 +1,785 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.ResourceLocator;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.edit.command.CommandParameter;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ChildCreationExtenderManager;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YDialog;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.core.util.CoreModelSwitch;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YMasterDetail;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTab;
+import org.eclipse.osbp.ecview.core.extension.model.extension.util.ExtensionModelSwitch;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridAdapterFactory;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support
+ * Viewers. The adapters generated by this factory convert EMF adapter
+ * notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}. The
+ * adapters also support Eclipse property sheets. Note that most of the adapters
+ * are shared among multiple instances. <!-- begin-user-doc --> <!--
+ * end-user-doc -->
+ * 
+ * @generated
+ */
+public class CxGridItemProviderAdapterFactory extends CxGridAdapterFactory
+		implements ComposeableAdapterFactory, IChangeNotifier, IDisposable,
+		IChildCreationExtender {
+
+	/**
+	 * This keeps track of the root adapter factory that delegates to this
+	 * adapter factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement
+	 * {@link org.eclipse.emf.edit.provider.IChangeNotifier}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This helps manage the child creation extenders. <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected ChildCreationExtenderManager childCreationExtenderManager = new ChildCreationExtenderManager(
+			CxGridEditPlugin.INSTANCE, CxGridPackage.eNS_URI);
+
+	/**
+	 * This keeps track of all the supported types checked by
+	 * {@link #isFactoryForType isFactoryForType}. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 * 
+	 * @generated
+	 */
+	public CxGridItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGrid} instances. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridItemProvider cxGridItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGrid}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridAdapter() {
+		if (cxGridItemProvider == null) {
+			cxGridItemProvider = new CxGridItemProvider(this);
+		}
+
+		return cxGridItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridHeaderRowItemProvider cxGridHeaderRowItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridHeaderRowAdapter() {
+		if (cxGridHeaderRowItemProvider == null) {
+			cxGridHeaderRowItemProvider = new CxGridHeaderRowItemProvider(this);
+		}
+
+		return cxGridHeaderRowItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridFooterRowItemProvider cxGridFooterRowItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridFooterRowAdapter() {
+		if (cxGridFooterRowItemProvider == null) {
+			cxGridFooterRowItemProvider = new CxGridFooterRowItemProvider(this);
+		}
+
+		return cxGridFooterRowItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridFilterRowItemProvider cxGridFilterRowItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridFilterRowAdapter() {
+		if (cxGridFilterRowItemProvider == null) {
+			cxGridFilterRowItemProvider = new CxGridFilterRowItemProvider(this);
+		}
+
+		return cxGridFilterRowItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridMetaCellItemProvider cxGridMetaCellItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridMetaCellAdapter() {
+		if (cxGridMetaCellItemProvider == null) {
+			cxGridMetaCellItemProvider = new CxGridMetaCellItemProvider(this);
+		}
+
+		return cxGridMetaCellItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell}
+	 * instances. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridGroupedCellItemProvider cxGridGroupedCellItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridGroupedCellAdapter() {
+		if (cxGridGroupedCellItemProvider == null) {
+			cxGridGroupedCellItemProvider = new CxGridGroupedCellItemProvider(
+					this);
+		}
+
+		return cxGridGroupedCellItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridColumnItemProvider cxGridColumnItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridColumnAdapter() {
+		if (cxGridColumnItemProvider == null) {
+			cxGridColumnItemProvider = new CxGridColumnItemProvider(this);
+		}
+
+		return cxGridColumnItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator}
+	 * instances. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridDelegateCellStyleGeneratorItemProvider cxGridDelegateCellStyleGeneratorItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator}
+	 * . <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridDelegateCellStyleGeneratorAdapter() {
+		if (cxGridDelegateCellStyleGeneratorItemProvider == null) {
+			cxGridDelegateCellStyleGeneratorItemProvider = new CxGridDelegateCellStyleGeneratorItemProvider(
+					this);
+		}
+
+		return cxGridDelegateCellStyleGeneratorItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected CxGridSortableItemProvider cxGridSortableItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridSortableAdapter() {
+		if (cxGridSortableItemProvider == null) {
+			cxGridSortableItemProvider = new CxGridSortableItemProvider(this);
+		}
+
+		return cxGridSortableItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the root adapter factory
+	 * @generated
+	 */
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory
+				.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param parentAdapterFactory
+	 *            the new this keeps track of the root adapter factory that
+	 *            delegates to this adapter factory
+	 * @generated
+	 */
+	public void setParentAdapterFactory(
+			ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param type
+	 *            the type
+	 * @return true, if is factory for type
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the
+	 * adapter. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param type
+	 *            the type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>)
+					|| (((Class<?>) type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the child creation extenders
+	 * @generated
+	 */
+	public List<IChildCreationExtender> getChildCreationExtenders() {
+		return childCreationExtenderManager.getChildCreationExtenders();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param editingDomain
+	 *            the editing domain
+	 * @return the new child descriptors
+	 * @generated
+	 */
+	public Collection<?> getNewChildDescriptors(Object object,
+			EditingDomain editingDomain) {
+		return childCreationExtenderManager.getNewChildDescriptors(object,
+				editingDomain);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	public ResourceLocator getResourceLocator() {
+		return childCreationExtenderManager;
+	}
+
+	/**
+	 * This adds a listener. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to
+	 * {@link #parentAdapterFactory}. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param notification
+	 *            the notification
+	 * @generated
+	 */
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void dispose() {
+		if (cxGridItemProvider != null)
+			cxGridItemProvider.dispose();
+		if (cxGridHeaderRowItemProvider != null)
+			cxGridHeaderRowItemProvider.dispose();
+		if (cxGridFooterRowItemProvider != null)
+			cxGridFooterRowItemProvider.dispose();
+		if (cxGridFilterRowItemProvider != null)
+			cxGridFilterRowItemProvider.dispose();
+		if (cxGridMetaCellItemProvider != null)
+			cxGridMetaCellItemProvider.dispose();
+		if (cxGridGroupedCellItemProvider != null)
+			cxGridGroupedCellItemProvider.dispose();
+		if (cxGridColumnItemProvider != null)
+			cxGridColumnItemProvider.dispose();
+		if (cxGridDelegateCellStyleGeneratorItemProvider != null)
+			cxGridDelegateCellStyleGeneratorItemProvider.dispose();
+		if (cxGridSortableItemProvider != null)
+			cxGridSortableItemProvider.dispose();
+	}
+
+	/**
+	 * A child creation extender for the {@link CoreModelPackage}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public static class CoreModelChildCreationExtender implements
+			IChildCreationExtender {
+		/**
+		 * The switch for creating child descriptors specific to each extended
+		 * class. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
+		 * @generated
+		 */
+		protected static class CreationSwitch extends CoreModelSwitch<Object> {
+			/**
+			 * The child descriptors being populated. <!-- begin-user-doc -->
+			 * <!-- end-user-doc -->
+			 * 
+			 * @generated
+			 */
+			protected List<Object> newChildDescriptors;
+
+			/**
+			 * The domain in which to create the children. <!-- begin-user-doc
+			 * --> <!-- end-user-doc -->
+			 * 
+			 * @generated
+			 */
+			protected EditingDomain editingDomain;
+
+			/**
+			 * Creates the a switch for populating child descriptors in the
+			 * given domain. <!-- begin-user-doc --> <!-- end-user-doc -->
+			 * 
+			 * @generated
+			 */
+			CreationSwitch(List<Object> newChildDescriptors,
+					EditingDomain editingDomain) {
+				this.newChildDescriptors = newChildDescriptors;
+				this.editingDomain = editingDomain;
+			}
+
+			/**
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYLayout(YLayout object) {
+				newChildDescriptors.add(createChildParameter(
+						CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						CxGridFactory.eINSTANCE.createCxGrid()));
+
+				return null;
+			}
+
+			/**
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYView(YView object) {
+				newChildDescriptors.add(createChildParameter(
+						CoreModelPackage.Literals.YVIEW__CONTENT,
+						CxGridFactory.eINSTANCE.createCxGrid()));
+
+				return null;
+			}
+
+			/**
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYDialog(YDialog object) {
+				newChildDescriptors.add(createChildParameter(
+						CoreModelPackage.Literals.YDIALOG__CONTENT,
+						CxGridFactory.eINSTANCE.createCxGrid()));
+
+				return null;
+			}
+
+			/**
+			 *
+			 * @param feature
+			 *            the feature
+			 * @param child
+			 *            the child
+			 * @return the command parameter
+			 * @generated
+			 */
+			protected CommandParameter createChildParameter(Object feature,
+					Object child) {
+				return new CommandParameter(null, feature, child);
+			}
+
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @param object
+		 *            the object
+		 * @param editingDomain
+		 *            the editing domain
+		 * @return the new child descriptors
+		 * @generated
+		 */
+		public Collection<Object> getNewChildDescriptors(Object object,
+				EditingDomain editingDomain) {
+			ArrayList<Object> result = new ArrayList<Object>();
+			new CreationSwitch(result, editingDomain)
+					.doSwitch((EObject) object);
+			return result;
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @return the resource locator
+		 * @generated
+		 */
+		public ResourceLocator getResourceLocator() {
+			return CxGridEditPlugin.INSTANCE;
+		}
+	}
+
+	/**
+	 * A child creation extender for the {@link ExtensionModelPackage}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public static class ExtensionModelChildCreationExtender implements
+			IChildCreationExtender {
+		/**
+		 * The switch for creating child descriptors specific to each extended
+		 * class. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
+		 * @generated
+		 */
+		protected static class CreationSwitch extends
+				ExtensionModelSwitch<Object> {
+			/**
+			 * The child descriptors being populated. <!-- begin-user-doc -->
+			 * <!-- end-user-doc -->
+			 * 
+			 * @generated
+			 */
+			protected List<Object> newChildDescriptors;
+
+			/**
+			 * The domain in which to create the children. <!-- begin-user-doc
+			 * --> <!-- end-user-doc -->
+			 * 
+			 * @generated
+			 */
+			protected EditingDomain editingDomain;
+
+			/**
+			 * Creates the a switch for populating child descriptors in the
+			 * given domain. <!-- begin-user-doc --> <!-- end-user-doc -->
+			 * 
+			 * @generated
+			 */
+			CreationSwitch(List<Object> newChildDescriptors,
+					EditingDomain editingDomain) {
+				this.newChildDescriptors = newChildDescriptors;
+				this.editingDomain = editingDomain;
+			}
+
+			/**
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYTab(YTab object) {
+				newChildDescriptors.add(createChildParameter(
+						ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						CxGridFactory.eINSTANCE.createCxGrid()));
+
+				return null;
+			}
+
+			/**
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYMasterDetail(YMasterDetail object) {
+				newChildDescriptors
+						.add(createChildParameter(
+								ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+								CxGridFactory.eINSTANCE.createCxGrid()));
+
+				newChildDescriptors
+						.add(createChildParameter(
+								ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+								CxGridFactory.eINSTANCE.createCxGrid()));
+
+				return null;
+			}
+
+			/**
+			 *
+			 * @param feature
+			 *            the feature
+			 * @param child
+			 *            the child
+			 * @return the command parameter
+			 * @generated
+			 */
+			protected CommandParameter createChildParameter(Object feature,
+					Object child) {
+				return new CommandParameter(null, feature, child);
+			}
+
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @param object
+		 *            the object
+		 * @param editingDomain
+		 *            the editing domain
+		 * @return the new child descriptors
+		 * @generated
+		 */
+		public Collection<Object> getNewChildDescriptors(Object object,
+				EditingDomain editingDomain) {
+			ArrayList<Object> result = new ArrayList<Object>();
+			new CreationSwitch(result, editingDomain)
+					.doSwitch((EObject) object);
+			return result;
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @return the resource locator
+		 * @generated
+		 */
+		public ResourceLocator getResourceLocator() {
+			return CxGridEditPlugin.INSTANCE;
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridMetaCellItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridMetaCellItemProvider.java
new file mode 100644
index 0000000..aef8eb6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridMetaCellItemProvider.java
@@ -0,0 +1,604 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridMetaCellItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridMetaCellItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addTargetPropertyDescriptor(object);
+			addLabelPropertyDescriptor(object);
+			addLabelI18nKeyPropertyDescriptor(object);
+			addUseHTMLPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Target feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTargetPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMetaCell_target_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMetaCell_target_feature", "_UI_CxGridMetaCell_type"),
+				 CxGridPackage.Literals.CX_GRID_META_CELL__TARGET,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMetaCell_label_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMetaCell_label_feature", "_UI_CxGridMetaCell_type"),
+				 CxGridPackage.Literals.CX_GRID_META_CELL__LABEL,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label I1 8n Key feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelI18nKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMetaCell_labelI18nKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMetaCell_labelI18nKey_feature", "_UI_CxGridMetaCell_type"),
+				 CxGridPackage.Literals.CX_GRID_META_CELL__LABEL_I1_8N_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Use HTML feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addUseHTMLPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridMetaCell_useHTML_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridMetaCell_useHTML_feature", "_UI_CxGridMetaCell_type"),
+				 CxGridPackage.Literals.CX_GRID_META_CELL__USE_HTML,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridMetaCell.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridMetaCell"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridMetaCell)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridMetaCell_type") :
+			getString("_UI_CxGridMetaCell_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridMetaCell.class)) {
+			case CxGridPackage.CX_GRID_META_CELL__TAGS:
+			case CxGridPackage.CX_GRID_META_CELL__ID:
+			case CxGridPackage.CX_GRID_META_CELL__NAME:
+			case CxGridPackage.CX_GRID_META_CELL__LABEL:
+			case CxGridPackage.CX_GRID_META_CELL__LABEL_I1_8N_KEY:
+			case CxGridPackage.CX_GRID_META_CELL__USE_HTML:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__PROPERTIES:
+			case CxGridPackage.CX_GRID_META_CELL__ELEMENT:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 CxGridFactory.eINSTANCE.createCxGrid()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 CoreModelFactory.eINSTANCE.createYLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 CoreModelFactory.eINSTANCE.createYHelperLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 CoreModelFactory.eINSTANCE.createYField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 CoreModelFactory.eINSTANCE.createYAction()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYGridLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYHorizontalLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYVerticalLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYTable()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYTree()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYOptionsGroup()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYList()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYLabel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYImage()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYBeanReferenceField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYTextArea()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYCheckBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYBrowser()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYDateTime()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYDecimalField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYNumericField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYButton()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYSlider()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYToggleButton()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYProgressBar()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYTabSheet()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYMasterDetail()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYFormLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYTextSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYBooleanSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYNumericSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYReferenceSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYSplitPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYSearchPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYEnumOptionsGroup()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYEnumList()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYEnumComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYCssLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYAbsoluteLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYSuggestTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridPackage.Literals.CX_GRID_META_CELL__ELEMENT,
+				 ExtensionModelFactory.eINSTANCE.createYPasswordField()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridSortableItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridSortableItemProvider.java
new file mode 100644
index 0000000..3a52a8c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/provider/CxGridSortableItemProvider.java
@@ -0,0 +1,327 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.CxGridSortable;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridSortableItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridSortableItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addDescendingPropertyDescriptor(object);
+			addColumnPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Descending feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDescendingPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridSortable_descending_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridSortable_descending_feature", "_UI_CxGridSortable_type"),
+				 CxGridPackage.Literals.CX_GRID_SORTABLE__DESCENDING,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Column feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addColumnPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridSortable_column_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridSortable_column_feature", "_UI_CxGridSortable_type"),
+				 CxGridPackage.Literals.CX_GRID_SORTABLE__COLUMN,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridSortable.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridSortable"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridSortable)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridSortable_type") :
+			getString("_UI_CxGridSortable_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridSortable.class)) {
+			case CxGridPackage.CX_GRID_SORTABLE__TAGS:
+			case CxGridPackage.CX_GRID_SORTABLE__ID:
+			case CxGridPackage.CX_GRID_SORTABLE__NAME:
+			case CxGridPackage.CX_GRID_SORTABLE__DESCENDING:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridBooleanRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridBooleanRendererItemProvider.java
new file mode 100644
index 0000000..b59795a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridBooleanRendererItemProvider.java
@@ -0,0 +1,120 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridBooleanRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridBooleanRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns CxGridBooleanRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridBooleanRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridBooleanRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridBooleanRenderer_type") :
+			getString("_UI_CxGridBooleanRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridButtonRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridButtonRendererItemProvider.java
new file mode 100644
index 0000000..95077b2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridButtonRendererItemProvider.java
@@ -0,0 +1,226 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererFactory;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridButtonRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridButtonRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNullRepresentationPropertyDescriptor(object);
+			addEventTopicPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Null Representation feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNullRepresentationPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridButtonRenderer_nullRepresentation_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridButtonRenderer_nullRepresentation_feature", "_UI_CxGridButtonRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Event Topic feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEventTopicPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridButtonRenderer_eventTopic_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridButtonRenderer_eventTopic_feature", "_UI_CxGridButtonRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_BUTTON_RENDERER__EVENT_TOPIC,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CxGridRendererPackage.Literals.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridButtonRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridButtonRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridButtonRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridButtonRenderer_type") :
+			getString("_UI_CxGridButtonRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridButtonRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION:
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__EVENT_TOPIC:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridRendererPackage.Literals.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT,
+				 CxGridRendererFactory.eINSTANCE.createCxGridRendererClickEvent()));
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridDateRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridDateRendererItemProvider.java
new file mode 100644
index 0000000..ce98008
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridDateRendererItemProvider.java
@@ -0,0 +1,155 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridDateRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridDateRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addDateFormatPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Date Format feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDateFormatPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridDateRenderer_dateFormat_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridDateRenderer_dateFormat_feature", "_UI_CxGridDateRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_DATE_RENDERER__DATE_FORMAT,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridDateRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridDateRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridDateRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridDateRenderer_type") :
+			getString("_UI_CxGridDateRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridDateRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_DATE_RENDERER__DATE_FORMAT:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridDelegateRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridDelegateRendererItemProvider.java
new file mode 100644
index 0000000..8524d88
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridDelegateRendererItemProvider.java
@@ -0,0 +1,155 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridDelegateRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridDelegateRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addDelegateIdPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Delegate Id feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDelegateIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridDelegateRenderer_delegateId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridDelegateRenderer_delegateId_feature", "_UI_CxGridDelegateRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_DELEGATE_RENDERER__DELEGATE_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridDelegateRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridDelegateRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridDelegateRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridDelegateRenderer_type") :
+			getString("_UI_CxGridDelegateRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridDelegateRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER__DELEGATE_ID:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridHtmlRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridHtmlRendererItemProvider.java
new file mode 100644
index 0000000..a95fc72
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridHtmlRendererItemProvider.java
@@ -0,0 +1,155 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridHtmlRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridHtmlRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNullRepresentationPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Null Representation feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNullRepresentationPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridHtmlRenderer_nullRepresentation_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridHtmlRenderer_nullRepresentation_feature", "_UI_CxGridHtmlRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_HTML_RENDERER__NULL_REPRESENTATION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridHtmlRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridHtmlRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridHtmlRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridHtmlRenderer_type") :
+			getString("_UI_CxGridHtmlRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridHtmlRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_HTML_RENDERER__NULL_REPRESENTATION:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridImageRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridImageRendererItemProvider.java
new file mode 100644
index 0000000..b771596
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridImageRendererItemProvider.java
@@ -0,0 +1,200 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererFactory;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridImageRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridImageRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addEventTopicPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Event Topic feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEventTopicPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridImageRenderer_eventTopic_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridImageRenderer_eventTopic_feature", "_UI_CxGridImageRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_IMAGE_RENDERER__EVENT_TOPIC,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CxGridRendererPackage.Literals.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns CxGridImageRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridImageRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridImageRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridImageRenderer_type") :
+			getString("_UI_CxGridImageRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridImageRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__EVENT_TOPIC:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CxGridRendererPackage.Literals.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT,
+				 CxGridRendererFactory.eINSTANCE.createCxGridRendererClickEvent()));
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridIndicatorRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridIndicatorRendererItemProvider.java
new file mode 100644
index 0000000..622fef5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridIndicatorRendererItemProvider.java
@@ -0,0 +1,181 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridIndicatorRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridIndicatorRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addRedEndsPropertyDescriptor(object);
+			addGreenStartsPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Red Ends feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addRedEndsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridIndicatorRenderer_redEnds_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridIndicatorRenderer_redEnds_feature", "_UI_CxGridIndicatorRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_INDICATOR_RENDERER__RED_ENDS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.REAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Green Starts feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addGreenStartsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridIndicatorRenderer_greenStarts_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridIndicatorRenderer_greenStarts_feature", "_UI_CxGridIndicatorRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_INDICATOR_RENDERER__GREEN_STARTS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.REAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridIndicatorRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridIndicatorRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridIndicatorRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridIndicatorRenderer_type") :
+			getString("_UI_CxGridIndicatorRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridIndicatorRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__RED_ENDS:
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__GREEN_STARTS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridNumberRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridNumberRendererItemProvider.java
new file mode 100644
index 0000000..405bf9e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridNumberRendererItemProvider.java
@@ -0,0 +1,181 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridNumberRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridNumberRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNumberFormatPropertyDescriptor(object);
+			addNullRepresentationPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Number Format feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNumberFormatPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridNumberRenderer_numberFormat_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridNumberRenderer_numberFormat_feature", "_UI_CxGridNumberRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Null Representation feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNullRepresentationPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridNumberRenderer_nullRepresentation_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridNumberRenderer_nullRepresentation_feature", "_UI_CxGridNumberRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridNumberRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridNumberRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridNumberRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridNumberRenderer_type") :
+			getString("_UI_CxGridNumberRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridNumberRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT:
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridPriceRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridPriceRendererItemProvider.java
new file mode 100644
index 0000000..bdaf3ce
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridPriceRendererItemProvider.java
@@ -0,0 +1,256 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridPriceRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridPriceRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValuePropertyPathPropertyDescriptor(object);
+			addCurrencyPropertyPathPropertyDescriptor(object);
+			addNullRepresentationPropertyDescriptor(object);
+			addHtmlPatternPropertyDescriptor(object);
+			addNumberFormatPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Property Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridPriceRenderer_valuePropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridPriceRenderer_valuePropertyPath_feature", "_UI_CxGridPriceRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Currency Property Path feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addCurrencyPropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridPriceRenderer_currencyPropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridPriceRenderer_currencyPropertyPath_feature", "_UI_CxGridPriceRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Null Representation feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNullRepresentationPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridPriceRenderer_nullRepresentation_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridPriceRenderer_nullRepresentation_feature", "_UI_CxGridPriceRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Html Pattern feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHtmlPatternPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridPriceRenderer_htmlPattern_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridPriceRenderer_htmlPattern_feature", "_UI_CxGridPriceRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_PRICE_RENDERER__HTML_PATTERN,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Number Format feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNumberFormatPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridPriceRenderer_numberFormat_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridPriceRenderer_numberFormat_feature", "_UI_CxGridPriceRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_PRICE_RENDERER__NUMBER_FORMAT,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridPriceRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridPriceRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridPriceRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridPriceRenderer_type") :
+			getString("_UI_CxGridPriceRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridPriceRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH:
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH:
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION:
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__HTML_PATTERN:
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NUMBER_FORMAT:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridProgressBarRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridProgressBarRendererItemProvider.java
new file mode 100644
index 0000000..8aee9f7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridProgressBarRendererItemProvider.java
@@ -0,0 +1,155 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridProgressBarRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridProgressBarRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addMaxValuePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Max Value feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addMaxValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridProgressBarRenderer_maxValue_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridProgressBarRenderer_maxValue_feature", "_UI_CxGridProgressBarRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.REAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridProgressBarRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridProgressBarRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridProgressBarRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridProgressBarRenderer_type") :
+			getString("_UI_CxGridProgressBarRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridProgressBarRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridQuantityRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridQuantityRendererItemProvider.java
new file mode 100644
index 0000000..cf7bd0b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridQuantityRendererItemProvider.java
@@ -0,0 +1,259 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridQuantityRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridQuantityRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValuePropertyPathPropertyDescriptor(object);
+			addUomPropertyPathPropertyDescriptor(object);
+			addNullRepresentationPropertyDescriptor(object);
+			addHtmlPatternPropertyDescriptor(object);
+			addNumberFormatPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Property Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridQuantityRenderer_valuePropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridQuantityRenderer_valuePropertyPath_feature", "_UI_CxGridQuantityRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Uom Property Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addUomPropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridQuantityRenderer_uomPropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridQuantityRenderer_uomPropertyPath_feature", "_UI_CxGridQuantityRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Null Representation feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNullRepresentationPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridQuantityRenderer_nullRepresentation_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridQuantityRenderer_nullRepresentation_feature", "_UI_CxGridQuantityRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Html Pattern feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addHtmlPatternPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridQuantityRenderer_htmlPattern_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridQuantityRenderer_htmlPattern_feature", "_UI_CxGridQuantityRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_QUANTITY_RENDERER__HTML_PATTERN,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Number Format feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNumberFormatPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridQuantityRenderer_numberFormat_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridQuantityRenderer_numberFormat_feature", "_UI_CxGridQuantityRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridQuantityRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridQuantityRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridQuantityRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridQuantityRenderer_type") :
+			getString("_UI_CxGridQuantityRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridQuantityRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH:
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH:
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION:
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__HTML_PATTERN:
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererClickEventItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererClickEventItemProvider.java
new file mode 100644
index 0000000..cdcb649
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererClickEventItemProvider.java
@@ -0,0 +1,207 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.provider.CxGridEditPlugin;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridRendererClickEventItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridRendererClickEventItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addRendererPropertyDescriptor(object);
+			addLastClickTimePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Renderer feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addRendererPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridRendererClickEvent_renderer_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridRendererClickEvent_renderer_feature", "_UI_CxGridRendererClickEvent_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_RENDERER_CLICK_EVENT__RENDERER,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Last Click Time feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLastClickTimePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridRendererClickEvent_lastClickTime_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridRendererClickEvent_lastClickTime_feature", "_UI_CxGridRendererClickEvent_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridRendererClickEvent.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridRendererClickEvent"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		CxGridRendererClickEvent cxGridRendererClickEvent = (CxGridRendererClickEvent)object;
+		return getString("_UI_CxGridRendererClickEvent_type") + " " + cxGridRendererClickEvent.getLastClickTime();
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridRendererClickEvent.class)) {
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return CxGridEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererItemProvider.java
new file mode 100644
index 0000000..69b1b0d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererItemProvider.java
@@ -0,0 +1,266 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.provider.CxGridEditPlugin;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridRendererItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridRenderer_type") :
+			getString("_UI_CxGridRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_RENDERER__TAGS:
+			case CxGridRendererPackage.CX_GRID_RENDERER__ID:
+			case CxGridRendererPackage.CX_GRID_RENDERER__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return CxGridEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererItemProviderAdapterFactory.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererItemProviderAdapterFactory.java
new file mode 100644
index 0000000..0dc3f9f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridRendererItemProviderAdapterFactory.java
@@ -0,0 +1,498 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.util.CxGridRendererAdapterFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support Viewers.
+ * The adapters generated by this factory convert EMF adapter notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}.
+ * The adapters also support Eclipse property sheets.
+ * Note that most of the adapters are shared among multiple instances.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridRendererItemProviderAdapterFactory extends CxGridRendererAdapterFactory implements ComposeableAdapterFactory, IChangeNotifier, IDisposable {
+	
+	/**
+	 * This keeps track of the root adapter factory that delegates to this adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement {@link org.eclipse.emf.edit.provider.IChangeNotifier}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This keeps track of all the supported types checked by {@link #isFactoryForType isFactoryForType}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridRendererItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridDelegateRendererItemProvider cxGridDelegateRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridDelegateRendererAdapter() {
+		if (cxGridDelegateRendererItemProvider == null) {
+			cxGridDelegateRendererItemProvider = new CxGridDelegateRendererItemProvider(this);
+		}
+
+		return cxGridDelegateRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridDateRendererItemProvider cxGridDateRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridDateRendererAdapter() {
+		if (cxGridDateRendererItemProvider == null) {
+			cxGridDateRendererItemProvider = new CxGridDateRendererItemProvider(this);
+		}
+
+		return cxGridDateRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridHtmlRendererItemProvider cxGridHtmlRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridHtmlRendererAdapter() {
+		if (cxGridHtmlRendererItemProvider == null) {
+			cxGridHtmlRendererItemProvider = new CxGridHtmlRendererItemProvider(this);
+		}
+
+		return cxGridHtmlRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridNumberRendererItemProvider cxGridNumberRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridNumberRendererAdapter() {
+		if (cxGridNumberRendererItemProvider == null) {
+			cxGridNumberRendererItemProvider = new CxGridNumberRendererItemProvider(this);
+		}
+
+		return cxGridNumberRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridProgressBarRendererItemProvider cxGridProgressBarRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridProgressBarRendererAdapter() {
+		if (cxGridProgressBarRendererItemProvider == null) {
+			cxGridProgressBarRendererItemProvider = new CxGridProgressBarRendererItemProvider(this);
+		}
+
+		return cxGridProgressBarRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridTextRendererItemProvider cxGridTextRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridTextRendererAdapter() {
+		if (cxGridTextRendererItemProvider == null) {
+			cxGridTextRendererItemProvider = new CxGridTextRendererItemProvider(this);
+		}
+
+		return cxGridTextRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridButtonRendererItemProvider cxGridButtonRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridButtonRendererAdapter() {
+		if (cxGridButtonRendererItemProvider == null) {
+			cxGridButtonRendererItemProvider = new CxGridButtonRendererItemProvider(this);
+		}
+
+		return cxGridButtonRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridImageRendererItemProvider cxGridImageRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridImageRendererAdapter() {
+		if (cxGridImageRendererItemProvider == null) {
+			cxGridImageRendererItemProvider = new CxGridImageRendererItemProvider(this);
+		}
+
+		return cxGridImageRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridRendererClickEventItemProvider cxGridRendererClickEventItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridRendererClickEventAdapter() {
+		if (cxGridRendererClickEventItemProvider == null) {
+			cxGridRendererClickEventItemProvider = new CxGridRendererClickEventItemProvider(this);
+		}
+
+		return cxGridRendererClickEventItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridBooleanRendererItemProvider cxGridBooleanRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridBooleanRendererAdapter() {
+		if (cxGridBooleanRendererItemProvider == null) {
+			cxGridBooleanRendererItemProvider = new CxGridBooleanRendererItemProvider(this);
+		}
+
+		return cxGridBooleanRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridQuantityRendererItemProvider cxGridQuantityRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridQuantityRendererAdapter() {
+		if (cxGridQuantityRendererItemProvider == null) {
+			cxGridQuantityRendererItemProvider = new CxGridQuantityRendererItemProvider(this);
+		}
+
+		return cxGridQuantityRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridPriceRendererItemProvider cxGridPriceRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridPriceRendererAdapter() {
+		if (cxGridPriceRendererItemProvider == null) {
+			cxGridPriceRendererItemProvider = new CxGridPriceRendererItemProvider(this);
+		}
+
+		return cxGridPriceRendererItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridIndicatorRendererItemProvider cxGridIndicatorRendererItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createCxGridIndicatorRendererAdapter() {
+		if (cxGridIndicatorRendererItemProvider == null) {
+			cxGridIndicatorRendererItemProvider = new CxGridIndicatorRendererItemProvider(this);
+		}
+
+		return cxGridIndicatorRendererItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the root adapter factory
+	 * @generated
+	 */
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param parentAdapterFactory
+	 *            the new this keeps track of the root adapter factory that
+	 *            delegates to this adapter factory
+	 * @generated
+	 */
+	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param type
+	 *            the type
+	 * @return true, if is factory for type
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the adapter.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param type
+	 *            the type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>) || (((Class<?>)type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * This adds a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to
+	 * {@link #parentAdapterFactory}. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param notification
+	 *            the notification
+	 * @generated
+	 */
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory. 
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void dispose() {
+		if (cxGridDelegateRendererItemProvider != null) cxGridDelegateRendererItemProvider.dispose();
+		if (cxGridDateRendererItemProvider != null) cxGridDateRendererItemProvider.dispose();
+		if (cxGridHtmlRendererItemProvider != null) cxGridHtmlRendererItemProvider.dispose();
+		if (cxGridNumberRendererItemProvider != null) cxGridNumberRendererItemProvider.dispose();
+		if (cxGridProgressBarRendererItemProvider != null) cxGridProgressBarRendererItemProvider.dispose();
+		if (cxGridTextRendererItemProvider != null) cxGridTextRendererItemProvider.dispose();
+		if (cxGridButtonRendererItemProvider != null) cxGridButtonRendererItemProvider.dispose();
+		if (cxGridImageRendererItemProvider != null) cxGridImageRendererItemProvider.dispose();
+		if (cxGridRendererClickEventItemProvider != null) cxGridRendererClickEventItemProvider.dispose();
+		if (cxGridBooleanRendererItemProvider != null) cxGridBooleanRendererItemProvider.dispose();
+		if (cxGridQuantityRendererItemProvider != null) cxGridQuantityRendererItemProvider.dispose();
+		if (cxGridPriceRendererItemProvider != null) cxGridPriceRendererItemProvider.dispose();
+		if (cxGridIndicatorRendererItemProvider != null) cxGridIndicatorRendererItemProvider.dispose();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridTextRendererItemProvider.java b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridTextRendererItemProvider.java
new file mode 100644
index 0000000..eace3c0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model.edit/src/org/eclipse/osbp/ecview/extension/grid/renderer/provider/CxGridTextRendererItemProvider.java
@@ -0,0 +1,155 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.provider;
+
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridTextRendererItemProvider extends CxGridRendererItemProvider {
+	
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public CxGridTextRendererItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNullRepresentationPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Null Representation feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNullRepresentationPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_CxGridTextRenderer_nullRepresentation_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_CxGridTextRenderer_nullRepresentation_feature", "_UI_CxGridTextRenderer_type"),
+				 CxGridRendererPackage.Literals.CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns CxGridTextRenderer.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/CxGridTextRenderer"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((CxGridTextRenderer)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_CxGridTextRenderer_type") :
+			getString("_UI_CxGridTextRenderer_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(CxGridTextRenderer.class)) {
+			case CxGridRendererPackage.CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/.project b/org.eclipse.osbp.ecview.extension.grid.model/.project
new file mode 100644
index 0000000..1e22935
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/.project
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.grid.model</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/LICENSE.txt b/org.eclipse.osbp.ecview.extension.grid.model/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/META-INF/MANIFEST.MF b/org.eclipse.osbp.ecview.extension.grid.model/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..7cd9f22
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/META-INF/MANIFEST.MF
@@ -0,0 +1,25 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.ecview.extension.grid.model
+Bundle-SymbolicName: org.eclipse.osbp.ecview.extension.grid.model;singleton:=true
+Bundle-Version: 0.9.0.qualifier
+Bundle-ClassPath: .
+Bundle-Vendor: Eclipse OSBP
+ Germany)
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.emf.ecore;visibility:=reexport,
+ org.eclipse.osbp.ecview.core.common.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.extension.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport
+Bundle-ActivationPolicy: lazy
+Export-Package: org.eclipse.osbp.ecview.extension.grid;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.impl;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.memento;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.memento.impl;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.memento.util;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.renderer;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.renderer.impl;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.renderer.util;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.grid.util;version="0.9.0"
+Import-Package: org.eclipse.osbp.ui.api.useraccess;version="0.9.0"
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/about.html b/org.eclipse.osbp.ecview.extension.grid.model/about.html
new file mode 100644
index 0000000..64c0598
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/about.html
@@ -0,0 +1,28 @@
+<!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>June 1, 2016</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &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>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/about.ini b/org.eclipse.osbp.ecview.extension.grid.model/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/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.ecview.extension.grid.model/about.mappings b/org.eclipse.osbp.ecview.extension.grid.model/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/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.ecview.extension.grid.model/about.properties b/org.eclipse.osbp.ecview.extension.grid.model/about.properties
new file mode 100644
index 0000000..8272479
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/about.properties
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.ecview.extension.grid.model
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - implementation\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/build.properties b/org.eclipse.osbp.ecview.extension.grid.model/build.properties
new file mode 100644
index 0000000..1b850aa
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/build.properties
@@ -0,0 +1,15 @@
+#
+output.. = target/classes/
+bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  .,\
+               model/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               license.html,\
+               LICENSE.txt,\
+               epl-v10.html
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
+               LICENSE.txt,\
+               epl-v10.html			   
+jars.compile.order = .
+source.. = src/
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/epl-v10.html b/org.eclipse.osbp.ecview.extension.grid.model/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/license.html b/org.eclipse.osbp.ecview.extension.grid.model/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.aird b/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.aird
new file mode 100644
index 0000000..fbf3b4c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.aird
@@ -0,0 +1,2730 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<viewpoint:DAnalysis xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:description="http://www.eclipse.org/sirius/description/1.1.0" xmlns:description_1="http://www.eclipse.org/sirius/diagram/description/1.1.0" xmlns:diagram="http://www.eclipse.org/sirius/diagram/1.1.0" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:notation="http://www.eclipse.org/gmf/runtime/1.0.2/notation" xmlns:style="http://www.eclipse.org/sirius/diagram/description/style/1.1.0" xmlns:viewpoint="http://www.eclipse.org/sirius/1.1.0" xsi:schemaLocation="http://www.eclipse.org/sirius/description/1.1.0 http://www.eclipse.org/sirius/1.1.0#//description http://www.eclipse.org/sirius/diagram/description/1.1.0 http://www.eclipse.org/sirius/diagram/1.1.0#//description http://www.eclipse.org/sirius/diagram/description/style/1.1.0 http://www.eclipse.org/sirius/diagram/1.1.0#//description/style" xmi:id="_A2WegAFYEeaZkPiwH6BSQw" selectedViews="_Br3xQAFYEeaZkPiwH6BSQw _CGtTIAFYEeaZkPiwH6BSQw _CG_nAAFYEeaZkPiwH6BSQw _CLMxkAFYEeaZkPiwH6BSQw" version="10.0.0.201505222000">
+  <semanticResources>cxgrid.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore</semanticResources>
+  <semanticResources>http://www.eclipse.org/emf/2002/Ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore</semanticResources>
+  <ownedViews xmi:type="viewpoint:DRepresentationContainer" xmi:id="_Br3xQAFYEeaZkPiwH6BSQw">
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_B4ZxYAFYEeaZkPiwH6BSQw" name="grid class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_B4ZxYQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_B4ZxYgFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_B5QF8AFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_B5QF8QFYEeaZkPiwH6BSQw" type="Sirius" element="_B4ZxYAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_B5sx4AFYEeaZkPiwH6BSQw" type="2001" element="_B4ZxYwFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_B6YHUAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_B6YHUQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CEd3cAFYEeaZkPiwH6BSQw" type="3005" element="_B4ZxZAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CEd3cQFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CEd3cgFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_B5sx4QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_B5sx4gFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_B5QF8gFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_B4ZxYwFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="cxgrid.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="cxgrid.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_B4ZxZAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_B4ZxZQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="cxgrid.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CEz1sAFYEeaZkPiwH6BSQw" name="renderer class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CEz1sQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CEz1sgFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CE0cwAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CE0cwQFYEeaZkPiwH6BSQw" type="Sirius" element="_CEz1sAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CE0cwwFYEeaZkPiwH6BSQw" type="2001" element="_CEz1swFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CE1q4AFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CE1q4QFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CE2R8AFYEeaZkPiwH6BSQw" type="3005" element="_CEz1tAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CE2R8QFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CE2R8gFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CE0cxAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CE0cxQFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CE0cwgFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CEz1swFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="cxgrid.ecore#//renderer"/>
+        <semanticElements xmi:type="ecore:EPackage" href="cxgrid.ecore#//renderer"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CEz1tAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CEz1tQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="cxgrid.ecore#//renderer"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CFAC8AFYEeaZkPiwH6BSQw" name="memento class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFAC8QFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CFAC8gFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFAqAAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CFAqAQFYEeaZkPiwH6BSQw" type="Sirius" element="_CFAC8AFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CFAqAwFYEeaZkPiwH6BSQw" type="2001" element="_CFAC8wFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CFB4IAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CFB4IQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CFCfMAFYEeaZkPiwH6BSQw" type="3005" element="_CFAC9AFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CFCfMQFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFCfMgFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CFAqBAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFAqBQFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CFAqAgFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CFAC8wFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="cxgrid.ecore#//memento"/>
+        <semanticElements xmi:type="ecore:EPackage" href="cxgrid.ecore#//memento"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CFAC9AFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CFAC9QFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="cxgrid.ecore#//memento"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CFJz8AFYEeaZkPiwH6BSQw" name="extension class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFJz8QFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CFJz8gFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFKbAAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CFKbAQFYEeaZkPiwH6BSQw" type="Sirius" element="_CFJz8AFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CFKbAwFYEeaZkPiwH6BSQw" type="2001" element="_CFJz8wFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CFLpIAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CFLpIQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CFMQMAFYEeaZkPiwH6BSQw" type="3005" element="_CFJz9AFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CFMQMQFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFMQMgFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CFKbBAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFKbBQFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CFKbAgFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CFJz8wFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CFJz9AFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CFJz9QFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CFcH0AFYEeaZkPiwH6BSQw" name="core class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFcH0QFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CFcH0gFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFcu4AFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CFcu4QFYEeaZkPiwH6BSQw" type="Sirius" element="_CFcH0AFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CFcu4wFYEeaZkPiwH6BSQw" type="2001" element="_CFcH0wFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CFd9AAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CFd9AQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CFekEAFYEeaZkPiwH6BSQw" type="3005" element="_CFcH1AFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CFekEQFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFekEgFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CFcu5AFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFcu5QFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CFcu4gFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CFcH0wFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CFcH1AFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CFcH1QFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CFr_cAFYEeaZkPiwH6BSQw" name="ecore class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFr_cQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CFr_cgFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CFsmgAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CFsmgQFYEeaZkPiwH6BSQw" type="Sirius" element="_CFr_cAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CFsmgwFYEeaZkPiwH6BSQw" type="2001" element="_CFr_cwFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CFtNkAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CFtNkQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CFt0oAFYEeaZkPiwH6BSQw" type="3005" element="_CFr_dAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CFt0oQFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFt0ogFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CFsmhAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CFsmhQFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CFsmggFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CFr_cwFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="http://www.eclipse.org/emf/2002/Ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="http://www.eclipse.org/emf/2002/Ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CFr_dAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CFr_dQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="http://www.eclipse.org/emf/2002/Ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CF4MsAFYEeaZkPiwH6BSQw" name="binding class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CF4MsQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CF4MsgFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CF4zwAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CF4zwQFYEeaZkPiwH6BSQw" type="Sirius" element="_CF4MsAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CF4zwwFYEeaZkPiwH6BSQw" type="2001" element="_CF4MswFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CF5a0AFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CF5a0QFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CF6B4AFYEeaZkPiwH6BSQw" type="3005" element="_CF4MtAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CF6B4QFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CF6B4gFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CF4zxAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CF4zxQFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CF4zwgFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CF4MswFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CF4MtAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CF4MtQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CGBWoAFYEeaZkPiwH6BSQw" name="datatypes class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGBWoQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CGBWogFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGB9sAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CGB9sQFYEeaZkPiwH6BSQw" type="Sirius" element="_CGBWoAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CGB9swFYEeaZkPiwH6BSQw" type="2001" element="_CGBWowFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CGDL0AFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CGDL0QFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CGEZ8AFYEeaZkPiwH6BSQw" type="3005" element="_CGBWpAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CGEZ8QFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGEZ8gFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CGB9tAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGB9tQFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CGB9sgFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CGBWowFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CGBWpAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CGBWpQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CGLHoAFYEeaZkPiwH6BSQw" name="datatypes class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGLHoQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CGLHogFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGLHpgFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CGLHpwFYEeaZkPiwH6BSQw" type="Sirius" element="_CGLHoAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CGLusAFYEeaZkPiwH6BSQw" type="2001" element="_CGLHowFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CGMVwAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CGMVwQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CGM80AFYEeaZkPiwH6BSQw" type="3005" element="_CGLHpAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CGM80QFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGM80gFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CGLusQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGLusgFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CGLHqAFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CGLHowFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CGLHpAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CGLHpQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CGTDcAFYEeaZkPiwH6BSQw" name="validation class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGTDcQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CGTDcgFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGTDdgFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CGTDdwFYEeaZkPiwH6BSQw" type="Sirius" element="_CGTDcAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CGTqgAFYEeaZkPiwH6BSQw" type="2001" element="_CGTDcwFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CGURkAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CGURkQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CGU4oAFYEeaZkPiwH6BSQw" type="3005" element="_CGTDdAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CGU4oQFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGU4ogFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CGTqgQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGTqggFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CGTDeAFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CGTDcwFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CGTDdAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CGTDdQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_CGaYMAFYEeaZkPiwH6BSQw" name="visibility class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGaYMQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_CGaYMgFYEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_CGa_QAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_CGa_QQFYEeaZkPiwH6BSQw" type="Sirius" element="_CGaYMAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_CGa_QwFYEeaZkPiwH6BSQw" type="2001" element="_CGaYMwFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_CGbmUAFYEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_CGbmUQFYEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_CGcNYAFYEeaZkPiwH6BSQw" type="3005" element="_CGaYNAFYEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_CGcNYQFYEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGcNYgFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_CGa_RAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_CGa_RQFYEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_CGa_QgFYEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_CGaYMwFYEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_CGaYNAFYEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_CGaYNQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_FzH6gAFYEeaZkPiwH6BSQw" name="grid class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_FzH6gQFYEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_FzH6ggFYEeaZkPiwH6BSQw">
+          <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_YRlZ4AFYEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan">
+            <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            <centerLabelStyleDescription xmi:type="style:CenterLabelStyleDescription" xmi:id="_YRlZ4QFYEeaZkPiwH6BSQw" showIcon="false" labelExpression="service:render">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            </centerLabelStyleDescription>
+            <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_YRlZ4gFYEeaZkPiwH6BSQw" labelSize="6" showIcon="false" labelExpression="service:eKeysLabel">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>
+            </endLabelStyleDescription>
+          </computedStyleDescriptions>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_FzIhkAFYEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_FzIhkQFYEeaZkPiwH6BSQw" type="Sirius" element="_FzH6gAFYEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_YSKosAFYEeaZkPiwH6BSQw" type="2003" element="_YPl10AFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_YSL20AFYEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_YSQIQAFYEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_YSjqQAFYEeaZkPiwH6BSQw" type="3010" element="_YQueQAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSjqQQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSjqQgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSk4YAFYEeaZkPiwH6BSQw" type="3010" element="_YQzWwAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSk4YQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSk4YgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSlfcAFYEeaZkPiwH6BSQw" type="3010" element="_YQz90AFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSlfcQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSlfcgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSmGgAFYEeaZkPiwH6BSQw" type="3010" element="_YQ0k4QFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSmGgQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSmGggFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSmGgwFYEeaZkPiwH6BSQw" type="3010" element="_YQ1L8QFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSmGhAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSmGhQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSmtkAFYEeaZkPiwH6BSQw" type="3010" element="_YQ2aEAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSmtkQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSmtkgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSnUoAFYEeaZkPiwH6BSQw" type="3010" element="_YQ3BIQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSnUoQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSnUogFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSnUowFYEeaZkPiwH6BSQw" type="3010" element="_YQ3oMQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSnUpAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSnUpQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSn7sAFYEeaZkPiwH6BSQw" type="3010" element="_YQ5dYAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSn7sQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSn7sgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSoiwAFYEeaZkPiwH6BSQw" type="3010" element="_YQ6EcQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSoiwQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSoiwgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSoiwwFYEeaZkPiwH6BSQw" type="3010" element="_YQ6rgQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSoixAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSoixQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSpJ0AFYEeaZkPiwH6BSQw" type="3010" element="_YQ7SkQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSpJ0QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSpJ0gFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSpw4AFYEeaZkPiwH6BSQw" type="3010" element="_YQ75oQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSpw4QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSpw4gFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSpw4wFYEeaZkPiwH6BSQw" type="3010" element="_YQ8gsQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSpw5AFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSpw5QFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSqX8AFYEeaZkPiwH6BSQw" type="3010" element="_YQ9HwQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSqX8QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSqX8gFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSrmEAFYEeaZkPiwH6BSQw" type="3010" element="_YQ9u0QFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSrmEQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSrmEgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSsNIAFYEeaZkPiwH6BSQw" type="3010" element="_YQ-V4QFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSsNIQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSsNIgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSs0MAFYEeaZkPiwH6BSQw" type="3010" element="_YQ-88QFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSs0MQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSs0MgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSs0MwFYEeaZkPiwH6BSQw" type="3010" element="_YQ_kAQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSs0NAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSs0NQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YStbQAFYEeaZkPiwH6BSQw" type="3010" element="_YRAyIAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YStbQQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YStbQgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_YSQIQQFYEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_YSQIQgFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_YSKosQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YSKosgFYEeaZkPiwH6BSQw" x="90" y="189"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_YSTLkAFYEeaZkPiwH6BSQw" type="2003" element="_YP1GYAFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_YSTyoAFYEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_YSTyoQFYEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_YSuCUAFYEeaZkPiwH6BSQw" type="3010" element="_YRGRsAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSuCUQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSuCUgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSupYAFYEeaZkPiwH6BSQw" type="3010" element="_YRHf0AFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSupYQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSupYgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSupYwFYEeaZkPiwH6BSQw" type="3010" element="_YRIG4AFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSvQcAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSvQcQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSvQcgFYEeaZkPiwH6BSQw" type="3010" element="_YRIt8QFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSvQcwFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSvQdAFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSv3gAFYEeaZkPiwH6BSQw" type="3010" element="_YRJVAQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSv3gQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSv3ggFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSv3gwFYEeaZkPiwH6BSQw" type="3010" element="_YRJ8EQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSv3hAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSv3hQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSwekAFYEeaZkPiwH6BSQw" type="3010" element="_YRKjIQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSwekQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSwekgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSxFoAFYEeaZkPiwH6BSQw" type="3010" element="_YRLxQAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSxFoQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSxFogFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSxFowFYEeaZkPiwH6BSQw" type="3010" element="_YRMYUAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSxFpAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSxFpQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSxssAFYEeaZkPiwH6BSQw" type="3010" element="_YRM_YAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSxssQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSxssgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSyTwAFYEeaZkPiwH6BSQw" type="3010" element="_YRNmcAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSyTwQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSyTwgFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSyTwwFYEeaZkPiwH6BSQw" type="3010" element="_YRONgAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSyTxAFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSyTxQFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSy60AFYEeaZkPiwH6BSQw" type="3010" element="_YRO0kAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSy60QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSy60gFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSzh4AFYEeaZkPiwH6BSQw" type="3010" element="_YRPboAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSzh4QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSzh4gFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YSzh4wFYEeaZkPiwH6BSQw" type="3010" element="_YRQCsAFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YSzh5AFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YSzh5QFYEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_YS0I8AFYEeaZkPiwH6BSQw" type="3010" element="_YRQpwQFYEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_YS0I8QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_YS0I8gFYEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_YSTyogFYEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_YSTyowFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_YSTLkQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YSTLkgFYEeaZkPiwH6BSQw" x="432" y="216"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_oC5WgAFYEeaZkPiwH6BSQw" type="2003" element="_oCPPMAFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_oC7LsAFYEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_oC7ywAFYEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_oC7ywQFYEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_oC7ywgFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_oC5WgQFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" italic="true"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oC5WggFYEeaZkPiwH6BSQw" x="675" y="234"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_oC8Z0AFYEeaZkPiwH6BSQw" type="2003" element="_oCRrcAFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_oC9A4AFYEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_oC9A4QFYEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_oC9A4gFYEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_oC9A4wFYEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_oC8Z0QFYEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" italic="true"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oC8Z0gFYEeaZkPiwH6BSQw" x="675" y="369"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_FzIhkgFYEeaZkPiwH6BSQw"/>
+          <edges xmi:type="notation:Edge" xmi:id="_YTISAAFYEeaZkPiwH6BSQw" type="4001" element="_YRkLwAFYEeaZkPiwH6BSQw" source="_YSKosAFYEeaZkPiwH6BSQw" target="_YSTLkAFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_YTKuQAFYEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YTKuQQFYEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_YTLVUAFYEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YTLVUQFYEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_YTNKgAFYEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YTNKgQFYEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_YTISAQFYEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_YTISAgFYEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YTISAwFYEeaZkPiwH6BSQw" points="[57, -31, -252, -26]$[231, -31, -78, -26]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YTbM8AFYEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YTbM8QFYEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_oC-PAAFYEeaZkPiwH6BSQw" type="4001" element="_oCyo0AFYEeaZkPiwH6BSQw" source="_YSTLkAFYEeaZkPiwH6BSQw" target="_oC8Z0AFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_oC-PBAFYEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oC-PBQFYEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_oC-PBgFYEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oC-PBwFYEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_oC-PCAFYEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oC-PCQFYEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_oC-PAQFYEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_oC-PAgFYEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_oC-PAwFYEeaZkPiwH6BSQw" points="[78, 189, -146, -62]$[165, 189, -59, -62]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_oDBSUAFYEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_oDBSUQFYEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_oDB5YAFYEeaZkPiwH6BSQw" type="4001" element="_oCz28AFYEeaZkPiwH6BSQw" source="_YSTLkAFYEeaZkPiwH6BSQw" target="_oC5WgAFYEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_oDB5ZAFYEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oDB5ZQFYEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_oDB5ZgFYEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oDB5ZwFYEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_oDB5aAFYEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_oDB5aQFYEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_oDB5YQFYEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_oDB5YgFYEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_oDB5YwFYEeaZkPiwH6BSQw" points="[78, 72, -146, -44]$[165, 72, -59, -44]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_oDCgcAFYEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_oDCgcQFYEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_YPl10AFYEeaZkPiwH6BSQw" name="CxGrid" tooltipText="" outgoingEdges="_YRkLwAFYEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGrid"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGrid"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_YPuYsAFYEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQueQAFYEeaZkPiwH6BSQw" name="label : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/label"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/label"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQyIoAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQzWwAFYEeaZkPiwH6BSQw" name="labelI18nKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/labelI18nKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/labelI18nKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQzWwQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQz90AFYEeaZkPiwH6BSQw" name="selectionType : YSelectionType = " tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/selectionType"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/selectionType"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ0k4AFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ0k4QFYEeaZkPiwH6BSQw" name="selectionEventTopic : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/selectionEventTopic"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/selectionEventTopic"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ1L8AFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ1L8QFYEeaZkPiwH6BSQw" name="selection : EJavaObject" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/selection"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/selection"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ1zAAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ2aEAFYEeaZkPiwH6BSQw" name="multiSelection : EJavaObject" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/multiSelection"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/multiSelection"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ3BIAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ3BIQFYEeaZkPiwH6BSQw" name="collection : EJavaObject" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/collection"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/collection"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ3oMAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ3oMQFYEeaZkPiwH6BSQw" name="type : EJavaClass" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/type"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/type"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ42UAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ5dYAFYEeaZkPiwH6BSQw" name="emfNsURI : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/emfNsURI"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/emfNsURI"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ6EcAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ6EcQFYEeaZkPiwH6BSQw" name="typeQualifiedName : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/typeQualifiedName"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/typeQualifiedName"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ6rgAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ6rgQFYEeaZkPiwH6BSQw" name="columnReorderingAllowed : EBoolean = true" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/columnReorderingAllowed"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/columnReorderingAllowed"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ7SkAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ7SkQFYEeaZkPiwH6BSQw" name="filteringVisible : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/filteringVisible"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/filteringVisible"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ75oAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ75oQFYEeaZkPiwH6BSQw" name="customFilters : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/customFilters"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/customFilters"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ8gsAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ8gsQFYEeaZkPiwH6BSQw" name="headerVisible : EBoolean = true" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/headerVisible"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/headerVisible"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ9HwAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ9HwQFYEeaZkPiwH6BSQw" name="footerVisible : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/footerVisible"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/footerVisible"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ9u0AFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ9u0QFYEeaZkPiwH6BSQw" name="editorEnabled : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorEnabled"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorEnabled"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ-V4AFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ-V4QFYEeaZkPiwH6BSQw" name="editorCancelI18nLabelKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorCancelI18nLabelKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorCancelI18nLabelKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ-88AFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ-88QFYEeaZkPiwH6BSQw" name="editorSaveI18nLabelKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorSaveI18nLabelKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorSaveI18nLabelKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YQ_kAAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YQ_kAQFYEeaZkPiwH6BSQw" name="editorSaved : EJavaObject" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorSaved"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGrid/editorSaved"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRALEAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRAyIAFYEeaZkPiwH6BSQw" name="createEditorFieldHelperLayout() : YHelperLayout" tooltipText="createEditorFieldHelperLayout() : YHelperLayout">
+          <target xmi:type="ecore:EOperation" href="cxgrid.ecore#//CxGrid/createEditorFieldHelperLayout"/>
+          <semanticElements xmi:type="ecore:EOperation" href="cxgrid.ecore#//CxGrid/createEditorFieldHelperLayout"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRFDkAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_YP1GYAFYEeaZkPiwH6BSQw" name="CxGridColumn" tooltipText="" outgoingEdges="_oCyo0AFYEeaZkPiwH6BSQw _oCz28AFYEeaZkPiwH6BSQw" incomingEdges="_YRkLwAFYEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridColumn"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridColumn"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_YP2UgAFYEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRGRsAFYEeaZkPiwH6BSQw" name="propertyId : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyId"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyId"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRG4wAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRHf0AFYEeaZkPiwH6BSQw" name="label : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/label"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/label"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRHf0QFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRIG4AFYEeaZkPiwH6BSQw" name="labelI18nKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/labelI18nKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/labelI18nKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRIt8AFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRIt8QFYEeaZkPiwH6BSQw" name="editable : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/editable"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/editable"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRJVAAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRJVAQFYEeaZkPiwH6BSQw" name="headerCaption : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaption"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaption"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRJ8EAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRJ8EQFYEeaZkPiwH6BSQw" name="headerCaptionI18nKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaptionI18nKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaptionI18nKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRKjIAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRKjIQFYEeaZkPiwH6BSQw" name="expandRatio : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/expandRatio"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/expandRatio"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRLKMAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRLxQAFYEeaZkPiwH6BSQw" name="hidden : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hidden"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hidden"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRLxQQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRMYUAFYEeaZkPiwH6BSQw" name="hideable : EBoolean = true" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hideable"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hideable"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRMYUQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRM_YAFYEeaZkPiwH6BSQw" name="sortable : EBoolean = true" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/sortable"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/sortable"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRM_YQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRNmcAFYEeaZkPiwH6BSQw" name="propertyPath : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyPath"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyPath"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRNmcQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRONgAFYEeaZkPiwH6BSQw" name="width : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/width"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/width"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRONgQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRO0kAFYEeaZkPiwH6BSQw" name="minWidthPixels : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/minWidthPixels"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/minWidthPixels"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRO0kQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRPboAFYEeaZkPiwH6BSQw" name="maxWidthPixels : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/maxWidthPixels"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/maxWidthPixels"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRPboQFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRQCsAFYEeaZkPiwH6BSQw" name="type : EJavaClass" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/type"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/type"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRQpwAFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_YRQpwQFYEeaZkPiwH6BSQw" name="typeQualifiedName : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/typeQualifiedName"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/typeQualifiedName"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_YRRQ0AFYEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_YRkLwAFYEeaZkPiwH6BSQw" name="[0..*] columns" sourceNode="_YPl10AFYEeaZkPiwH6BSQw" targetNode="_YP1GYAFYEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGrid/columns"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGrid/columns"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_YRpEQAFYEeaZkPiwH6BSQw" description="_YRlZ4AFYEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_YRpEQQFYEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_YRpEQgFYEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_oCPPMAFYEeaZkPiwH6BSQw" name="CxGridRenderer" tooltipText="" incomingEdges="_oCz28AFYEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridRenderer"/>
+        <decorations xmi:type="viewpoint:Decoration" xmi:id="_oCwMkAFYEeaZkPiwH6BSQw">
+          <description xmi:type="description:SemanticBasedDecoration" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@decorationDescriptionsSet/@decorationDescriptions[name='External']"/>
+        </decorations>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_oCQdUAFYEeaZkPiwH6BSQw" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_abstract.gif" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">
+          <labelFormat>italic</labelFormat>
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.1/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_oCRrcAFYEeaZkPiwH6BSQw" name="YConverter" tooltipText="" incomingEdges="_oCyo0AFYEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YConverter"/>
+        <semanticElements xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YConverter"/>
+        <decorations xmi:type="viewpoint:Decoration" xmi:id="_oCwMkQFYEeaZkPiwH6BSQw">
+          <description xmi:type="description:SemanticBasedDecoration" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@decorationDescriptionsSet/@decorationDescriptions[name='External']"/>
+        </decorations>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_oCRrcQFYEeaZkPiwH6BSQw" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_interface.gif" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">
+          <labelFormat>italic</labelFormat>
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.0/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_oCyo0AFYEeaZkPiwH6BSQw" name="[0..1] converter" sourceNode="_YP1GYAFYEeaZkPiwH6BSQw" targetNode="_oCRrcAFYEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridColumn/converter"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridColumn/converter"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_oCzP4AFYEeaZkPiwH6BSQw" description="_YRlZ4AFYEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_oCzP4QFYEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_oCzP4gFYEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_oCz28AFYEeaZkPiwH6BSQw" name="[0..1] renderer" sourceNode="_YP1GYAFYEeaZkPiwH6BSQw" targetNode="_oCPPMAFYEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridColumn/renderer"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridColumn/renderer"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_oC0eAAFYEeaZkPiwH6BSQw" description="_YRlZ4AFYEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_oC0eAQFYEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_oC0eAgFYEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_FzH6hQFYEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="cxgrid.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_LA0VIAFdEeaZkPiwH6BSQw" name="renderer class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_LA0VIQFdEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_LA0VIgFdEeaZkPiwH6BSQw">
+          <computedStyleDescriptions xmi:type="style:BundledImageDescription" xmi:id="_OIxkkQFdEeaZkPiwH6BSQw" labelExpression="service:render" labelAlignment="LEFT" tooltipExpression="service:renderTooltip" sizeComputationExpression="1">
+            <borderColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            <labelFormat>bold</labelFormat>
+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            <color xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+          </computedStyleDescriptions>
+          <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_OI9x0AFdEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan">
+            <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            <centerLabelStyleDescription xmi:type="style:CenterLabelStyleDescription" xmi:id="_OI9x0QFdEeaZkPiwH6BSQw" showIcon="false" labelExpression="service:render">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            </centerLabelStyleDescription>
+            <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_OI9x0gFdEeaZkPiwH6BSQw" labelSize="6" showIcon="false" labelExpression="service:eKeysLabel">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>
+            </endLabelStyleDescription>
+          </computedStyleDescriptions>
+          <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_OI-_8QFdEeaZkPiwH6BSQw" routingStyle="manhattan">
+            <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            <centerLabelStyleDescription xmi:type="style:CenterLabelStyleDescription" xmi:id="_OI-_8gFdEeaZkPiwH6BSQw" showIcon="false" labelExpression="service:render">
+              <labelFormat>bold</labelFormat>
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            </centerLabelStyleDescription>
+            <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_OI-_8wFdEeaZkPiwH6BSQw" labelSize="6" showIcon="false" labelExpression="service:eKeysLabel">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>
+            </endLabelStyleDescription>
+          </computedStyleDescriptions>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_LA0VJgFdEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_LA08MAFdEeaZkPiwH6BSQw" type="Sirius" element="_LA0VIAFdEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_OJKmIAFdEeaZkPiwH6BSQw" type="2003" element="_OIQnMAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJLNMAFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJLNMQFdEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJLNMgFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJLNMwFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJKmIQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJKmIgFdEeaZkPiwH6BSQw" x="1269" y="161"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJLNNAFdEeaZkPiwH6BSQw" type="2003" element="_OIR1UAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJL0QAFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJL0QQFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJQsxwFdEeaZkPiwH6BSQw" type="3010" element="_OIvIUAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJQsyAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJQsyQFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJRT0AFdEeaZkPiwH6BSQw" type="3010" element="_OIvvYQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJRT0QFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJRT0gFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJRT0wFdEeaZkPiwH6BSQw" type="3010" element="_OIwWcQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJRT1AFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJRT1QFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJL0QgFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJL0QwFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJLNNQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJLNNgFdEeaZkPiwH6BSQw" x="1062" y="333"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJL0RAFdEeaZkPiwH6BSQw" type="2003" element="_OITDcAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJL0RwFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJMbUAFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJRT1gFdEeaZkPiwH6BSQw" type="3010" element="_OIw9gAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJRT1wFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJRT2AFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJMbUQFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJMbUgFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJL0RQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJL0RgFdEeaZkPiwH6BSQw" x="663" y="162"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJMbUwFdEeaZkPiwH6BSQw" type="2003" element="_OITqgQFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJMbVgFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJMbVwFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJR64AFdEeaZkPiwH6BSQw" type="3010" element="_OIxkkAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJR64QFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJR64gFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJMbWAFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJMbWQFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJMbVAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJMbVQFdEeaZkPiwH6BSQw" x="1989" y="161"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJMbWgFdEeaZkPiwH6BSQw" type="2003" element="_OIU4oAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJNCYAFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJNCYQFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJR64wFdEeaZkPiwH6BSQw" type="3010" element="_OIyLoAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJR65AFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJR65QFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJNCYgFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJNCYwFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJMbWwFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJMbXAFdEeaZkPiwH6BSQw" x="837" y="161"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJNCZAFdEeaZkPiwH6BSQw" type="2003" element="_OIVfsAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJNCZwFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJNpcAFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJR65gFdEeaZkPiwH6BSQw" type="3010" element="_OIyysAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJR65wFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJR66AFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJSh8AFdEeaZkPiwH6BSQw" type="3010" element="_OIyysgFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJSh8QFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJSh8gFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJNpcQFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJNpcgFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJNCZQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJNCZgFdEeaZkPiwH6BSQw" x="261" y="333"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJNpcwFdEeaZkPiwH6BSQw" type="2003" element="_OIWGwAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJNpdgFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJNpdwFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJSh8wFdEeaZkPiwH6BSQw" type="3010" element="_OI0A0AFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJSh9AFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJSh9QFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJSh9gFdEeaZkPiwH6BSQw" type="3010" element="_OI0n4QFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJSh9wFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJSh-AFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJNpeAFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJNpeQFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJNpdAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJNpdQFdEeaZkPiwH6BSQw" x="458" y="161"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJOQgAFdEeaZkPiwH6BSQw" type="2003" element="_OIWt0AFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJOQgwFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJOQhAFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJTJAAFdEeaZkPiwH6BSQw" type="3010" element="_OI1O8AFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJTJAQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJTJAgFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJTJAwFdEeaZkPiwH6BSQw" type="3010" element="_OI12AAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJTJBAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJTJBQFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJOQhQFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJOQhgFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJOQgQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJOQggFdEeaZkPiwH6BSQw" x="198" y="161"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJOQhwFdEeaZkPiwH6BSQw" type="2003" element="_OIXU4QFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJO3kAFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJO3kQFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJTJBgFdEeaZkPiwH6BSQw" type="3010" element="_OI12AgFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJTJBwFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJTJCAFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJTJCQFdEeaZkPiwH6BSQw" type="3010" element="_OI2dEQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJTJCgFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJTJCwFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJTwEAFdEeaZkPiwH6BSQw" type="3010" element="_OI3EIQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJTwEQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJTwEgFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJTwEwFdEeaZkPiwH6BSQw" type="3010" element="_OI3rMAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJTwFAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJTwFQFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJTwFgFdEeaZkPiwH6BSQw" type="3010" element="_OI3rMgFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJTwFwFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJTwGAFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJO3kgFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJO3kwFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJOQiAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJOQiQFdEeaZkPiwH6BSQw" x="1647" y="162"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJO3lAFdEeaZkPiwH6BSQw" type="2003" element="_OIX78QFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJO3lwFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJO3mAFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJUXIAFdEeaZkPiwH6BSQw" type="3010" element="_OI4SQQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJUXIQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJUXIgFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJO3mQFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJO3mgFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJO3lQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJO3lgFdEeaZkPiwH6BSQw" y="161"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJPeoAFdEeaZkPiwH6BSQw" type="2003" element="_OIZKEAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJPeowFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJPepAFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJUXIwFdEeaZkPiwH6BSQw" type="3010" element="_OI45UQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJUXJAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJUXJQFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJUXJgFdEeaZkPiwH6BSQw" type="3010" element="_OI5gYQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJUXJwFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJUXKAFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJUXKQFdEeaZkPiwH6BSQw" type="3010" element="_OI6HcAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJUXKgFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJUXKwFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJU-MAFdEeaZkPiwH6BSQw" type="3010" element="_OI6HcgFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJU-MQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJU-MgFdEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_OJU-MwFdEeaZkPiwH6BSQw" type="3010" element="_OI6ugQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJU-NAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" bold="true"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJU-NQFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJPepQFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJPepgFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJPeoQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJPeogFdEeaZkPiwH6BSQw" x="2169" y="162"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJPepwFdEeaZkPiwH6BSQw" type="2003" element="_OIZxIQFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJQFsAFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJQFsQFdEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJQFsgFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJQFswFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJPeqAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" italic="true"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJPeqQFdEeaZkPiwH6BSQw" x="1053"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJQFtAFdEeaZkPiwH6BSQw" type="2003" element="_OIaYMQFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJQFtwFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJQFuAFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJU-NgFdEeaZkPiwH6BSQw" type="3010" element="_OI7VkQFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJU-NwFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJU-OAFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJQFuQFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJQFugFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJQFtQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJQFtgFdEeaZkPiwH6BSQw" x="1044" y="161"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_OJQswAFdEeaZkPiwH6BSQw" type="2003" element="_OIbmUAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJQswwFdEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_OJQsxAFdEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_OJVlQAFdEeaZkPiwH6BSQw" type="3010" element="_OI78oAFdEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_OJVlQQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_OJVlQgFdEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_OJQsxQFdEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_OJQsxgFdEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_OJQswQFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJQswgFdEeaZkPiwH6BSQw" x="1449" y="161"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_LA08MQFdEeaZkPiwH6BSQw"/>
+          <edges xmi:type="notation:Edge" xmi:id="_OJVlQwFdEeaZkPiwH6BSQw" type="4001" element="_OI9KwAFdEeaZkPiwH6BSQw" source="_OJLNNAFdEeaZkPiwH6BSQw" target="_OJQFtAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJWMUAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJWMUQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJWMUgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJWMUwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJWMVAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJWMVQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJVlRAFdEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJVlRQFdEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJVlRgFdEeaZkPiwH6BSQw" points="[0, 0, 111, 60]$[-111, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJWMVgFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJWMVwFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJWzYAFdEeaZkPiwH6BSQw" type="4001" element="_OI-Y4AFdEeaZkPiwH6BSQw" source="_OJNCZAFdEeaZkPiwH6BSQw" target="_OJQFtAFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJWzZAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJWzZQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJWzZgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJWzZwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJWzaAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJWzaQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJWzYQFdEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJWzYgFdEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJWzYwFdEeaZkPiwH6BSQw" points="[0, 0, -696, 60]$[696, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJWzagFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJWzawFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJXacAFdEeaZkPiwH6BSQw" type="4001" element="_OI-_8AFdEeaZkPiwH6BSQw" source="_OJQFtAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJXadAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJXadQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJXadgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJXadwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJXaeAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJXaeQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJXacQFdEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJXacgFdEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJXacwFdEeaZkPiwH6BSQw" points="[0, 0, 0, 60]$[0, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJXaegFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJXaewFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJYBgAFdEeaZkPiwH6BSQw" type="4001" element="_OI_nAAFdEeaZkPiwH6BSQw" source="_OJKmIAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJYBhAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJYBhQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJYBhgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJYBhwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJYBiAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJYBiQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJYBgQFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJYBggFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJYBgwFdEeaZkPiwH6BSQw" points="[0, 0, 217, 60]$[-217, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJYBigFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJYBiwFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJYBjAFdEeaZkPiwH6BSQw" type="4001" element="_OJAOEwFdEeaZkPiwH6BSQw" source="_OJLNNAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJYokAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJYokQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJYokgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJYokwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJYolAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJYolQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJYBjQFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJYBjgFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJYBjwFdEeaZkPiwH6BSQw" points="[0, 0, 111, 231]$[-1, -171, 110, 60]$[-111, -231, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJYolgFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJYolwFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJYomAFdEeaZkPiwH6BSQw" type="4001" element="_OJA1IAFdEeaZkPiwH6BSQw" source="_OJL0RAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJZPoAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJZPoQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJZPogFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJZPowFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJZPpAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJZPpQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJYomQFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJYomgFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJYomwFdEeaZkPiwH6BSQw" points="[0, 0, -388, 60]$[388, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJZPpgFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJZPpwFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJZPqAFdEeaZkPiwH6BSQw" type="4001" element="_OJBcMAFdEeaZkPiwH6BSQw" source="_OJMbUwFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJZ2sAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJZ2sQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJZ2sgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJZ2swFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJZ2tAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJZ2tQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJZPqQFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJZPqgFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJZPqwFdEeaZkPiwH6BSQw" points="[0, 0, 940, 60]$[-940, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJZ2tgFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJZ2twFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJZ2uAFdEeaZkPiwH6BSQw" type="4001" element="_OJCDQAFdEeaZkPiwH6BSQw" source="_OJMbWgFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJadwAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJadwQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJadwgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJadwwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJadxAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJadxQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJZ2uQFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJZ2ugFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJZ2uwFdEeaZkPiwH6BSQw" points="[0, 0, -197, 60]$[197, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJadxgFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJadxwFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJadyAFdEeaZkPiwH6BSQw" type="4001" element="_OJCqUwFdEeaZkPiwH6BSQw" source="_OJNCZAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJbE0AFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJbE0QFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJbE0gFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJbE0wFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJbE1AFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJbE1QFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJadyQFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJadygFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJadywFdEeaZkPiwH6BSQw" points="[0, 0, -696, 231]$[1, -171, -695, 60]$[696, -231, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJbE1gFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJbE1wFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJbE2AFdEeaZkPiwH6BSQw" type="4001" element="_OJDRYwFdEeaZkPiwH6BSQw" source="_OJNpcwFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJbr4AFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJbr4QFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJbr4gFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJbr4wFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJbr5AFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJbr5QFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJbE2QFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJbE2gFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJbE2wFdEeaZkPiwH6BSQw" points="[0, 0, -579, 60]$[579, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJbr5gFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJbr5wFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJbr6AFdEeaZkPiwH6BSQw" type="4001" element="_OJFGkAFdEeaZkPiwH6BSQw" source="_OJOQgAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJcS8AFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJcS8QFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJcS8gFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJcS8wFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJcS9AFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJcS9QFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJbr6QFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJbr6gFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJbr6wFdEeaZkPiwH6BSQw" points="[0, 0, -828, 60]$[828, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJcS9gFdEeaZkPiwH6BSQw" id="(0.4971098265895953,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJcS9wFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJcS-AFdEeaZkPiwH6BSQw" type="4001" element="_OJFGlAFdEeaZkPiwH6BSQw" source="_OJOQhwFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJc6AAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJc6AQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJc6AgFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJc6AwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJc6BAFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJc6BQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJcS-QFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJcS-gFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJcS-wFdEeaZkPiwH6BSQw" points="[0, 0, 679, 60]$[-679, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJc6BgFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJc6BwFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJc6CAFdEeaZkPiwH6BSQw" type="4001" element="_OJFtowFdEeaZkPiwH6BSQw" source="_OJO3lAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJc6DAFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJc6DQFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJdhEAFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJdhEQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJdhEgFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJdhEwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJc6CQFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJc6CgFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJc6CwFdEeaZkPiwH6BSQw" points="[0, 0, -1042, 60]$[1042, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJdhFAFdEeaZkPiwH6BSQw" id="(0.49629629629629635,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJdhFQFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJdhFgFdEeaZkPiwH6BSQw" type="4001" element="_OJGUswFdEeaZkPiwH6BSQw" source="_OJPeoAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJdhGgFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJdhGwFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJeIIAFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJeIIQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJeIIgFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJeIIwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJdhFwFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJdhGAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJdhGQFdEeaZkPiwH6BSQw" points="[0, 0, 1201, 60]$[-1201, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJeIJAFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJeIJQFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_OJeIJgFdEeaZkPiwH6BSQw" type="4001" element="_OJG7wwFdEeaZkPiwH6BSQw" source="_OJQswAFdEeaZkPiwH6BSQw" target="_OJPepwFdEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_OJeIKgFdEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJeIKwFdEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJevMAFdEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJevMQFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_OJevMgFdEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_OJevMwFdEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_OJeIJwFdEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_OJeIKAFdEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_OJeIKQFdEeaZkPiwH6BSQw" points="[0, 0, 408, 60]$[-408, -60, 0, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJevNAFdEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_OJevNQFdEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIQnMAFdEeaZkPiwH6BSQw" name="CxGridBooleanRenderer" tooltipText="" outgoingEdges="_OI_nAAFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridBooleanRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridBooleanRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIROQAFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIR1UAFdEeaZkPiwH6BSQw" name="CxGridButtonRenderer" tooltipText="" outgoingEdges="_OI9KwAFdEeaZkPiwH6BSQw _OJAOEwFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridButtonRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridButtonRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIScYAFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIvIUAFdEeaZkPiwH6BSQw" name="nullRepresentation : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/nullRepresentation"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/nullRepresentation"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIvvYAFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIvvYQFdEeaZkPiwH6BSQw" name="eventTopic : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/eventTopic"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/eventTopic"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIwWcAFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIwWcQFdEeaZkPiwH6BSQw" name="createLastClickEventEndpoint() : YECViewModelValueBindingEndpoint" tooltipText="createLastClickEventEndpoint() : YECViewModelValueBindingEndpoint">
+          <target xmi:type="ecore:EOperation" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/createLastClickEventEndpoint"/>
+          <semanticElements xmi:type="ecore:EOperation" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/createLastClickEventEndpoint"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIwWcgFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OITDcAFdEeaZkPiwH6BSQw" name="CxGridDateRenderer" tooltipText="" outgoingEdges="_OJA1IAFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridDateRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridDateRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OITqgAFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIw9gAFdEeaZkPiwH6BSQw" name="dateFormat : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridDateRenderer/dateFormat"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridDateRenderer/dateFormat"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIw9gQFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OITqgQFdEeaZkPiwH6BSQw" name="CxGridDelegateRenderer" tooltipText="" outgoingEdges="_OJBcMAFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridDelegateRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridDelegateRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIURkAFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIxkkAFdEeaZkPiwH6BSQw" name="delegateId : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridDelegateRenderer/delegateId"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridDelegateRenderer/delegateId"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIxkkgFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIU4oAFdEeaZkPiwH6BSQw" name="CxGridHtmlRenderer" tooltipText="" outgoingEdges="_OJCDQAFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridHtmlRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridHtmlRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIU4oQFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIyLoAFdEeaZkPiwH6BSQw" name="nullRepresentation : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridHtmlRenderer/nullRepresentation"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridHtmlRenderer/nullRepresentation"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIyLoQFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIVfsAFdEeaZkPiwH6BSQw" name="CxGridImageRenderer" tooltipText="" outgoingEdges="_OI-Y4AFdEeaZkPiwH6BSQw _OJCqUwFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridImageRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridImageRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIVfsQFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIyysAFdEeaZkPiwH6BSQw" name="eventTopic : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridImageRenderer/eventTopic"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridImageRenderer/eventTopic"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIyysQFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OIyysgFdEeaZkPiwH6BSQw" name="createLastClickEventEndpoint() : YECViewModelValueBindingEndpoint" tooltipText="createLastClickEventEndpoint() : YECViewModelValueBindingEndpoint">
+          <target xmi:type="ecore:EOperation" href="cxgrid.ecore#//renderer/CxGridImageRenderer/createLastClickEventEndpoint"/>
+          <semanticElements xmi:type="ecore:EOperation" href="cxgrid.ecore#//renderer/CxGridImageRenderer/createLastClickEventEndpoint"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OIzZwAFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIWGwAFdEeaZkPiwH6BSQw" name="CxGridIndicatorRenderer" tooltipText="" outgoingEdges="_OJDRYwFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIWGwQFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI0A0AFdEeaZkPiwH6BSQw" name="redEnds : EDouble = 0.0" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer/redEnds"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer/redEnds"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI0n4AFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI0n4QFdEeaZkPiwH6BSQw" name="greenStarts : EDouble = 0.0" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer/greenStarts"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer/greenStarts"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI0n4gFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIWt0AFdEeaZkPiwH6BSQw" name="CxGridNumberRenderer" tooltipText="" outgoingEdges="_OJFGkAFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridNumberRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridNumberRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIXU4AFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI1O8AFdEeaZkPiwH6BSQw" name="numberFormat : EString = #,##0.00" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridNumberRenderer/numberFormat"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridNumberRenderer/numberFormat"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI1O8QFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI12AAFdEeaZkPiwH6BSQw" name="nullRepresentation : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridNumberRenderer/nullRepresentation"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridNumberRenderer/nullRepresentation"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI12AQFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIXU4QFdEeaZkPiwH6BSQw" name="CxGridPriceRenderer" tooltipText="" outgoingEdges="_OJFGlAFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridPriceRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridPriceRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIX78AFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI12AgFdEeaZkPiwH6BSQw" name="valuePropertyPath : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/valuePropertyPath"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/valuePropertyPath"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI2dEAFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI2dEQFdEeaZkPiwH6BSQw" name="currencyPropertyPath : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/currencyPropertyPath"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/currencyPropertyPath"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI3EIAFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI3EIQFdEeaZkPiwH6BSQw" name="nullRepresentation : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/nullRepresentation"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/nullRepresentation"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI3EIgFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI3rMAFdEeaZkPiwH6BSQw" name="htmlPattern : EString = &lt;b>{@value}&lt;/b> &lt;i>{@currency}&lt;/i>" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/htmlPattern"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/htmlPattern"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI3rMQFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI3rMgFdEeaZkPiwH6BSQw" name="numberFormat : EString = #,##0.00" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/numberFormat"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/numberFormat"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI4SQAFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIX78QFdEeaZkPiwH6BSQw" name="CxGridProgressBarRenderer" tooltipText="" outgoingEdges="_OJFtowFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridProgressBarRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridProgressBarRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIYjAAFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI4SQQFdEeaZkPiwH6BSQw" name="maxValue : EDouble = 1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridProgressBarRenderer/maxValue"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridProgressBarRenderer/maxValue"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI45UAFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIZKEAFdEeaZkPiwH6BSQw" name="CxGridQuantityRenderer" tooltipText="" outgoingEdges="_OJGUswFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIZxIAFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI45UQFdEeaZkPiwH6BSQw" name="valuePropertyPath : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/valuePropertyPath"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/valuePropertyPath"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI5gYAFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI5gYQFdEeaZkPiwH6BSQw" name="uomPropertyPath : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/uomPropertyPath"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/uomPropertyPath"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI5gYgFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI6HcAFdEeaZkPiwH6BSQw" name="nullRepresentation : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/nullRepresentation"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/nullRepresentation"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI6HcQFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI6HcgFdEeaZkPiwH6BSQw" name="htmlPattern : EString = &lt;b>{@value}&lt;/b> &lt;i>{@currency}&lt;/i>" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/htmlPattern"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/htmlPattern"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI6ugAFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI6ugQFdEeaZkPiwH6BSQw" name="numberFormat : EString = #,##0.00" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/numberFormat"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/numberFormat"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI7VkAFdEeaZkPiwH6BSQw" labelAlignment="LEFT" description="_OIxkkQFdEeaZkPiwH6BSQw">
+            <labelFormat>bold</labelFormat>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIZxIQFdEeaZkPiwH6BSQw" name="CxGridRenderer" tooltipText="" incomingEdges="_OI-_8AFdEeaZkPiwH6BSQw _OI_nAAFdEeaZkPiwH6BSQw _OJAOEwFdEeaZkPiwH6BSQw _OJA1IAFdEeaZkPiwH6BSQw _OJBcMAFdEeaZkPiwH6BSQw _OJCDQAFdEeaZkPiwH6BSQw _OJCqUwFdEeaZkPiwH6BSQw _OJDRYwFdEeaZkPiwH6BSQw _OJFGkAFdEeaZkPiwH6BSQw _OJFGlAFdEeaZkPiwH6BSQw _OJFtowFdEeaZkPiwH6BSQw _OJGUswFdEeaZkPiwH6BSQw _OJG7wwFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIaYMAFdEeaZkPiwH6BSQw" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_abstract.gif" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">
+          <labelFormat>italic</labelFormat>
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.1/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIaYMQFdEeaZkPiwH6BSQw" name="CxGridRendererClickEvent" tooltipText="" outgoingEdges="_OI-_8AFdEeaZkPiwH6BSQw" incomingEdges="_OI9KwAFdEeaZkPiwH6BSQw _OI-Y4AFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridRendererClickEvent"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridRendererClickEvent"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIa_QAFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI7VkQFdEeaZkPiwH6BSQw" name="lastClickTime : ELong = 0" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridRendererClickEvent/lastClickTime"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridRendererClickEvent/lastClickTime"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI7VkgFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_OIbmUAFdEeaZkPiwH6BSQw" name="CxGridTextRenderer" tooltipText="" outgoingEdges="_OJG7wwFdEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridTextRenderer"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridTextRenderer"/>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_OIbmUQFdEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_OI78oAFdEeaZkPiwH6BSQw" name="nullRepresentation : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridTextRenderer/nullRepresentation"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//renderer/CxGridTextRenderer/nullRepresentation"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_OI78oQFdEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OI9KwAFdEeaZkPiwH6BSQw" name="[0..1] lastClickEvent" sourceNode="_OIR1UAFdEeaZkPiwH6BSQw" targetNode="_OIaYMQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/lastClickEvent"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/lastClickEvent"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OI9x0wFdEeaZkPiwH6BSQw" description="_OI9x0AFdEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OI9x1AFdEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_OI9x1QFdEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OI-Y4AFdEeaZkPiwH6BSQw" name="[0..1] lastClickEvent" sourceNode="_OIVfsAFdEeaZkPiwH6BSQw" targetNode="_OIaYMQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//renderer/CxGridImageRenderer/lastClickEvent"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//renderer/CxGridImageRenderer/lastClickEvent"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OI-Y4QFdEeaZkPiwH6BSQw" description="_OI9x0AFdEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OI-Y4gFdEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_OI-Y4wFdEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OI-_8AFdEeaZkPiwH6BSQw" name="[1..1] renderer" sourceNode="_OIaYMQFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//renderer/CxGridRendererClickEvent/renderer"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//renderer/CxGridRendererClickEvent/renderer"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OI-_9AFdEeaZkPiwH6BSQw" description="_OI-_8QFdEeaZkPiwH6BSQw" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OI-_9QFdEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+            <labelFormat>bold</labelFormat>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_OI-_9gFdEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OI_nAAFdEeaZkPiwH6BSQw" sourceNode="_OIQnMAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridBooleanRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridBooleanRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJAOEAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJAOEQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJAOEgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJAOEwFdEeaZkPiwH6BSQw" sourceNode="_OIR1UAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridButtonRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridButtonRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJAOFAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJAOFQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJAOFgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJA1IAFdEeaZkPiwH6BSQw" sourceNode="_OITDcAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridDateRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridDateRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJA1IQFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJA1IgFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJA1IwFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJBcMAFdEeaZkPiwH6BSQw" sourceNode="_OITqgQFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridDelegateRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridDelegateRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJBcMQFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJBcMgFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJBcMwFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJCDQAFdEeaZkPiwH6BSQw" sourceNode="_OIU4oAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridHtmlRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridHtmlRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJCqUAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJCqUQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJCqUgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJCqUwFdEeaZkPiwH6BSQw" sourceNode="_OIVfsAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridImageRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridImageRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJDRYAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJDRYQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJDRYgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJDRYwFdEeaZkPiwH6BSQw" sourceNode="_OIWGwAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridIndicatorRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJD4cAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJD4cQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJD4cgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJFGkAFdEeaZkPiwH6BSQw" sourceNode="_OIWt0AFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridNumberRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridNumberRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJFGkQFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJFGkgFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJFGkwFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJFGlAFdEeaZkPiwH6BSQw" sourceNode="_OIXU4QFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridPriceRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridPriceRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJFtoAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJFtoQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJFtogFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJFtowFdEeaZkPiwH6BSQw" sourceNode="_OIX78QFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridProgressBarRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridProgressBarRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJGUsAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJGUsQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJGUsgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJGUswFdEeaZkPiwH6BSQw" sourceNode="_OIZKEAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridQuantityRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJG7wAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJG7wQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJG7wgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_OJG7wwFdEeaZkPiwH6BSQw" sourceNode="_OIbmUAFdEeaZkPiwH6BSQw" targetNode="_OIZxIQFdEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//renderer/CxGridTextRenderer"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//renderer/CxGridTextRenderer/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_OJG7xAFdEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_OJG7xQFdEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_OJG7xgFdEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_LA0VJQFdEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="cxgrid.ecore#//renderer"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_JXPdUAFfEeaZkPiwH6BSQw" name="grid header and footer diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_JXPdUQFfEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_JXPdUgFfEeaZkPiwH6BSQw">
+          <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_M4Z28AFfEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan">
+            <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            <centerLabelStyleDescription xmi:type="style:CenterLabelStyleDescription" xmi:id="_M4Z28QFfEeaZkPiwH6BSQw" showIcon="false" labelExpression="service:render">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            </centerLabelStyleDescription>
+            <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_M4Z28gFfEeaZkPiwH6BSQw" labelSize="6" showIcon="false" labelExpression="service:eKeysLabel">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>
+            </endLabelStyleDescription>
+          </computedStyleDescriptions>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_JXPdVgFfEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_JXPdVwFfEeaZkPiwH6BSQw" type="Sirius" element="_JXPdUAFfEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_qNWXsAFfEeaZkPiwH6BSQw" type="2003" element="_qNBnkAFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_qNW-wAFfEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_qNW-wQFfEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_qNW-wgFfEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_qNW-wwFfEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_qNWXsQFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" italic="true"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qNWXsgFfEeaZkPiwH6BSQw" x="162" y="315"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_svAcIAFfEeaZkPiwH6BSQw" type="2003" element="_suuIQAFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_svAcIwFfEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_svAcJAFfEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_svBDNAFfEeaZkPiwH6BSQw" type="3010" element="_su5HYAFfEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_svBDNQFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_svBDNgFfEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_svBqQAFfEeaZkPiwH6BSQw" type="3010" element="_su5HYgFfEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_svBqQQFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_svBqQgFfEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_svBqQwFfEeaZkPiwH6BSQw" type="3010" element="_su5ucAFfEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_svBqRAFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_svBqRQFfEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_svAcJQFfEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_svAcJgFfEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_svAcIQFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svAcIgFfEeaZkPiwH6BSQw" x="378" y="225"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_svAcJwFfEeaZkPiwH6BSQw" type="2003" element="_suvWYAFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_svBDMAFfEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_svBDMQFfEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_svBqRgFfEeaZkPiwH6BSQw" type="3010" element="_su5ucgFfEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_svBqRwFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_svBqSAFfEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_svCRUAFfEeaZkPiwH6BSQw" type="3010" element="_su6VgQFfEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_svCRUQFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_svCRUgFfEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_svCRUwFfEeaZkPiwH6BSQw" type="3010" element="_su6VgwFfEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_svCRVAFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_svCRVQFfEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_svBDMgFfEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_svBDMwFfEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_svAcKAFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svAcKQFfEeaZkPiwH6BSQw" x="387" y="423"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_8IZA8AFfEeaZkPiwH6BSQw" type="2003" element="_8IOo4AFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_8IZA8wFfEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_8IZA9AFfEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_8IZA9QFfEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_8IZA9gFfEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_8IZA8QFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" italic="true"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8IZA8gFfEeaZkPiwH6BSQw" x="387" y="90"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_E2QI8AFgEeaZkPiwH6BSQw" type="2003" element="_E1_qQAFgEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_E2QwAAFgEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_E2QwAQFgEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_E2QwBAFgEeaZkPiwH6BSQw" type="3010" element="_E2GX8AFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2QwBQFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2QwBgFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2RXEAFgEeaZkPiwH6BSQw" type="3010" element="_E2GX8gFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2RXEQFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2RXEgFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2RXEwFgEeaZkPiwH6BSQw" type="3010" element="_E2G_AQFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2RXFAFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2RXFQFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2RXFgFgEeaZkPiwH6BSQw" type="3010" element="_E2G_AwFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2RXFwFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2RXGAFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2RXGQFgEeaZkPiwH6BSQw" type="3010" element="_E2HmEQFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2RXGgFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2RXGwFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2R-IAFgEeaZkPiwH6BSQw" type="3010" element="_E2HmEwFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2R-IQFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2R-IgFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2R-IwFgEeaZkPiwH6BSQw" type="3010" element="_E2INIQFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2R-JAFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2R-JQFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2R-JgFgEeaZkPiwH6BSQw" type="3010" element="_E2INIwFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2R-JwFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2R-KAFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2R-KQFgEeaZkPiwH6BSQw" type="3010" element="_E2I0MQFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2R-KgFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2R-KwFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2SlMAFgEeaZkPiwH6BSQw" type="3010" element="_E2I0MwFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2SlMQFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2SlMgFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2SlMwFgEeaZkPiwH6BSQw" type="3010" element="_E2JbQQFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2SlNAFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2SlNQFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2SlNgFgEeaZkPiwH6BSQw" type="3010" element="_E2JbQwFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2SlNwFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2SlOAFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2SlOQFgEeaZkPiwH6BSQw" type="3010" element="_E2KCUQFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2SlOgFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2SlOwFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2TMQAFgEeaZkPiwH6BSQw" type="3010" element="_E2KCUwFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2TMQQFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2TMQgFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2TMQwFgEeaZkPiwH6BSQw" type="3010" element="_E2KpYQFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2TMRAFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2TMRQFgEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_E2TMRgFgEeaZkPiwH6BSQw" type="3010" element="_E2KpYwFgEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_E2TMRwFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_E2TMSAFgEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_E2QwAgFgEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_E2QwAwFgEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_E2QI8QFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_E2QI8gFgEeaZkPiwH6BSQw" x="720" y="279"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_GQ3QUAFhEeaZkPiwH6BSQw" type="2003" element="_GQfc4AFhEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_GQ33YAFhEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_GQ33YQFhEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_GQ33ZAFhEeaZkPiwH6BSQw" visible="false" type="3010" element="_GQs4QAFhEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_GQ33ZQFhEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_GQ33ZgFhEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_GQ4ecAFhEeaZkPiwH6BSQw" visible="false" type="3010" element="_GQtfUAFhEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_GQ4ecQFhEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_GQ4ecgFhEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_GQ4ecwFhEeaZkPiwH6BSQw" visible="false" type="3010" element="_GQtfUgFhEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_GQ4edAFhEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_GQ4edQFhEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_GQ5FgAFhEeaZkPiwH6BSQw" visible="false" type="3010" element="_GQuGYQFhEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_GQ5FgQFhEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_GQ5FggFhEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_GQ33YgFhEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_GQ33YwFhEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_GQ3QUQFhEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" italic="true"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GQ3QUgFhEeaZkPiwH6BSQw" x="144" y="504"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_JXPdWAFfEeaZkPiwH6BSQw"/>
+          <edges xmi:type="notation:Edge" xmi:id="_svCRVgFfEeaZkPiwH6BSQw" type="4001" element="_su8KsAFfEeaZkPiwH6BSQw" source="_qNWXsAFfEeaZkPiwH6BSQw" target="_svAcIAFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_svC4YgFfEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svC4YwFfEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_svC4ZAFfEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svC4ZQFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_svC4ZgFfEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svC4ZwFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_svCRVwFfEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_svC4YAFfEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_svC4YQFfEeaZkPiwH6BSQw" points="[59, 48, -168, 40]$[112, 48, -115, 40]$[112, -54, -115, -62]$[157, -54, -70, -62]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_svC4aAFfEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_svC4aQFfEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_svDfcAFfEeaZkPiwH6BSQw" type="4001" element="_su8xwwFfEeaZkPiwH6BSQw" source="_qNWXsAFfEeaZkPiwH6BSQw" target="_svAcJwFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_svDfdAFfEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svDfdQFfEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_svDfdgFfEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svDfdwFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_svDfeAFfEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_svDfeQFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_svDfcQFfEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_svDfcgFfEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_svDfcwFfEeaZkPiwH6BSQw" points="[59, 63, -177, -143]$[112, 63, -124, -143]$[112, 158, -124, -48]$[166, 158, -70, -48]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_svDfegFfEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_svDfewFfEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_8IZoAAFfEeaZkPiwH6BSQw" type="4001" element="_8IXLwAFfEeaZkPiwH6BSQw" source="_svAcIAFfEeaZkPiwH6BSQw" target="_8IZA8AFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_8IZoBAFfEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8IZoBQFfEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_8IZoBgFfEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8IZoBwFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_8IaPEAFfEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8IaPEQFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_8IZoAQFfEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_8IZoAgFfEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_8IZoAwFfEeaZkPiwH6BSQw" points="[70, 5, 72, 140]$[110, 5, 112, 140]$[110, -134, 112, 1]$[57, -134, 59, 1]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_8IaPEgFfEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_8IaPEwFfEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_8IaPFAFfEeaZkPiwH6BSQw" type="4001" element="_8IXy0AFfEeaZkPiwH6BSQw" source="_svAcIAFfEeaZkPiwH6BSQw" target="_8IZA8AFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_8IaPGAFfEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8IaPGQFfEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_8IaPGgFfEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8Ia2IAFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_8Ia2IQFfEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_8Ia2IgFfEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_8IaPFQFfEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_8IaPFgFfEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_8IaPFwFfEeaZkPiwH6BSQw" points="[0, -49, 2, 86]$[0, -67, 2, 68]$[-1, -67, 1, 68]$[-1, -86, 1, 49]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_8Ia2IwFfEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_8Ia2JAFfEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_E2TzUAFgEeaZkPiwH6BSQw" type="4001" element="_E2NFoAFgEeaZkPiwH6BSQw" source="_E2QI8AFgEeaZkPiwH6BSQw" target="_8IZA8AFfEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_E2TzVAFgEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_E2TzVQFgEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_E2UaYAFgEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_E2UaYQFgEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_E2UaYgFgEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_E2UaYwFgEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_E2TzUQFgEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_E2TzUgFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_E2TzUwFgEeaZkPiwH6BSQw" points="[0, -142, 352, 140]$[0, -214, 352, 68]$[-351, -214, 1, 68]$[-351, -233, 1, 49]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_E2UaZAFgEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_E2UaZQFgEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_E2UaZgFgEeaZkPiwH6BSQw" type="4001" element="_E2OTwAFgEeaZkPiwH6BSQw" source="_svAcJwFfEeaZkPiwH6BSQw" target="_E2QI8AFgEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_E2UaagFgEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_E2UaawFgEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_E2VBcAFgEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_E2VBcQFgEeaZkPiwH6BSQw" x="37" y="9"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_E2VBcgFgEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_E2VBcwFgEeaZkPiwH6BSQw" x="-19" y="9"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_E2UaZwFgEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_E2UaaAFgEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_E2UaaQFgEeaZkPiwH6BSQw" points="[70, -4, -271, 47]$[263, -4, -78, 47]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_E2VBdAFgEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_E2VBdQFgEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_GQ5skAFhEeaZkPiwH6BSQw" type="4001" element="_GQwioAFhEeaZkPiwH6BSQw" source="_svAcJwFfEeaZkPiwH6BSQw" target="_GQ3QUAFhEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_GQ5slAFhEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GQ5slQFhEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_GQ5slgFhEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GQ5slwFhEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_GQ5smAFhEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_GQ5smQFhEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_GQ5skQFhEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_GQ5skgFhEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_GQ5skwFhEeaZkPiwH6BSQw" points="[-29, 49, 225, -32]$[-29, 91, 225, 10]$[-230, 91, 24, 10]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_GQ6ToAFhEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_GQ6ToQFhEeaZkPiwH6BSQw" id="(0.5,0.5)"/>
+          </edges>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_qNBnkAFfEeaZkPiwH6BSQw" name="CxGridMetaRow" tooltipText="" outgoingEdges="_su8KsAFfEeaZkPiwH6BSQw _su8xwwFfEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridMetaRow"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridMetaRow"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_qNCOoAFfEeaZkPiwH6BSQw" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_interface.gif" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">
+          <labelFormat>italic</labelFormat>
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.0/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_suuIQAFfEeaZkPiwH6BSQw" name="CxGridGroupedCell" tooltipText="" outgoingEdges="_8IXLwAFfEeaZkPiwH6BSQw _8IXy0AFfEeaZkPiwH6BSQw" incomingEdges="_su8KsAFfEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridGroupedCell"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridGroupedCell"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_suuvUAFfEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_su5HYAFfEeaZkPiwH6BSQw" name="label : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridGroupedCell/label"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridGroupedCell/label"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_su5HYQFfEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_su5HYgFfEeaZkPiwH6BSQw" name="labelI18nKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridGroupedCell/labelI18nKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridGroupedCell/labelI18nKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_su5HYwFfEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_su5ucAFfEeaZkPiwH6BSQw" name="useHTML : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridGroupedCell/useHTML"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridGroupedCell/useHTML"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_su5ucQFfEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_suvWYAFfEeaZkPiwH6BSQw" name="CxGridMetaCell" tooltipText="" outgoingEdges="_E2OTwAFgEeaZkPiwH6BSQw _GQwioAFhEeaZkPiwH6BSQw" incomingEdges="_su8xwwFfEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridMetaCell"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridMetaCell"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_suvWYQFfEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_su5ucgFfEeaZkPiwH6BSQw" name="label : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridMetaCell/label"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridMetaCell/label"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_su6VgAFfEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_su6VgQFfEeaZkPiwH6BSQw" name="labelI18nKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridMetaCell/labelI18nKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridMetaCell/labelI18nKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_su6VggFfEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_su6VgwFfEeaZkPiwH6BSQw" name="useHTML : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridMetaCell/useHTML"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridMetaCell/useHTML"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_su6VhAFfEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_su8KsAFfEeaZkPiwH6BSQw" name="[0..*] groupings" sourceNode="_qNBnkAFfEeaZkPiwH6BSQw" targetNode="_suuIQAFfEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaRow/groupings"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaRow/groupings"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_su8xwAFfEeaZkPiwH6BSQw" description="_M4Z28AFfEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_su8xwQFfEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_su8xwgFfEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_su8xwwFfEeaZkPiwH6BSQw" name="[0..*] customCells" sourceNode="_qNBnkAFfEeaZkPiwH6BSQw" targetNode="_suvWYAFfEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaRow/customCells"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaRow/customCells"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_su9Y0AFfEeaZkPiwH6BSQw" description="_M4Z28AFfEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_su9Y0QFfEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_su9Y0gFfEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_8IOo4AFfEeaZkPiwH6BSQw" name="CxGridGroupable" tooltipText="" incomingEdges="_8IXLwAFfEeaZkPiwH6BSQw _8IXy0AFfEeaZkPiwH6BSQw _E2NFoAFgEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridGroupable"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridGroupable"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_8IPP8AFfEeaZkPiwH6BSQw" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_abstract.gif" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">
+          <labelFormat>italic</labelFormat>
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.1/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_8IXLwAFfEeaZkPiwH6BSQw" name="[0..*] groupables" sourceNode="_suuIQAFfEeaZkPiwH6BSQw" targetNode="_8IOo4AFfEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridGroupedCell/groupables"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridGroupedCell/groupables"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_8IXLwQFfEeaZkPiwH6BSQw" routingStyle="manhattan" strokeColor="0,0,0">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']/@style"/>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_8IXLwgFfEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_8IXLwwFfEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_8IXy0AFfEeaZkPiwH6BSQw" sourceNode="_suuIQAFfEeaZkPiwH6BSQw" targetNode="_8IOo4AFfEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridGroupedCell"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//CxGridGroupedCell/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_8IXy0QFfEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_8IXy0gFfEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_8IXy0wFfEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_E1_qQAFgEeaZkPiwH6BSQw" name="CxGridColumn" tooltipText="" outgoingEdges="_E2NFoAFgEeaZkPiwH6BSQw" incomingEdges="_E2OTwAFgEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridColumn"/>
+        <semanticElements xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridColumn"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_E2ARUAFgEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2GX8AFgEeaZkPiwH6BSQw" name="propertyId : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyId"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyId"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2GX8QFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2GX8gFgEeaZkPiwH6BSQw" name="label : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/label"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/label"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2G_AAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2G_AQFgEeaZkPiwH6BSQw" name="labelI18nKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/labelI18nKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/labelI18nKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2G_AgFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2G_AwFgEeaZkPiwH6BSQw" name="editable : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/editable"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/editable"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2HmEAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2HmEQFgEeaZkPiwH6BSQw" name="headerCaption : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaption"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaption"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2HmEgFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2HmEwFgEeaZkPiwH6BSQw" name="headerCaptionI18nKey : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaptionI18nKey"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/headerCaptionI18nKey"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2INIAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2INIQFgEeaZkPiwH6BSQw" name="expandRatio : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/expandRatio"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/expandRatio"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2INIgFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2INIwFgEeaZkPiwH6BSQw" name="hidden : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hidden"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hidden"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2I0MAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2I0MQFgEeaZkPiwH6BSQw" name="hideable : EBoolean = true" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hideable"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/hideable"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2I0MgFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2I0MwFgEeaZkPiwH6BSQw" name="sortable : EBoolean = true" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/sortable"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/sortable"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2JbQAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2JbQQFgEeaZkPiwH6BSQw" name="propertyPath : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyPath"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/propertyPath"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2JbQgFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2JbQwFgEeaZkPiwH6BSQw" name="width : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/width"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/width"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2KCUAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2KCUQFgEeaZkPiwH6BSQw" name="minWidthPixels : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/minWidthPixels"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/minWidthPixels"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2KCUgFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2KCUwFgEeaZkPiwH6BSQw" name="maxWidthPixels : EInt = -1" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/maxWidthPixels"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/maxWidthPixels"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2KpYAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2KpYQFgEeaZkPiwH6BSQw" name="type : EJavaClass" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/type"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/type"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2KpYgFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_E2KpYwFgEeaZkPiwH6BSQw" name="typeQualifiedName : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/typeQualifiedName"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="cxgrid.ecore#//CxGridColumn/typeQualifiedName"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_E2LQcAFgEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_E2NFoAFgEeaZkPiwH6BSQw" sourceNode="_E1_qQAFgEeaZkPiwH6BSQw" targetNode="_8IOo4AFfEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="cxgrid.ecore#//CxGridColumn"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//CxGridColumn/@eGenericSuperTypes.0"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="cxgrid.ecore#//CxGridColumn/@eGenericSuperTypes.1"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_E2NssAFgEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_E2NssQFgEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_E2NssgFgEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_E2OTwAFgEeaZkPiwH6BSQw" sourceNode="_suvWYAFfEeaZkPiwH6BSQw" targetNode="_E1_qQAFgEeaZkPiwH6BSQw" beginLabel="[0..*] usedInMetaCells" endLabel="[0..1] target">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaCell/target"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaCell/target"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridColumn/usedInMetaCells"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_E2OTwQFgEeaZkPiwH6BSQw" sourceArrow="InputArrow" routingStyle="manhattan" strokeColor="0,0,0">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_E2OTwgFgEeaZkPiwH6BSQw" showIcon="false"/>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_E2OTwwFgEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_GQfc4AFhEeaZkPiwH6BSQw" name="YEmbeddable" tooltipText="" incomingEdges="_GQwioAFhEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable"/>
+        <semanticElements xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable"/>
+        <decorations xmi:type="viewpoint:Decoration" xmi:id="_GQutcAFhEeaZkPiwH6BSQw">
+          <description xmi:type="description:SemanticBasedDecoration" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@decorationDescriptionsSet/@decorationDescriptions[name='External']"/>
+        </decorations>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_GQgD8AFhEeaZkPiwH6BSQw" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_abstract.gif" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">
+          <labelFormat>italic</labelFormat>
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.1/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_GQs4QAFhEeaZkPiwH6BSQw" name="mementoEnabled : EBoolean = false" visible="false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoEnabled"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoEnabled"/>
+          <graphicalFilters xmi:type="diagram:HideFilter" xmi:id="_LW2SsAFhEeaZkPiwH6BSQw"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_GQs4QQFhEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_GQtfUAFhEeaZkPiwH6BSQw" name="mementoId : EString" visible="false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoId"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoId"/>
+          <graphicalFilters xmi:type="diagram:HideFilter" xmi:id="_LW2SsQFhEeaZkPiwH6BSQw"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_GQtfUQFhEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_GQtfUgFhEeaZkPiwH6BSQw" name="getView() : YView" visible="false" tooltipText="getView() : YView">
+          <target xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getView"/>
+          <semanticElements xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getView"/>
+          <graphicalFilters xmi:type="diagram:HideFilter" xmi:id="_L4_WcAFhEeaZkPiwH6BSQw"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_GQuGYAFhEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_GQuGYQFhEeaZkPiwH6BSQw" name="getParent() : YLayout" visible="false" tooltipText="getParent() : YLayout">
+          <target xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getParent"/>
+          <semanticElements xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getParent"/>
+          <graphicalFilters xmi:type="diagram:HideFilter" xmi:id="_L4_WcQFhEeaZkPiwH6BSQw"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_GQuGYgFhEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_GQwioAFhEeaZkPiwH6BSQw" name="[0..1] element" sourceNode="_suvWYAFfEeaZkPiwH6BSQw" targetNode="_GQfc4AFhEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaCell/element"/>
+        <semanticElements xmi:type="ecore:EReference" href="cxgrid.ecore#//CxGridMetaCell/element"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_GQxJsAFhEeaZkPiwH6BSQw" description="_M4Z28AFfEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_GQxJsQFhEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_GQxJsgFhEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_JXPdVQFfEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="cxgrid.ecore#/"/>
+    </ownedRepresentations>
+    <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']"/>
+  </ownedViews>
+  <ownedViews xmi:type="viewpoint:DRepresentationContainer" xmi:id="_CGtTIAFYEeaZkPiwH6BSQw">
+    <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Review']"/>
+  </ownedViews>
+  <ownedViews xmi:type="viewpoint:DRepresentationContainer" xmi:id="_CG_nAAFYEeaZkPiwH6BSQw">
+    <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']"/>
+  </ownedViews>
+  <ownedViews xmi:type="viewpoint:DRepresentationContainer" xmi:id="_CLMxkAFYEeaZkPiwH6BSQw">
+    <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Generation']"/>
+  </ownedViews>
+</viewpoint:DAnalysis>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.ecore b/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.ecore
new file mode 100644
index 0000000..30a4a61
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.ecore
@@ -0,0 +1,248 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="grid" nsURI="http://osbp.de/ecview/v1/extension/grid" nsPrefix="grid">
+  <eClassifiers xsi:type="ecore:EClass" name="CxGrid" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YCollectionBindable ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YSelectionBindable ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YMultiSelectionBindable ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YBeanServiceConsumer">
+    <eOperations name="createEditorFieldHelperLayout" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YHelperLayout"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="selectionType" eType="ecore:EEnum ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YSelectionType"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="selectionEventTopic" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="selection" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="multiSelection" upperBound="-1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="collection" upperBound="-1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+      <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="emfNsURI" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="columns" upperBound="-1"
+        eType="#//CxGridColumn" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="sortOrder" upperBound="-1"
+        eType="#//CxGridSortable" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="columnReorderingAllowed"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean" defaultValueLiteral="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="cellStyleGenerator" eType="#//CxGridCellStyleGenerator"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="filteringVisible" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="customFilters" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="false"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="headers" upperBound="-1"
+        eType="#//CxGridHeaderRow" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="headerVisible" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="footers" upperBound="-1"
+        eType="#//CxGridFooterRow" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="footerVisible" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="editorEnabled" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="editorCancelI18nLabelKey"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="editorSaveI18nLabelKey"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="editorSaved" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridProvider" abstract="true" interface="true"/>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridMetaRow" abstract="true" interface="true"
+      eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement #//CxGridProvider">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="groupings" upperBound="-1"
+        eType="#//CxGridGroupedCell" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="customCells" upperBound="-1"
+        eType="#//CxGridMetaCell" containment="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridHeaderRow" eSuperTypes="#//CxGridMetaRow"/>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridFooterRow" eSuperTypes="#//CxGridMetaRow"/>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridFilterRow" eSuperTypes="#//CxGridMetaRow"/>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridGroupable" abstract="true" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement #//CxGridProvider"/>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridMetaCell" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement #//CxGridProvider">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="target" eType="#//CxGridColumn"
+        eOpposite="#//CxGridColumn/usedInMetaCells"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="label" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="labelI18nKey" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="useHTML" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="element" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YEmbeddable"
+        containment="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridGroupedCell" eSuperTypes="#//CxGridGroupable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="groupables" upperBound="-1"
+        eType="#//CxGridGroupable"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="label" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="labelI18nKey" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="useHTML" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridColumn" eSuperTypes="#//CxGridGroupable ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YHelperLayoutProvider">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="propertyId" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="label" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="labelI18nKey" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="editable" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="false"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="converter" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="renderer" eType="#//renderer/CxGridRenderer"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="editorField" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YField"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="searchField" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YSearchField"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="headerCaption" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="headerCaptionI18nKey" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="expandRatio" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+        defaultValueLiteral="-1"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="hidden" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="hideable" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="sortable" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="propertyPath" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="width" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+        defaultValueLiteral="-1"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="minWidthPixels" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+        defaultValueLiteral="-1"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="maxWidthPixels" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+        defaultValueLiteral="-1"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="usedInMetaCells" upperBound="-1"
+        eType="#//CxGridMetaCell" eOpposite="#//CxGridMetaCell/target"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+      <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridCellStyleGenerator" abstract="true"
+      eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement #//CxGridProvider"/>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridDelegateCellStyleGenerator" eSuperTypes="#//CxGridCellStyleGenerator">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="delegateId" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="CxGridSortable" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="descending" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="false"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="column" lowerBound="1"
+        eType="#//CxGridColumn"/>
+  </eClassifiers>
+  <eSubpackages name="renderer" nsURI="http://osbp.de/ecview/v1/extension/grid/renderer"
+      nsPrefix="renderer">
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridRenderer" abstract="true" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement #//CxGridProvider"/>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridDelegateRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="delegateId" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridDateRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="dateFormat" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridHtmlRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="nullRepresentation" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridNumberRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="numberFormat" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral="#,##0.00"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="nullRepresentation" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridProgressBarRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="maxValue" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDouble"
+          defaultValueLiteral="1"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridTextRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="nullRepresentation" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridButtonRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eOperations name="createLastClickEventEndpoint" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/binding.ecore#//YECViewModelValueBindingEndpoint"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="nullRepresentation" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+      <eStructuralFeatures xsi:type="ecore:EReference" name="lastClickEvent" eType="#//renderer/CxGridRendererClickEvent"
+          containment="true"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="eventTopic" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridImageRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eOperations name="createLastClickEventEndpoint" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/binding.ecore#//YECViewModelValueBindingEndpoint"/>
+      <eStructuralFeatures xsi:type="ecore:EReference" name="lastClickEvent" eType="#//renderer/CxGridRendererClickEvent"
+          containment="true"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="eventTopic" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridRendererClickEvent">
+      <eStructuralFeatures xsi:type="ecore:EReference" name="renderer" lowerBound="1"
+          eType="#//renderer/CxGridRenderer"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="lastClickTime" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//ELong"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridBooleanRenderer" eSuperTypes="#//renderer/CxGridRenderer"/>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridQuantityRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="valuePropertyPath" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="uomPropertyPath" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="nullRepresentation" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="htmlPattern" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral="&lt;b>{@value}&lt;/b> &lt;i>{@currency}&lt;/i>"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="numberFormat" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral="#,##0.00"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridPriceRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="valuePropertyPath" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="currencyPropertyPath"
+          lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="nullRepresentation" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral=""/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="htmlPattern" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral="&lt;b>{@value}&lt;/b> &lt;i>{@currency}&lt;/i>"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="numberFormat" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral="#,##0.00"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridIndicatorRenderer" eSuperTypes="#//renderer/CxGridRenderer">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="redEnds" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDouble"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="greenStarts" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDouble"/>
+    </eClassifiers>
+  </eSubpackages>
+  <eSubpackages name="memento" nsURI="http://osbp.de/ecview/v1/extension/grid/memento"
+      nsPrefix="memento">
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridMemento" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YMemento">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="gridId" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="headerVisible" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="filterVisible" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="footerVisible" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="editorEnabled" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+      <eStructuralFeatures xsi:type="ecore:EReference" name="columns" upperBound="-1"
+          eType="#//memento/CxGridMementoColumn" containment="true"/>
+      <eStructuralFeatures xsi:type="ecore:EReference" name="sortOrders" upperBound="-1"
+          eType="#//memento/CxGridMementoSortable" containment="true"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridMementoColumn">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="propertyId" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="editable" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+          defaultValueLiteral="false"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="expandRatio" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+          defaultValueLiteral="-1"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="hidden" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+          defaultValueLiteral="false"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="hideable" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+          defaultValueLiteral="true"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="sortable" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+          defaultValueLiteral="true"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="width" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+          defaultValueLiteral="-1"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="CxGridMementoSortable">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="descending" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+          defaultValueLiteral="false"/>
+      <eStructuralFeatures xsi:type="ecore:EReference" name="column" lowerBound="1"
+          eType="#//memento/CxGridMementoColumn"/>
+    </eClassifiers>
+  </eSubpackages>
+</ecore:EPackage>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.genmodel b/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.genmodel
new file mode 100644
index 0000000..905e8e0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/model/cxgrid.genmodel
@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" 
+    modelDirectory="/org.eclipse.osbp.ecview.extension.grid.model/src" editDirectory="/org.eclipse.osbp.ecview.extension.grid.model.edit/src"
+    editorDirectory="/org.eclipse.osbp.ecview.extension.grid.model.editor/src" modelPluginID="org.eclipse.osbp.ecview.extension.grid.model"
+    modelName="CxGrid" editPluginClass="org.eclipse.osbp.ecview.extension.grid.provider.CxGridEditPlugin"
+    editorPluginClass="org.eclipse.osbp.ecview.extension.grid.presentation.cxecviewEditorPlugin"
+    rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container" testSuiteClass="org.eclipse.osbp.ecview.extension.grid.tests.cxecviewAllTests"
+    importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0" editPluginID="org.eclipse.osbp.ecview.extension.grid.model.edit"
+    editorPluginID="org.eclipse.osbp.ecview.extension.grid.model.editor" language="" usedGenPackages="../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//binding ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//core ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//validation ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//datatypes ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//visibility ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.genmodel#//datatypes ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.genmodel#//extension"
+    importOrganizing="true">
+  <foreignModel>cxgrid.ecore</foreignModel>
+  <genPackages prefix="CxGrid" basePackage="org.eclipse.osbp.ecview.extension" disposableProviderFactory="true"
+      extensibleProviderFactory="true" childCreationExtenders="true" ecorePackage="cxgrid.ecore#/">
+    <genClasses ecoreClass="cxgrid.ecore#//CxGrid">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/label"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/labelI18nKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/selectionType"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/selectionEventTopic"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/selection"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/multiSelection"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/collection"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/type"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/emfNsURI"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/typeQualifiedName"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGrid/columns"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/columnReorderingAllowed"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGrid/cellStyleGenerator"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/filteringVisible"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGrid/headers"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/headerVisible"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGrid/footers"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/footerVisible"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/editorEnabled"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/editorCancelI18nLabelKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGrid/editorSaveI18nLabelKey"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="cxgrid.ecore#//CxGridProvider"/>
+    <genClasses image="false" ecoreClass="cxgrid.ecore#//CxGridMetaRow">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridMetaRow/groupings"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridMetaRow/customCells"/>
+    </genClasses>
+    <genClasses ecoreClass="cxgrid.ecore#//CxGridHeaderRow"/>
+    <genClasses ecoreClass="cxgrid.ecore#//CxGridFooterRow"/>
+    <genClasses ecoreClass="cxgrid.ecore#//CxGridFilterRow"/>
+    <genClasses image="false" ecoreClass="cxgrid.ecore#//CxGridGroupable"/>
+    <genClasses ecoreClass="cxgrid.ecore#//CxGridMetaCell">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridMetaCell/target"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridMetaCell/label"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridMetaCell/labelI18nKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridMetaCell/useHTML"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridMetaCell/element"/>
+    </genClasses>
+    <genClasses ecoreClass="cxgrid.ecore#//CxGridGroupedCell">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridGroupedCell/groupables"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridGroupedCell/label"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridGroupedCell/labelI18nKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridGroupedCell/useHTML"/>
+    </genClasses>
+    <genClasses ecoreClass="cxgrid.ecore#//CxGridColumn">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/propertyId"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/label"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/labelI18nKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/visible"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/editable"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridColumn/converter"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridColumn/renderer"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridColumn/editorField"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridColumn/searchField"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/headerCaption"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/headerCaptionI18nKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/expandRatio"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/hidden"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/hideable"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/sortable"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/propertyPath"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/minWidthPixels"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridColumn/maxWidthPixels"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference cxgrid.ecore#//CxGridColumn/usedInMetaCells"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="cxgrid.ecore#//CxGridCellStyleGenerator"/>
+    <genClasses ecoreClass="cxgrid.ecore#//CxGridDelegateCellStyleGenerator">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//CxGridDelegateCellStyleGenerator/delegateId"/>
+    </genClasses>
+    <nestedGenPackages prefix="CxGridRenderer" disposableProviderFactory="true" ecorePackage="cxgrid.ecore#//renderer">
+      <genClasses image="false" ecoreClass="cxgrid.ecore#//renderer/CxGridRenderer"/>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridDelegateRenderer">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridDelegateRenderer/delegateId"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridDateRenderer">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridDateRenderer/dateFormat"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridHtmlRenderer">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridHtmlRenderer/nullRepresentation"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridNumberRenderer">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridNumberRenderer/numberFormat"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridNumberRenderer/nullRepresentation"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridProgressBarRenderer">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridProgressBarRenderer/maxValue"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridTextRenderer">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridTextRenderer/nullRepresentation"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridButtonRenderer">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridButtonRenderer/nullRepresentation"/>
+        <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//renderer/CxGridButtonRenderer/lastClickEvent"/>
+        <genOperations ecoreOperation="cxgrid.ecore#//renderer/CxGridButtonRenderer/createLastClickEventEndpoint"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridImageRenderer">
+        <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//renderer/CxGridImageRenderer/lastClickEvent"/>
+        <genOperations ecoreOperation="cxgrid.ecore#//renderer/CxGridImageRenderer/createLastClickEventEndpoint"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridRendererClickEvent">
+        <genFeatures notify="false" createChild="false" propertySortChoices="true"
+            ecoreFeature="ecore:EReference cxgrid.ecore#//renderer/CxGridRendererClickEvent/renderer"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//renderer/CxGridRendererClickEvent/lastClickTime"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//renderer/CxGridBooleanRenderer"/>
+    </nestedGenPackages>
+    <nestedGenPackages prefix="CxGridMemento" disposableProviderFactory="true" ecorePackage="cxgrid.ecore#//memento">
+      <genClasses ecoreClass="cxgrid.ecore#//memento/CxGridMemento">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//memento/CxGridMemento/gridId"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//memento/CxGridMemento/filterVisible"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//memento/CxGridMemento/editorEnabled"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//memento/CxGridMemento/columnsOrder"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//memento/CxGridMemento/visibleColumns"/>
+        <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference cxgrid.ecore#//memento/CxGridMemento/sortOrder"/>
+      </genClasses>
+      <genClasses ecoreClass="cxgrid.ecore#//memento/CxGridSortable">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//memento/CxGridSortable/columnId"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute cxgrid.ecore#//memento/CxGridSortable/descending"/>
+      </genClasses>
+    </nestedGenPackages>
+  </genPackages>
+</genmodel:GenModel>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/notice.html b/org.eclipse.osbp.ecview.extension.grid.model/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.grid.model/plugin.properties b/org.eclipse.osbp.ecview.extension.grid.model/plugin.properties
new file mode 100644
index 0000000..4a6a554
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/plugin.properties
@@ -0,0 +1,2 @@
+pluginName = Extension model
+providerName = 
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/plugin.xml b/org.eclipse.osbp.ecview.extension.grid.model/plugin.xml
new file mode 100644
index 0000000..6d38e43
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/plugin.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+-->
+
+<plugin>
+   
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated cxecview -->
+      <package
+            uri="http://osbp.de/ecview/v1/extension/grid"
+            class="org.eclipse.osbp.ecview.extension.model.CxECviewPackage"
+            genModel="model/cxgrid.genmodel"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated cxgrid -->
+      <package
+            uri="http://osbp.de/ecview/v1/extension/grid"
+            class="org.eclipse.osbp.ecview.extension.grid.CxGridPackage"
+            genModel="model/cxgrid.genmodel"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated cxgrid -->
+      <package
+            uri="http://osbp.de/ecview/v1/extension/grid/renderer"
+            class="org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage"
+            genModel="model/cxgrid.genmodel"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated cxgrid -->
+      <package
+            uri="http://osbp.de/ecview/v1/extension/grid/memento"
+            class="org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage"
+            genModel="model/cxgrid.genmodel"/>
+   </extension>
+
+</plugin>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/pom.xml b/org.eclipse.osbp.ecview.extension.grid.model/pom.xml
new file mode 100644
index 0000000..0fa636f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/pom.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial 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.ecview.extension.api</groupId>
+		<artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.ecview.extension.grid.model</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<description>Contains the extension ECView-Model for Vaadi Grid</description>
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+	</build>
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGrid.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGrid.java
new file mode 100644
index 0000000..f8528e7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGrid.java
@@ -0,0 +1,628 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.binding.YValueBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YHelperLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YMultiSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YSelectionType;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '
+ * <em><b>Cx Grid</b></em>'. <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionType <em>Selection Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionEventTopic <em>Selection Event Topic</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelection <em>Selection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getMultiSelection <em>Multi Selection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getCollection <em>Collection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEmfNsURI <em>Emf Ns URI</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getColumns <em>Columns</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSortOrder <em>Sort Order</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isColumnReorderingAllowed <em>Column Reordering Allowed</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getCellStyleGenerator <em>Cell Style Generator</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isFilteringVisible <em>Filtering Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isCustomFilters <em>Custom Filters</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getHeaders <em>Headers</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isHeaderVisible <em>Header Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getFooters <em>Footers</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isFooterVisible <em>Footer Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isEditorEnabled <em>Editor Enabled</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorCancelI18nLabelKey <em>Editor Cancel I1 8n Label Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaveI18nLabelKey <em>Editor Save I1 8n Label Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaved <em>Editor Saved</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid()
+ * @model
+ * @generated
+ */
+public interface CxGrid extends YInput, YCollectionBindable,
+		YSelectionBindable, YMultiSelectionBindable, YBeanServiceConsumer {
+	
+	/**
+	 * Returns the value of the '<em><b>Selection Type</b></em>' attribute.
+	 * The literals are from the enumeration {@link org.eclipse.osbp.ecview.core.extension.model.extension.YSelectionType}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Selection Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Selection Type</em>' attribute.
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.YSelectionType
+	 * @see #setSelectionType(YSelectionType)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_SelectionType()
+	 * @model
+	 * @generated
+	 */
+	YSelectionType getSelectionType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionType <em>Selection Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Selection Type</em>' attribute.
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.YSelectionType
+	 * @see #getSelectionType()
+	 * @generated
+	 */
+	void setSelectionType(YSelectionType value);
+
+	/**
+	 * Returns the value of the '<em><b>Selection Event Topic</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Selection Event Topic</em>' attribute isn't
+	 * clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Selection Event Topic</em>' attribute.
+	 * @see #setSelectionEventTopic(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_SelectionEventTopic()
+	 * @model
+	 * @generated
+	 */
+	String getSelectionEventTopic();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionEventTopic <em>Selection Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Selection Event Topic</em>' attribute.
+	 * @see #getSelectionEventTopic()
+	 * @generated
+	 */
+	void setSelectionEventTopic(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Selection</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Selection</em>' attribute isn't clear, there
+	 * really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Selection</em>' attribute.
+	 * @see #setSelection(Object)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_Selection()
+	 * @model transient="true"
+	 * @generated
+	 */
+	Object getSelection();
+
+	/**
+	 * Sets the value of the '
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelection
+	 * <em>Selection</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Selection</em>' attribute.
+	 * @see #getSelection()
+	 * @generated
+	 */
+	void setSelection(Object value);
+
+	/**
+	 * Returns the value of the '<em><b>Multi Selection</b></em>' attribute
+	 * list. The list contents are of type {@link java.lang.Object}. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Multi Selection</em>' attribute list isn't
+	 * clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Multi Selection</em>' attribute list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_MultiSelection()
+	 * @model transient="true"
+	 * @generated
+	 */
+	EList<Object> getMultiSelection();
+
+	/**
+	 * Returns the value of the '<em><b>Collection</b></em>' attribute list.
+	 * The list contents are of type {@link java.lang.Object}.
+	 * <!-- begin-user-doc
+	 * -->
+	 * <p>
+	 * If the meaning of the '<em>Collection</em>' attribute list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Collection</em>' attribute list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_Collection()
+	 * @model transient="true"
+	 * @generated
+	 */
+	EList<Object> getCollection();
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear, there really
+	 * should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+	/**
+	 * Returns the value of the '<em><b>Emf Ns URI</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Emf Ns URI</em>' attribute isn't clear, there
+	 * really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Emf Ns URI</em>' attribute.
+	 * @see #setEmfNsURI(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_EmfNsURI()
+	 * @model
+	 * @generated
+	 */
+	String getEmfNsURI();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEmfNsURI <em>Emf Ns URI</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Emf Ns URI</em>' attribute.
+	 * @see #getEmfNsURI()
+	 * @generated
+	 */
+	void setEmfNsURI(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't
+	 * clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Editor Enabled</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editor Enabled</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Editor Enabled</em>' attribute.
+	 * @see #setEditorEnabled(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_EditorEnabled()
+	 * @model
+	 * @generated
+	 */
+	boolean isEditorEnabled();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isEditorEnabled <em>Editor Enabled</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Editor Enabled</em>' attribute.
+	 * @see #isEditorEnabled()
+	 * @generated
+	 */
+	void setEditorEnabled(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Cell Style Generator</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Cell Style Generator</em>' containment
+	 * reference isn't clear, there really should be more of a description
+	 * here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Cell Style Generator</em>' containment reference.
+	 * @see #setCellStyleGenerator(CxGridCellStyleGenerator)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_CellStyleGenerator()
+	 * @model containment="true"
+	 * @generated
+	 */
+	CxGridCellStyleGenerator getCellStyleGenerator();
+
+	/**
+	 * Sets the value of the '
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getCellStyleGenerator
+	 * <em>Cell Style Generator</em>}' containment reference. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Cell Style Generator</em>'
+	 *            containment reference.
+	 * @see #getCellStyleGenerator()
+	 * @generated
+	 */
+	void setCellStyleGenerator(CxGridCellStyleGenerator value);
+
+	/**
+	 * Returns the value of the '<em><b>Filtering Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Filtering Visible</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Filtering Visible</em>' attribute.
+	 * @see #setFilteringVisible(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_FilteringVisible()
+	 * @model transient="true"
+	 * @generated
+	 */
+	boolean isFilteringVisible();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isFilteringVisible <em>Filtering Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Filtering Visible</em>' attribute.
+	 * @see #isFilteringVisible()
+	 * @generated
+	 */
+	void setFilteringVisible(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Custom Filters</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Custom Filters</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Custom Filters</em>' attribute.
+	 * @see #setCustomFilters(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_CustomFilters()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isCustomFilters();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isCustomFilters <em>Custom Filters</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Custom Filters</em>' attribute.
+	 * @see #isCustomFilters()
+	 * @generated
+	 */
+	void setCustomFilters(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Headers</b></em>' containment reference
+	 * list. The list contents are of type
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow}. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Headers</em>' containment reference list isn't
+	 * clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Headers</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_Headers()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridHeaderRow> getHeaders();
+
+	/**
+	 * Returns the value of the '<em><b>Columns</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn}.
+	 * <!-- begin-user-doc
+	 * -->
+	 * <p>
+	 * If the meaning of the '<em>Columns</em>' containment reference isn't
+	 * clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Columns</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_Columns()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridColumn> getColumns();
+
+	/**
+	 * Returns the value of the '<em><b>Sort Order</b></em>' containment
+	 * reference list. The list contents are of type
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable}. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Sort Order</em>' containment reference list
+	 * isn't clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Sort Order</em>' containment reference
+	 *         list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_SortOrder()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridSortable> getSortOrder();
+
+	/**
+	 * Returns the value of the '<em><b>Column Reordering Allowed</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc
+	 * -->
+	 * <p>
+	 * If the meaning of the '<em>Column Reordering Allowed</em>' attribute
+	 * isn't clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Column Reordering Allowed</em>' attribute.
+	 * @see #setColumnReorderingAllowed(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_ColumnReorderingAllowed()
+	 * @model default="true"
+	 * @generated
+	 */
+	boolean isColumnReorderingAllowed();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isColumnReorderingAllowed <em>Column Reordering Allowed</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Column Reordering Allowed</em>' attribute.
+	 * @see #isColumnReorderingAllowed()
+	 * @generated
+	 */
+	void setColumnReorderingAllowed(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Footer Visible</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Footer Visible</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Footer Visible</em>' attribute.
+	 * @see #setFooterVisible(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_FooterVisible()
+	 * @model
+	 * @generated
+	 */
+	boolean isFooterVisible();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isFooterVisible <em>Footer Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Footer Visible</em>' attribute.
+	 * @see #isFooterVisible()
+	 * @generated
+	 */
+	void setFooterVisible(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Header Visible</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Header Visible</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Header Visible</em>' attribute.
+	 * @see #setHeaderVisible(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_HeaderVisible()
+	 * @model default="true"
+	 * @generated
+	 */
+	boolean isHeaderVisible();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isHeaderVisible <em>Header Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Header Visible</em>' attribute.
+	 * @see #isHeaderVisible()
+	 * @generated
+	 */
+	void setHeaderVisible(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Footers</b></em>' containment reference
+	 * list. The list contents are of type
+	 * {@link org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow}. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Footers</em>' containment reference list isn't
+	 * clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Footers</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_Footers()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridFooterRow> getFooters();
+
+	/**
+	 * Returns the value of the '<em><b>Editor Cancel I1 8n Label Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editor Cancel I1 8n Label Key</em>' attribute
+	 * isn't clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Editor Cancel I1 8n Label Key</em>' attribute.
+	 * @see #setEditorCancelI18nLabelKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_EditorCancelI18nLabelKey()
+	 * @model
+	 * @generated
+	 */
+	String getEditorCancelI18nLabelKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorCancelI18nLabelKey <em>Editor Cancel I1 8n Label Key</em>}' attribute.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Editor Cancel I1 8n Label Key</em>' attribute.
+	 * @see #getEditorCancelI18nLabelKey()
+	 * @generated
+	 */
+	void setEditorCancelI18nLabelKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Editor Save I1 8n Label Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editor Save I1 8n Label Key</em>' attribute
+	 * isn't clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Editor Save I1 8n Label Key</em>' attribute.
+	 * @see #setEditorSaveI18nLabelKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_EditorSaveI18nLabelKey()
+	 * @model
+	 * @generated
+	 */
+	String getEditorSaveI18nLabelKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaveI18nLabelKey <em>Editor Save I1 8n Label Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Editor Save I1 8n Label Key</em>' attribute.
+	 * @see #getEditorSaveI18nLabelKey()
+	 * @generated
+	 */
+	void setEditorSaveI18nLabelKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Editor Saved</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editor Saved</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Editor Saved</em>' attribute.
+	 * @see #setEditorSaved(Object)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGrid_EditorSaved()
+	 * @model transient="true"
+	 * @generated
+	 */
+	Object getEditorSaved();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaved <em>Editor Saved</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Editor Saved</em>' attribute.
+	 * @see #getEditorSaved()
+	 * @generated
+	 */
+	void setEditorSaved(Object value);
+
+	/**
+	 * <!-- begin-user-doc --> Returns a new instance of YHelperLayout
+	 * referencing <b>(NOT containing)</b> all editor fields. <!-- end-user-doc
+	 * -->
+	 *
+	 * @return the y helper layout
+	 * @model
+	 * @generated
+	 */
+	YHelperLayout createEditorFieldHelperLayout();
+
+	/**
+	 * Creates a binding endpoint which passes the editor input if "save" was
+	 * pressed.
+	 * <p>
+	 * Operations about save need to be handled outside.
+	 *
+	 * @return the y value binding endpoint
+	 */
+	YValueBindingEndpoint createEditorUpdatedEndpoint();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridCellStyleGenerator.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridCellStyleGenerator.java
new file mode 100644
index 0000000..56644ff
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridCellStyleGenerator.java
@@ -0,0 +1,31 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cell Style Generator</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridCellStyleGenerator()
+ * @model abstract="true"
+ * @generated
+ */
+public interface CxGridCellStyleGenerator extends YElement, CxGridProvider {
+
+} 
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridColumn.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridColumn.java
new file mode 100644
index 0000000..6aab829
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridColumn.java
@@ -0,0 +1,607 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+import org.eclipse.osbp.ecview.core.common.model.core.YField;
+import org.eclipse.osbp.ecview.core.common.model.core.YHelperLayoutProvider;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YSearchField;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Column</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyId <em>Property Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isEditable <em>Editable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getConverter <em>Converter</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getRenderer <em>Renderer</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getEditorField <em>Editor Field</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getSearchField <em>Search Field</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaption <em>Header Caption</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaptionI18nKey <em>Header Caption I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getExpandRatio <em>Expand Ratio</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHidden <em>Hidden</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHideable <em>Hideable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isSortable <em>Sortable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyPath <em>Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getWidth <em>Width</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMinWidthPixels <em>Min Width Pixels</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMaxWidthPixels <em>Max Width Pixels</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getUsedInMetaCells <em>Used In Meta Cells</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn()
+ * @model
+ * @generated
+ */
+public interface CxGridColumn extends CxGridGroupable, YHelperLayoutProvider {
+	
+	/**
+	 * Returns the value of the '<em><b>Property Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Property Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Property Id</em>' attribute.
+	 * @see #setPropertyId(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_PropertyId()
+	 * @model
+	 * @generated
+	 */
+	String getPropertyId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyId <em>Property Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Property Id</em>' attribute.
+	 * @see #getPropertyId()
+	 * @generated
+	 */
+	void setPropertyId(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Converter</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Converter</em>' containment reference.
+	 * @see #setConverter(YConverter)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Converter()
+	 * @model containment="true"
+	 * @generated
+	 */
+	YConverter getConverter();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getConverter <em>Converter</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Converter</em>' containment reference.
+	 * @see #getConverter()
+	 * @generated
+	 */
+	void setConverter(YConverter value);
+
+	/**
+	 * Returns the value of the '<em><b>Renderer</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Renderer</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Renderer</em>' containment reference.
+	 * @see #setRenderer(CxGridRenderer)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Renderer()
+	 * @model containment="true"
+	 * @generated
+	 */
+	CxGridRenderer getRenderer();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getRenderer <em>Renderer</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Renderer</em>' containment reference.
+	 * @see #getRenderer()
+	 * @generated
+	 */
+	void setRenderer(CxGridRenderer value);
+
+	/**
+	 * Returns the value of the '<em><b>Editor Field</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editor Field</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Editor Field</em>' containment reference.
+	 * @see #setEditorField(YField)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_EditorField()
+	 * @model containment="true"
+	 * @generated
+	 */
+	YField getEditorField();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getEditorField <em>Editor Field</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Editor Field</em>' containment reference.
+	 * @see #getEditorField()
+	 * @generated
+	 */
+	void setEditorField(YField value);
+
+	/**
+	 * Returns the value of the '<em><b>Search Field</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Search Field</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Search Field</em>' containment reference.
+	 * @see #setSearchField(YSearchField)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_SearchField()
+	 * @model containment="true"
+	 * @generated
+	 */
+	YSearchField getSearchField();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getSearchField <em>Search Field</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Search Field</em>' containment reference.
+	 * @see #getSearchField()
+	 * @generated
+	 */
+	void setSearchField(YSearchField value);
+
+	/**
+	 * Returns the value of the '<em><b>Header Caption</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Header Caption</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Header Caption</em>' attribute.
+	 * @see #setHeaderCaption(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_HeaderCaption()
+	 * @model
+	 * @generated
+	 */
+	String getHeaderCaption();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaption <em>Header Caption</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Header Caption</em>' attribute.
+	 * @see #getHeaderCaption()
+	 * @generated
+	 */
+	void setHeaderCaption(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Header Caption I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Header Caption I1 8n Key</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Header Caption I1 8n Key</em>' attribute.
+	 * @see #setHeaderCaptionI18nKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_HeaderCaptionI18nKey()
+	 * @model
+	 * @generated
+	 */
+	String getHeaderCaptionI18nKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaptionI18nKey <em>Header Caption I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Header Caption I1 8n Key</em>' attribute.
+	 * @see #getHeaderCaptionI18nKey()
+	 * @generated
+	 */
+	void setHeaderCaptionI18nKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Expand Ratio</b></em>' attribute.
+	 * The default value is <code>"-1"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Expand Ratio</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Expand Ratio</em>' attribute.
+	 * @see #setExpandRatio(int)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_ExpandRatio()
+	 * @model default="-1"
+	 * @generated
+	 */
+	int getExpandRatio();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getExpandRatio <em>Expand Ratio</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Expand Ratio</em>' attribute.
+	 * @see #getExpandRatio()
+	 * @generated
+	 */
+	void setExpandRatio(int value);
+
+	/**
+	 * Returns the value of the '<em><b>Hidden</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Hidden</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Hidden</em>' attribute.
+	 * @see #setHidden(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Hidden()
+	 * @model
+	 * @generated
+	 */
+	boolean isHidden();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHidden <em>Hidden</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Hidden</em>' attribute.
+	 * @see #isHidden()
+	 * @generated
+	 */
+	void setHidden(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Hideable</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Hideable</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Hideable</em>' attribute.
+	 * @see #setHideable(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Hideable()
+	 * @model default="true"
+	 * @generated
+	 */
+	boolean isHideable();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHideable <em>Hideable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Hideable</em>' attribute.
+	 * @see #isHideable()
+	 * @generated
+	 */
+	void setHideable(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Sortable</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Sortable</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Sortable</em>' attribute.
+	 * @see #setSortable(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Sortable()
+	 * @model default="true"
+	 * @generated
+	 */
+	boolean isSortable();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isSortable <em>Sortable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Sortable</em>' attribute.
+	 * @see #isSortable()
+	 * @generated
+	 */
+	void setSortable(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Property Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Property Path</em>' attribute.
+	 * @see #setPropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_PropertyPath()
+	 * @model
+	 * @generated
+	 */
+	String getPropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyPath <em>Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Property Path</em>' attribute.
+	 * @see #getPropertyPath()
+	 * @generated
+	 */
+	void setPropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Width</b></em>' attribute.
+	 * The default value is <code>"-1"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Width</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Width</em>' attribute.
+	 * @see #setWidth(int)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Width()
+	 * @model default="-1"
+	 * @generated
+	 */
+	int getWidth();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getWidth <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Width</em>' attribute.
+	 * @see #getWidth()
+	 * @generated
+	 */
+	void setWidth(int value);
+
+	/**
+	 * Returns the value of the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label</em>' attribute.
+	 * @see #setLabel(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Label()
+	 * @model
+	 * @generated
+	 */
+	String getLabel();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabel <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label</em>' attribute.
+	 * @see #getLabel()
+	 * @generated
+	 */
+	void setLabel(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label I1 8n Key</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #setLabelI18nKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_LabelI18nKey()
+	 * @model
+	 * @generated
+	 */
+	String getLabelI18nKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabelI18nKey <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 */
+	void setLabelI18nKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Editable</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editable</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Editable</em>' attribute.
+	 * @see #setEditable(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Editable()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isEditable();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isEditable <em>Editable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Editable</em>' attribute.
+	 * @see #isEditable()
+	 * @generated
+	 */
+	void setEditable(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Min Width Pixels</b></em>' attribute.
+	 * The default value is <code>"-1"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Min Width Pixels</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Min Width Pixels</em>' attribute.
+	 * @see #setMinWidthPixels(int)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_MinWidthPixels()
+	 * @model default="-1"
+	 * @generated
+	 */
+	int getMinWidthPixels();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMinWidthPixels <em>Min Width Pixels</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Min Width Pixels</em>' attribute.
+	 * @see #getMinWidthPixels()
+	 * @generated
+	 */
+	void setMinWidthPixels(int value);
+
+	/**
+	 * Returns the value of the '<em><b>Max Width Pixels</b></em>' attribute.
+	 * The default value is <code>"-1"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Max Width Pixels</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Max Width Pixels</em>' attribute.
+	 * @see #setMaxWidthPixels(int)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_MaxWidthPixels()
+	 * @model default="-1"
+	 * @generated
+	 */
+	int getMaxWidthPixels();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMaxWidthPixels <em>Max Width Pixels</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Max Width Pixels</em>' attribute.
+	 * @see #getMaxWidthPixels()
+	 * @generated
+	 */
+	void setMaxWidthPixels(int value);
+
+	/**
+	 * Returns the value of the '<em><b>Used In Meta Cells</b></em>' reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell}.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getTarget <em>Target</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Used In Meta Cells</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Used In Meta Cells</em>' reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_UsedInMetaCells()
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getTarget
+	 * @model opposite="target"
+	 * @generated
+	 */
+	EList<CxGridMetaCell> getUsedInMetaCells();
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridColumn_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridDelegateCellStyleGenerator.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridDelegateCellStyleGenerator.java
new file mode 100644
index 0000000..35f1f71
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridDelegateCellStyleGenerator.java
@@ -0,0 +1,62 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Delegate Cell Style Generator</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator#getDelegateId <em>Delegate Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridDelegateCellStyleGenerator()
+ * @model
+ * @generated
+ */
+public interface CxGridDelegateCellStyleGenerator extends CxGridCellStyleGenerator {
+	
+	/**
+	 * Returns the value of the '<em><b>Delegate Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Delegate Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Delegate Id</em>' attribute.
+	 * @see #setDelegateId(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridDelegateCellStyleGenerator_DelegateId()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getDelegateId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator#getDelegateId <em>Delegate Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Delegate Id</em>' attribute.
+	 * @see #getDelegateId()
+	 * @generated
+	 */
+	void setDelegateId(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFactory.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFactory.java
new file mode 100644
index 0000000..3d00dcf
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFactory.java
@@ -0,0 +1,127 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage
+ * @generated
+ */
+public interface CxGridFactory extends EFactory {
+	
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	CxGridFactory eINSTANCE = org.eclipse.osbp.ecview.extension.grid.impl.CxGridFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid</em>'.
+	 * @generated
+	 */
+	CxGrid createCxGrid();
+
+	/**
+	 * Returns a new object of class '<em>Header Row</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Header Row</em>'.
+	 * @generated
+	 */
+	CxGridHeaderRow createCxGridHeaderRow();
+
+	/**
+	 * Returns a new object of class '<em>Footer Row</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Footer Row</em>'.
+	 * @generated
+	 */
+	CxGridFooterRow createCxGridFooterRow();
+
+	/**
+	 * Returns a new object of class '<em>Filter Row</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Filter Row</em>'.
+	 * @generated
+	 */
+	CxGridFilterRow createCxGridFilterRow();
+
+	/**
+	 * Returns a new object of class '<em>Meta Cell</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Meta Cell</em>'.
+	 * @generated
+	 */
+	CxGridMetaCell createCxGridMetaCell();
+
+	/**
+	 * Returns a new object of class '<em>Grouped Cell</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Grouped Cell</em>'.
+	 * @generated
+	 */
+	CxGridGroupedCell createCxGridGroupedCell();
+
+	/**
+	 * Returns a new object of class '<em>Column</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Column</em>'.
+	 * @generated
+	 */
+	CxGridColumn createCxGridColumn();
+
+	/**
+	 * Returns a new object of class '<em>Delegate Cell Style Generator</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Delegate Cell Style Generator</em>'.
+	 * @generated
+	 */
+	CxGridDelegateCellStyleGenerator createCxGridDelegateCellStyleGenerator();
+
+	/**
+	 * Returns a new object of class '<em>Sortable</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Sortable</em>'.
+	 * @generated
+	 */
+	CxGridSortable createCxGridSortable();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	CxGridPackage getCxGridPackage();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFilterRow.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFilterRow.java
new file mode 100644
index 0000000..2bfed8b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFilterRow.java
@@ -0,0 +1,30 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Filter Row</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridFilterRow()
+ * @model
+ * @generated
+ */
+public interface CxGridFilterRow extends CxGridMetaRow {
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFooterRow.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFooterRow.java
new file mode 100644
index 0000000..dc91c2e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridFooterRow.java
@@ -0,0 +1,31 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Footer Row</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridFooterRow()
+ * @model
+ * @generated
+ */
+public interface CxGridFooterRow extends CxGridMetaRow {
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridGroupable.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridGroupable.java
new file mode 100644
index 0000000..2322257
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridGroupable.java
@@ -0,0 +1,31 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Groupable</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridGroupable()
+ * @model abstract="true"
+ * @generated
+ */
+public interface CxGridGroupable extends YElement, CxGridProvider {
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridGroupedCell.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridGroupedCell.java
new file mode 100644
index 0000000..c400213
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridGroupedCell.java
@@ -0,0 +1,134 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Grouped Cell</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getGroupables <em>Groupables</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#isUseHTML <em>Use HTML</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridGroupedCell()
+ * @model
+ * @generated
+ */
+public interface CxGridGroupedCell extends CxGridGroupable {
+	
+	/**
+	 * Returns the value of the '<em><b>Groupables</b></em>' reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupable}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Groupables</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Groupables</em>' reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridGroupedCell_Groupables()
+	 * @model
+	 * @generated
+	 */
+	EList<CxGridGroupable> getGroupables();
+
+	/**
+	 * Returns the value of the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label</em>' attribute.
+	 * @see #setLabel(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridGroupedCell_Label()
+	 * @model
+	 * @generated
+	 */
+	String getLabel();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabel <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label</em>' attribute.
+	 * @see #getLabel()
+	 * @generated
+	 */
+	void setLabel(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label I1 8n Key</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #setLabelI18nKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridGroupedCell_LabelI18nKey()
+	 * @model
+	 * @generated
+	 */
+	String getLabelI18nKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabelI18nKey <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 */
+	void setLabelI18nKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Use HTML</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Use HTML</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Use HTML</em>' attribute.
+	 * @see #setUseHTML(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridGroupedCell_UseHTML()
+	 * @model
+	 * @generated
+	 */
+	boolean isUseHTML();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#isUseHTML <em>Use HTML</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Use HTML</em>' attribute.
+	 * @see #isUseHTML()
+	 * @generated
+	 */
+	void setUseHTML(boolean value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridHeaderRow.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridHeaderRow.java
new file mode 100644
index 0000000..82aed1d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridHeaderRow.java
@@ -0,0 +1,31 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Header Row</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridHeaderRow()
+ * @model
+ * @generated
+ */
+public interface CxGridHeaderRow extends CxGridMetaRow {
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridMetaCell.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridMetaCell.java
new file mode 100644
index 0000000..1620417
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridMetaCell.java
@@ -0,0 +1,174 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Meta Cell</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getTarget <em>Target</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#isUseHTML <em>Use HTML</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getElement <em>Element</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaCell()
+ * @model
+ * @generated
+ */
+public interface CxGridMetaCell extends YElement, CxGridProvider {
+	
+	/**
+	 * Returns the value of the '<em><b>Target</b></em>' reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getUsedInMetaCells <em>Used In Meta Cells</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Target</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Target</em>' reference.
+	 * @see #setTarget(CxGridColumn)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaCell_Target()
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getUsedInMetaCells
+	 * @model opposite="usedInMetaCells"
+	 * @generated
+	 */
+	CxGridColumn getTarget();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getTarget <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Target</em>' reference.
+	 * @see #getTarget()
+	 * @generated
+	 */
+	void setTarget(CxGridColumn value);
+
+	/**
+	 * Returns the value of the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label</em>' attribute.
+	 * @see #setLabel(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaCell_Label()
+	 * @model
+	 * @generated
+	 */
+	String getLabel();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabel <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label</em>' attribute.
+	 * @see #getLabel()
+	 * @generated
+	 */
+	void setLabel(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label I1 8n Key</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #setLabelI18nKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaCell_LabelI18nKey()
+	 * @model
+	 * @generated
+	 */
+	String getLabelI18nKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabelI18nKey <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 */
+	void setLabelI18nKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Use HTML</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Use HTML</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Use HTML</em>' attribute.
+	 * @see #setUseHTML(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaCell_UseHTML()
+	 * @model
+	 * @generated
+	 */
+	boolean isUseHTML();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#isUseHTML <em>Use HTML</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Use HTML</em>' attribute.
+	 * @see #isUseHTML()
+	 * @generated
+	 */
+	void setUseHTML(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Element</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Element</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Element</em>' containment reference.
+	 * @see #setElement(YEmbeddable)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaCell_Element()
+	 * @model containment="true"
+	 * @generated
+	 */
+	YEmbeddable getElement();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getElement <em>Element</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Element</em>' containment reference.
+	 * @see #getElement()
+	 * @generated
+	 */
+	void setElement(YEmbeddable value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridMetaRow.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridMetaRow.java
new file mode 100644
index 0000000..8a1e9b7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridMetaRow.java
@@ -0,0 +1,71 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Meta Row</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow#getGroupings <em>Groupings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow#getCustomCells <em>Custom Cells</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaRow()
+ * @model interface="true" abstract="true"
+ * @generated
+ */
+public interface CxGridMetaRow extends YElement, CxGridProvider {
+	
+	/**
+	 * Returns the value of the '<em><b>Groupings</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Groupings</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Groupings</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaRow_Groupings()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridGroupedCell> getGroupings();
+
+	/**
+	 * Returns the value of the '<em><b>Custom Cells</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Custom Cells</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Custom Cells</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridMetaRow_CustomCells()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridMetaCell> getCustomCells();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridPackage.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridPackage.java
new file mode 100644
index 0000000..d32fe8d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridPackage.java
@@ -0,0 +1,2903 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface CxGridPackage extends EPackage {
+	
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "grid";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://osbp.de/ecview/v1/extension/grid";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "grid";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	CxGridPackage eINSTANCE = org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl <em>Cx Grid</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGrid()
+	 * @generated
+	 */
+	int CX_GRID = 0;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Collection Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__COLLECTION_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Selection Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__SELECTION_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Multi Selection Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Use Bean Service</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__USE_BEAN_SERVICE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Selection Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__SELECTION_TYPE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Selection Event Topic</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__SELECTION_EVENT_TOPIC = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Selection</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__SELECTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Multi Selection</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__MULTI_SELECTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 7;
+
+	/**
+	 * The feature id for the '<em><b>Collection</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__COLLECTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 8;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__TYPE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 9;
+
+	/**
+	 * The feature id for the '<em><b>Emf Ns URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__EMF_NS_URI = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 10;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__TYPE_QUALIFIED_NAME = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 11;
+
+	/**
+	 * The feature id for the '<em><b>Columns</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__COLUMNS = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 12;
+
+	/**
+	 * The feature id for the '<em><b>Sort Order</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__SORT_ORDER = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 13;
+
+	/**
+	 * The feature id for the '<em><b>Column Reordering Allowed</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__COLUMN_REORDERING_ALLOWED = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 14;
+
+	/**
+	 * The feature id for the '<em><b>Cell Style Generator</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__CELL_STYLE_GENERATOR = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 15;
+
+	/**
+	 * The feature id for the '<em><b>Filtering Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__FILTERING_VISIBLE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 16;
+
+	/**
+	 * The feature id for the '<em><b>Custom Filters</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__CUSTOM_FILTERS = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 17;
+
+	/**
+	 * The feature id for the '<em><b>Headers</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__HEADERS = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 18;
+
+	/**
+	 * The feature id for the '<em><b>Header Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__HEADER_VISIBLE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 19;
+
+	/**
+	 * The feature id for the '<em><b>Footers</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__FOOTERS = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 20;
+
+	/**
+	 * The feature id for the '<em><b>Footer Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__FOOTER_VISIBLE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 21;
+
+	/**
+	 * The feature id for the '<em><b>Editor Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__EDITOR_ENABLED = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 22;
+
+	/**
+	 * The feature id for the '<em><b>Editor Cancel I1 8n Label Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 23;
+
+	/**
+	 * The feature id for the '<em><b>Editor Save I1 8n Label Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 24;
+
+	/**
+	 * The feature id for the '<em><b>Editor Saved</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID__EDITOR_SAVED = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 25;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 26;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridProvider <em>Provider</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridProvider()
+	 * @generated
+	 */
+	int CX_GRID_PROVIDER = 1;
+
+	/**
+	 * The number of structural features of the '<em>Provider</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PROVIDER_FEATURE_COUNT = 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow <em>Meta Row</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridMetaRow()
+	 * @generated
+	 */
+	int CX_GRID_META_ROW = 2;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_ROW__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_ROW__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_ROW__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_ROW__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Groupings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_ROW__GROUPINGS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Custom Cells</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_ROW__CUSTOM_CELLS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>Meta Row</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_ROW_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl <em>Header Row</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridHeaderRow()
+	 * @generated
+	 */
+	int CX_GRID_HEADER_ROW = 3;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HEADER_ROW__TAGS = CX_GRID_META_ROW__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HEADER_ROW__ID = CX_GRID_META_ROW__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HEADER_ROW__NAME = CX_GRID_META_ROW__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HEADER_ROW__PROPERTIES = CX_GRID_META_ROW__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Groupings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HEADER_ROW__GROUPINGS = CX_GRID_META_ROW__GROUPINGS;
+
+	/**
+	 * The feature id for the '<em><b>Custom Cells</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HEADER_ROW__CUSTOM_CELLS = CX_GRID_META_ROW__CUSTOM_CELLS;
+
+	/**
+	 * The number of structural features of the '<em>Header Row</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HEADER_ROW_FEATURE_COUNT = CX_GRID_META_ROW_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl <em>Footer Row</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridFooterRow()
+	 * @generated
+	 */
+	int CX_GRID_FOOTER_ROW = 4;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FOOTER_ROW__TAGS = CX_GRID_META_ROW__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FOOTER_ROW__ID = CX_GRID_META_ROW__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FOOTER_ROW__NAME = CX_GRID_META_ROW__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FOOTER_ROW__PROPERTIES = CX_GRID_META_ROW__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Groupings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FOOTER_ROW__GROUPINGS = CX_GRID_META_ROW__GROUPINGS;
+
+	/**
+	 * The feature id for the '<em><b>Custom Cells</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FOOTER_ROW__CUSTOM_CELLS = CX_GRID_META_ROW__CUSTOM_CELLS;
+
+	/**
+	 * The number of structural features of the '<em>Footer Row</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FOOTER_ROW_FEATURE_COUNT = CX_GRID_META_ROW_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl <em>Filter Row</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridFilterRow()
+	 * @generated
+	 */
+	int CX_GRID_FILTER_ROW = 5;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FILTER_ROW__TAGS = CX_GRID_META_ROW__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FILTER_ROW__ID = CX_GRID_META_ROW__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FILTER_ROW__NAME = CX_GRID_META_ROW__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FILTER_ROW__PROPERTIES = CX_GRID_META_ROW__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Groupings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FILTER_ROW__GROUPINGS = CX_GRID_META_ROW__GROUPINGS;
+
+	/**
+	 * The feature id for the '<em><b>Custom Cells</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FILTER_ROW__CUSTOM_CELLS = CX_GRID_META_ROW__CUSTOM_CELLS;
+
+	/**
+	 * The number of structural features of the '<em>Filter Row</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_FILTER_ROW_FEATURE_COUNT = CX_GRID_META_ROW_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl <em>Groupable</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridGroupable()
+	 * @generated
+	 */
+	int CX_GRID_GROUPABLE = 6;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPABLE__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPABLE__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPABLE__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPABLE__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The number of structural features of the '<em>Groupable</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPABLE_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl <em>Meta Cell</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridMetaCell()
+	 * @generated
+	 */
+	int CX_GRID_META_CELL = 7;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Target</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__TARGET = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__LABEL = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__LABEL_I1_8N_KEY = CoreModelPackage.YELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Use HTML</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__USE_HTML = CoreModelPackage.YELEMENT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Element</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL__ELEMENT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>Meta Cell</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_META_CELL_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 5;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl <em>Grouped Cell</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridGroupedCell()
+	 * @generated
+	 */
+	int CX_GRID_GROUPED_CELL = 8;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__TAGS = CX_GRID_GROUPABLE__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__ID = CX_GRID_GROUPABLE__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__NAME = CX_GRID_GROUPABLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__PROPERTIES = CX_GRID_GROUPABLE__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Groupables</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__GROUPABLES = CX_GRID_GROUPABLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__LABEL = CX_GRID_GROUPABLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY = CX_GRID_GROUPABLE_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Use HTML</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL__USE_HTML = CX_GRID_GROUPABLE_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>Grouped Cell</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_GROUPED_CELL_FEATURE_COUNT = CX_GRID_GROUPABLE_FEATURE_COUNT + 4;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl <em>Column</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridColumn()
+	 * @generated
+	 */
+	int CX_GRID_COLUMN = 9;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__TAGS = CX_GRID_GROUPABLE__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__ID = CX_GRID_GROUPABLE__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__NAME = CX_GRID_GROUPABLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__PROPERTIES = CX_GRID_GROUPABLE__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Property Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__PROPERTY_ID = CX_GRID_GROUPABLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__LABEL = CX_GRID_GROUPABLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__LABEL_I1_8N_KEY = CX_GRID_GROUPABLE_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__EDITABLE = CX_GRID_GROUPABLE_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__CONVERTER = CX_GRID_GROUPABLE_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Renderer</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__RENDERER = CX_GRID_GROUPABLE_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Editor Field</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__EDITOR_FIELD = CX_GRID_GROUPABLE_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Search Field</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__SEARCH_FIELD = CX_GRID_GROUPABLE_FEATURE_COUNT + 7;
+
+	/**
+	 * The feature id for the '<em><b>Header Caption</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__HEADER_CAPTION = CX_GRID_GROUPABLE_FEATURE_COUNT + 8;
+
+	/**
+	 * The feature id for the '<em><b>Header Caption I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY = CX_GRID_GROUPABLE_FEATURE_COUNT + 9;
+
+	/**
+	 * The feature id for the '<em><b>Expand Ratio</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__EXPAND_RATIO = CX_GRID_GROUPABLE_FEATURE_COUNT + 10;
+
+	/**
+	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__HIDDEN = CX_GRID_GROUPABLE_FEATURE_COUNT + 11;
+
+	/**
+	 * The feature id for the '<em><b>Hideable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__HIDEABLE = CX_GRID_GROUPABLE_FEATURE_COUNT + 12;
+
+	/**
+	 * The feature id for the '<em><b>Sortable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__SORTABLE = CX_GRID_GROUPABLE_FEATURE_COUNT + 13;
+
+	/**
+	 * The feature id for the '<em><b>Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__PROPERTY_PATH = CX_GRID_GROUPABLE_FEATURE_COUNT + 14;
+
+	/**
+	 * The feature id for the '<em><b>Width</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__WIDTH = CX_GRID_GROUPABLE_FEATURE_COUNT + 15;
+
+	/**
+	 * The feature id for the '<em><b>Min Width Pixels</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__MIN_WIDTH_PIXELS = CX_GRID_GROUPABLE_FEATURE_COUNT + 16;
+
+	/**
+	 * The feature id for the '<em><b>Max Width Pixels</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__MAX_WIDTH_PIXELS = CX_GRID_GROUPABLE_FEATURE_COUNT + 17;
+
+	/**
+	 * The feature id for the '<em><b>Used In Meta Cells</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__USED_IN_META_CELLS = CX_GRID_GROUPABLE_FEATURE_COUNT + 18;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__TYPE = CX_GRID_GROUPABLE_FEATURE_COUNT + 19;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN__TYPE_QUALIFIED_NAME = CX_GRID_GROUPABLE_FEATURE_COUNT + 20;
+
+	/**
+	 * The number of structural features of the '<em>Column</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_COLUMN_FEATURE_COUNT = CX_GRID_GROUPABLE_FEATURE_COUNT + 21;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl <em>Cell Style Generator</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridCellStyleGenerator()
+	 * @generated
+	 */
+	int CX_GRID_CELL_STYLE_GENERATOR = 10;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_CELL_STYLE_GENERATOR__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_CELL_STYLE_GENERATOR__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_CELL_STYLE_GENERATOR__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The number of structural features of the '<em>Cell Style Generator</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_CELL_STYLE_GENERATOR_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridDelegateCellStyleGeneratorImpl <em>Delegate Cell Style Generator</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridDelegateCellStyleGeneratorImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridDelegateCellStyleGenerator()
+	 * @generated
+	 */
+	int CX_GRID_DELEGATE_CELL_STYLE_GENERATOR = 11;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__TAGS = CX_GRID_CELL_STYLE_GENERATOR__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__ID = CX_GRID_CELL_STYLE_GENERATOR__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__NAME = CX_GRID_CELL_STYLE_GENERATOR__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__PROPERTIES = CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Delegate Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID = CX_GRID_CELL_STYLE_GENERATOR_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Delegate Cell Style Generator</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_CELL_STYLE_GENERATOR_FEATURE_COUNT = CX_GRID_CELL_STYLE_GENERATOR_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl <em>Sortable</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridSortable()
+	 * @generated
+	 */
+	int CX_GRID_SORTABLE = 12;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_SORTABLE__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_SORTABLE__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_SORTABLE__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_SORTABLE__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Descending</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_SORTABLE__DESCENDING = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Column</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_SORTABLE__COLUMN = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>Sortable</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_SORTABLE_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid <em>Cx Grid</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid
+	 * @generated
+	 */
+	EClass getCxGrid();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionType <em>Selection Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Selection Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionType()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_SelectionType();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionEventTopic <em>Selection Event Topic</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Selection Event Topic</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelectionEventTopic()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_SelectionEventTopic();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelection <em>Selection</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Selection</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getSelection()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_Selection();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getMultiSelection <em>Multi Selection</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute list '<em>Multi Selection</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getMultiSelection()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_MultiSelection();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getCollection <em>Collection</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute list '<em>Collection</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getCollection()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_Collection();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getType()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_Type();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEmfNsURI <em>Emf Ns URI</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Emf Ns URI</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getEmfNsURI()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_EmfNsURI();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getTypeQualifiedName()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isEditorEnabled <em>Editor Enabled</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Editor Enabled</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#isEditorEnabled()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_EditorEnabled();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getCellStyleGenerator <em>Cell Style Generator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Cell Style Generator</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getCellStyleGenerator()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EReference getCxGrid_CellStyleGenerator();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isFilteringVisible <em>Filtering Visible</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Filtering Visible</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#isFilteringVisible()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_FilteringVisible();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isCustomFilters <em>Custom Filters</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Custom Filters</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#isCustomFilters()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_CustomFilters();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getHeaders <em>Headers</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Headers</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getHeaders()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EReference getCxGrid_Headers();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getColumns <em>Columns</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Columns</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getColumns()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EReference getCxGrid_Columns();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getSortOrder <em>Sort Order</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Sort Order</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getSortOrder()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EReference getCxGrid_SortOrder();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isColumnReorderingAllowed <em>Column Reordering Allowed</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Column Reordering Allowed</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#isColumnReorderingAllowed()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_ColumnReorderingAllowed();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isFooterVisible <em>Footer Visible</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Footer Visible</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#isFooterVisible()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_FooterVisible();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#isHeaderVisible <em>Header Visible</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Header Visible</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#isHeaderVisible()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_HeaderVisible();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getFooters <em>Footers</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Footers</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getFooters()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EReference getCxGrid_Footers();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorCancelI18nLabelKey <em>Editor Cancel I1 8n Label Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Editor Cancel I1 8n Label Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorCancelI18nLabelKey()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_EditorCancelI18nLabelKey();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaveI18nLabelKey <em>Editor Save I1 8n Label Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Editor Save I1 8n Label Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaveI18nLabelKey()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_EditorSaveI18nLabelKey();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaved <em>Editor Saved</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Editor Saved</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#getEditorSaved()
+	 * @see #getCxGrid()
+	 * @generated
+	 */
+	EAttribute getCxGrid_EditorSaved();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridProvider <em>Provider</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Provider</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider
+	 * @generated
+	 */
+	EClass getCxGridProvider();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow <em>Meta Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Meta Row</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow
+	 * @generated
+	 */
+	EClass getCxGridMetaRow();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow#getGroupings <em>Groupings</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Groupings</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow#getGroupings()
+	 * @see #getCxGridMetaRow()
+	 * @generated
+	 */
+	EReference getCxGridMetaRow_Groupings();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow#getCustomCells <em>Custom Cells</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Custom Cells</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow#getCustomCells()
+	 * @see #getCxGridMetaRow()
+	 * @generated
+	 */
+	EReference getCxGridMetaRow_CustomCells();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow <em>Header Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Header Row</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow
+	 * @generated
+	 */
+	EClass getCxGridHeaderRow();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow <em>Footer Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Footer Row</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow
+	 * @generated
+	 */
+	EClass getCxGridFooterRow();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow <em>Filter Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Filter Row</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow
+	 * @generated
+	 */
+	EClass getCxGridFilterRow();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupable <em>Groupable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Groupable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupable
+	 * @generated
+	 */
+	EClass getCxGridGroupable();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell <em>Meta Cell</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Meta Cell</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell
+	 * @generated
+	 */
+	EClass getCxGridMetaCell();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getTarget <em>Target</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Target</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getTarget()
+	 * @see #getCxGridMetaCell()
+	 * @generated
+	 */
+	EReference getCxGridMetaCell_Target();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabel <em>Label</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabel()
+	 * @see #getCxGridMetaCell()
+	 * @generated
+	 */
+	EAttribute getCxGridMetaCell_Label();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabelI18nKey <em>Label I1 8n Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label I1 8n Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getLabelI18nKey()
+	 * @see #getCxGridMetaCell()
+	 * @generated
+	 */
+	EAttribute getCxGridMetaCell_LabelI18nKey();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#isUseHTML <em>Use HTML</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Use HTML</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#isUseHTML()
+	 * @see #getCxGridMetaCell()
+	 * @generated
+	 */
+	EAttribute getCxGridMetaCell_UseHTML();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getElement <em>Element</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Element</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell#getElement()
+	 * @see #getCxGridMetaCell()
+	 * @generated
+	 */
+	EReference getCxGridMetaCell_Element();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell <em>Grouped Cell</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Grouped Cell</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell
+	 * @generated
+	 */
+	EClass getCxGridGroupedCell();
+
+	/**
+	 * Returns the meta object for the reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getGroupables <em>Groupables</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference list '<em>Groupables</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getGroupables()
+	 * @see #getCxGridGroupedCell()
+	 * @generated
+	 */
+	EReference getCxGridGroupedCell_Groupables();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabel <em>Label</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabel()
+	 * @see #getCxGridGroupedCell()
+	 * @generated
+	 */
+	EAttribute getCxGridGroupedCell_Label();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabelI18nKey <em>Label I1 8n Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label I1 8n Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#getLabelI18nKey()
+	 * @see #getCxGridGroupedCell()
+	 * @generated
+	 */
+	EAttribute getCxGridGroupedCell_LabelI18nKey();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#isUseHTML <em>Use HTML</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Use HTML</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell#isUseHTML()
+	 * @see #getCxGridGroupedCell()
+	 * @generated
+	 */
+	EAttribute getCxGridGroupedCell_UseHTML();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn <em>Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Column</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn
+	 * @generated
+	 */
+	EClass getCxGridColumn();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyId <em>Property Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Property Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyId()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_PropertyId();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getConverter <em>Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getConverter()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EReference getCxGridColumn_Converter();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getRenderer <em>Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getRenderer()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EReference getCxGridColumn_Renderer();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getEditorField <em>Editor Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Editor Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getEditorField()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EReference getCxGridColumn_EditorField();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getSearchField <em>Search Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Search Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getSearchField()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EReference getCxGridColumn_SearchField();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaption <em>Header Caption</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Header Caption</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaption()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_HeaderCaption();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaptionI18nKey <em>Header Caption I1 8n Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Header Caption I1 8n Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getHeaderCaptionI18nKey()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_HeaderCaptionI18nKey();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getExpandRatio <em>Expand Ratio</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Expand Ratio</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getExpandRatio()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_ExpandRatio();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHidden <em>Hidden</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Hidden</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHidden()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_Hidden();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHideable <em>Hideable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Hideable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isHideable()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_Hideable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isSortable <em>Sortable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Sortable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isSortable()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_Sortable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyPath <em>Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getPropertyPath()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_PropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getWidth <em>Width</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Width</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getWidth()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_Width();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabel <em>Label</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabel()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_Label();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabelI18nKey <em>Label I1 8n Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label I1 8n Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getLabelI18nKey()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_LabelI18nKey();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isEditable <em>Editable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Editable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#isEditable()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_Editable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMinWidthPixels <em>Min Width Pixels</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Min Width Pixels</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMinWidthPixels()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_MinWidthPixels();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMaxWidthPixels <em>Max Width Pixels</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Max Width Pixels</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getMaxWidthPixels()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_MaxWidthPixels();
+
+	/**
+	 * Returns the meta object for the reference list '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getUsedInMetaCells <em>Used In Meta Cells</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference list '<em>Used In Meta Cells</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getUsedInMetaCells()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EReference getCxGridColumn_UsedInMetaCells();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getType()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_Type();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn#getTypeQualifiedName()
+	 * @see #getCxGridColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridColumn_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator <em>Cell Style Generator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cell Style Generator</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator
+	 * @generated
+	 */
+	EClass getCxGridCellStyleGenerator();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator <em>Delegate Cell Style Generator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Delegate Cell Style Generator</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator
+	 * @generated
+	 */
+	EClass getCxGridDelegateCellStyleGenerator();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator#getDelegateId <em>Delegate Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Delegate Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator#getDelegateId()
+	 * @see #getCxGridDelegateCellStyleGenerator()
+	 * @generated
+	 */
+	EAttribute getCxGridDelegateCellStyleGenerator_DelegateId();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable <em>Sortable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Sortable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridSortable
+	 * @generated
+	 */
+	EClass getCxGridSortable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable#isDescending <em>Descending</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Descending</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridSortable#isDescending()
+	 * @see #getCxGridSortable()
+	 * @generated
+	 */
+	EAttribute getCxGridSortable_Descending();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable#getColumn <em>Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Column</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridSortable#getColumn()
+	 * @see #getCxGridSortable()
+	 * @generated
+	 */
+	EReference getCxGridSortable_Column();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	CxGridFactory getCxGridFactory();
+
+	/**
+	 * <!-- begin-user-doc --> Defines literals for the meta objects that
+	 * represent
+	 * <ul>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl <em>Cx Grid</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGrid()
+		 * @generated
+		 */
+		EClass CX_GRID = eINSTANCE.getCxGrid();
+
+		/**
+		 * The meta object literal for the '<em><b>Selection Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__SELECTION_TYPE = eINSTANCE.getCxGrid_SelectionType();
+
+		/**
+		 * The meta object literal for the '<em><b>Selection Event Topic</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__SELECTION_EVENT_TOPIC = eINSTANCE.getCxGrid_SelectionEventTopic();
+
+		/**
+		 * The meta object literal for the '<em><b>Selection</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__SELECTION = eINSTANCE.getCxGrid_Selection();
+
+		/**
+		 * The meta object literal for the '<em><b>Multi Selection</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__MULTI_SELECTION = eINSTANCE.getCxGrid_MultiSelection();
+
+		/**
+		 * The meta object literal for the '<em><b>Collection</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__COLLECTION = eINSTANCE.getCxGrid_Collection();
+
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__TYPE = eINSTANCE.getCxGrid_Type();
+
+		/**
+		 * The meta object literal for the '<em><b>Emf Ns URI</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__EMF_NS_URI = eINSTANCE.getCxGrid_EmfNsURI();
+
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__TYPE_QUALIFIED_NAME = eINSTANCE.getCxGrid_TypeQualifiedName();
+
+		/**
+		 * The meta object literal for the '<em><b>Editor Enabled</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__EDITOR_ENABLED = eINSTANCE.getCxGrid_EditorEnabled();
+
+		/**
+		 * The meta object literal for the '<em><b>Cell Style Generator</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID__CELL_STYLE_GENERATOR = eINSTANCE.getCxGrid_CellStyleGenerator();
+
+		/**
+		 * The meta object literal for the '<em><b>Filtering Visible</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__FILTERING_VISIBLE = eINSTANCE.getCxGrid_FilteringVisible();
+
+		/**
+		 * The meta object literal for the '<em><b>Custom Filters</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__CUSTOM_FILTERS = eINSTANCE.getCxGrid_CustomFilters();
+
+		/**
+		 * The meta object literal for the '<em><b>Headers</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID__HEADERS = eINSTANCE.getCxGrid_Headers();
+
+		/**
+		 * The meta object literal for the '<em><b>Columns</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID__COLUMNS = eINSTANCE.getCxGrid_Columns();
+
+		/**
+		 * The meta object literal for the '<em><b>Sort Order</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID__SORT_ORDER = eINSTANCE.getCxGrid_SortOrder();
+
+		/**
+		 * The meta object literal for the '<em><b>Column Reordering Allowed</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__COLUMN_REORDERING_ALLOWED = eINSTANCE.getCxGrid_ColumnReorderingAllowed();
+
+		/**
+		 * The meta object literal for the '<em><b>Footer Visible</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__FOOTER_VISIBLE = eINSTANCE.getCxGrid_FooterVisible();
+
+		/**
+		 * The meta object literal for the '<em><b>Header Visible</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__HEADER_VISIBLE = eINSTANCE.getCxGrid_HeaderVisible();
+
+		/**
+		 * The meta object literal for the '<em><b>Footers</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID__FOOTERS = eINSTANCE.getCxGrid_Footers();
+
+		/**
+		 * The meta object literal for the '<em><b>Editor Cancel I1 8n Label Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY = eINSTANCE.getCxGrid_EditorCancelI18nLabelKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Editor Save I1 8n Label Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY = eINSTANCE.getCxGrid_EditorSaveI18nLabelKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Editor Saved</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID__EDITOR_SAVED = eINSTANCE.getCxGrid_EditorSaved();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridProvider <em>Provider</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridProvider()
+		 * @generated
+		 */
+		EClass CX_GRID_PROVIDER = eINSTANCE.getCxGridProvider();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow <em>Meta Row</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridMetaRow()
+		 * @generated
+		 */
+		EClass CX_GRID_META_ROW = eINSTANCE.getCxGridMetaRow();
+
+		/**
+		 * The meta object literal for the '<em><b>Groupings</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_META_ROW__GROUPINGS = eINSTANCE.getCxGridMetaRow_Groupings();
+
+		/**
+		 * The meta object literal for the '<em><b>Custom Cells</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_META_ROW__CUSTOM_CELLS = eINSTANCE.getCxGridMetaRow_CustomCells();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl <em>Header Row</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridHeaderRow()
+		 * @generated
+		 */
+		EClass CX_GRID_HEADER_ROW = eINSTANCE.getCxGridHeaderRow();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl <em>Footer Row</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridFooterRow()
+		 * @generated
+		 */
+		EClass CX_GRID_FOOTER_ROW = eINSTANCE.getCxGridFooterRow();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl <em>Filter Row</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridFilterRow()
+		 * @generated
+		 */
+		EClass CX_GRID_FILTER_ROW = eINSTANCE.getCxGridFilterRow();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl <em>Groupable</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridGroupable()
+		 * @generated
+		 */
+		EClass CX_GRID_GROUPABLE = eINSTANCE.getCxGridGroupable();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl <em>Meta Cell</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridMetaCell()
+		 * @generated
+		 */
+		EClass CX_GRID_META_CELL = eINSTANCE.getCxGridMetaCell();
+
+		/**
+		 * The meta object literal for the '<em><b>Target</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_META_CELL__TARGET = eINSTANCE.getCxGridMetaCell_Target();
+
+		/**
+		 * The meta object literal for the '<em><b>Label</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_META_CELL__LABEL = eINSTANCE.getCxGridMetaCell_Label();
+
+		/**
+		 * The meta object literal for the '<em><b>Label I1 8n Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_META_CELL__LABEL_I1_8N_KEY = eINSTANCE.getCxGridMetaCell_LabelI18nKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Use HTML</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_META_CELL__USE_HTML = eINSTANCE.getCxGridMetaCell_UseHTML();
+
+		/**
+		 * The meta object literal for the '<em><b>Element</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_META_CELL__ELEMENT = eINSTANCE.getCxGridMetaCell_Element();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl <em>Grouped Cell</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridGroupedCell()
+		 * @generated
+		 */
+		EClass CX_GRID_GROUPED_CELL = eINSTANCE.getCxGridGroupedCell();
+
+		/**
+		 * The meta object literal for the '<em><b>Groupables</b></em>' reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_GROUPED_CELL__GROUPABLES = eINSTANCE.getCxGridGroupedCell_Groupables();
+
+		/**
+		 * The meta object literal for the '<em><b>Label</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_GROUPED_CELL__LABEL = eINSTANCE.getCxGridGroupedCell_Label();
+
+		/**
+		 * The meta object literal for the '<em><b>Label I1 8n Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY = eINSTANCE.getCxGridGroupedCell_LabelI18nKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Use HTML</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_GROUPED_CELL__USE_HTML = eINSTANCE.getCxGridGroupedCell_UseHTML();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl <em>Column</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridColumn()
+		 * @generated
+		 */
+		EClass CX_GRID_COLUMN = eINSTANCE.getCxGridColumn();
+
+		/**
+		 * The meta object literal for the '<em><b>Property Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__PROPERTY_ID = eINSTANCE.getCxGridColumn_PropertyId();
+
+		/**
+		 * The meta object literal for the '<em><b>Converter</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_COLUMN__CONVERTER = eINSTANCE.getCxGridColumn_Converter();
+
+		/**
+		 * The meta object literal for the '<em><b>Renderer</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_COLUMN__RENDERER = eINSTANCE.getCxGridColumn_Renderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Editor Field</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_COLUMN__EDITOR_FIELD = eINSTANCE.getCxGridColumn_EditorField();
+
+		/**
+		 * The meta object literal for the '<em><b>Search Field</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_COLUMN__SEARCH_FIELD = eINSTANCE.getCxGridColumn_SearchField();
+
+		/**
+		 * The meta object literal for the '<em><b>Header Caption</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__HEADER_CAPTION = eINSTANCE.getCxGridColumn_HeaderCaption();
+
+		/**
+		 * The meta object literal for the '<em><b>Header Caption I1 8n Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY = eINSTANCE.getCxGridColumn_HeaderCaptionI18nKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Expand Ratio</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__EXPAND_RATIO = eINSTANCE.getCxGridColumn_ExpandRatio();
+
+		/**
+		 * The meta object literal for the '<em><b>Hidden</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__HIDDEN = eINSTANCE.getCxGridColumn_Hidden();
+
+		/**
+		 * The meta object literal for the '<em><b>Hideable</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__HIDEABLE = eINSTANCE.getCxGridColumn_Hideable();
+
+		/**
+		 * The meta object literal for the '<em><b>Sortable</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__SORTABLE = eINSTANCE.getCxGridColumn_Sortable();
+
+		/**
+		 * The meta object literal for the '<em><b>Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__PROPERTY_PATH = eINSTANCE.getCxGridColumn_PropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Width</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__WIDTH = eINSTANCE.getCxGridColumn_Width();
+
+		/**
+		 * The meta object literal for the '<em><b>Label</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__LABEL = eINSTANCE.getCxGridColumn_Label();
+
+		/**
+		 * The meta object literal for the '<em><b>Label I1 8n Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__LABEL_I1_8N_KEY = eINSTANCE.getCxGridColumn_LabelI18nKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Editable</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__EDITABLE = eINSTANCE.getCxGridColumn_Editable();
+
+		/**
+		 * The meta object literal for the '<em><b>Min Width Pixels</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__MIN_WIDTH_PIXELS = eINSTANCE.getCxGridColumn_MinWidthPixels();
+
+		/**
+		 * The meta object literal for the '<em><b>Max Width Pixels</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__MAX_WIDTH_PIXELS = eINSTANCE.getCxGridColumn_MaxWidthPixels();
+
+		/**
+		 * The meta object literal for the '<em><b>Used In Meta Cells</b></em>' reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_COLUMN__USED_IN_META_CELLS = eINSTANCE.getCxGridColumn_UsedInMetaCells();
+
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__TYPE = eINSTANCE.getCxGridColumn_Type();
+
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_COLUMN__TYPE_QUALIFIED_NAME = eINSTANCE.getCxGridColumn_TypeQualifiedName();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl <em>Cell Style Generator</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridCellStyleGenerator()
+		 * @generated
+		 */
+		EClass CX_GRID_CELL_STYLE_GENERATOR = eINSTANCE.getCxGridCellStyleGenerator();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridDelegateCellStyleGeneratorImpl <em>Delegate Cell Style Generator</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridDelegateCellStyleGeneratorImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridDelegateCellStyleGenerator()
+		 * @generated
+		 */
+		EClass CX_GRID_DELEGATE_CELL_STYLE_GENERATOR = eINSTANCE.getCxGridDelegateCellStyleGenerator();
+
+		/**
+		 * The meta object literal for the '<em><b>Delegate Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID = eINSTANCE.getCxGridDelegateCellStyleGenerator_DelegateId();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl <em>Sortable</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl#getCxGridSortable()
+		 * @generated
+		 */
+		EClass CX_GRID_SORTABLE = eINSTANCE.getCxGridSortable();
+
+		/**
+		 * The meta object literal for the '<em><b>Descending</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_SORTABLE__DESCENDING = eINSTANCE.getCxGridSortable_Descending();
+
+		/**
+		 * The meta object literal for the '<em><b>Column</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_SORTABLE__COLUMN = eINSTANCE.getCxGridSortable_Column();
+
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridProvider.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridProvider.java
new file mode 100644
index 0000000..db23eb7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridProvider.java
@@ -0,0 +1,37 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '
+ * <em><b>Provider</b></em>'. <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridProvider()
+ * @model interface="true" abstract="true"
+ * @generated
+ */
+public interface CxGridProvider extends EObject {
+	
+	/**
+	 * Returns the grid.
+	 *
+	 * @return the grid
+	 */
+	CxGrid getGrid();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridSortable.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridSortable.java
new file mode 100644
index 0000000..311b78b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/CxGridSortable.java
@@ -0,0 +1,91 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Sortable</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable#isDescending <em>Descending</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable#getColumn <em>Column</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridSortable()
+ * @model
+ * @generated
+ */
+public interface CxGridSortable extends YElement {
+	
+	/**
+	 * Returns the value of the '<em><b>Descending</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Descending</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Descending</em>' attribute.
+	 * @see #setDescending(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridSortable_Descending()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isDescending();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable#isDescending <em>Descending</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Descending</em>' attribute.
+	 * @see #isDescending()
+	 * @generated
+	 */
+	void setDescending(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Column</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Column</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Column</em>' reference.
+	 * @see #setColumn(CxGridColumn)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#getCxGridSortable_Column()
+	 * @model required="true"
+	 * @generated
+	 */
+	CxGridColumn getColumn();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable#getColumn <em>Column</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Column</em>' reference.
+	 * @see #getColumn()
+	 * @generated
+	 */
+	void setColumn(CxGridColumn value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridCellStyleGeneratorImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridCellStyleGeneratorImpl.java
new file mode 100644
index 0000000..d90c83f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridCellStyleGeneratorImpl.java
@@ -0,0 +1,370 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Cell Style Generator</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridCellStyleGeneratorImpl#getProperties <em>Properties</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public abstract class CxGridCellStyleGeneratorImpl extends
+		MinimalEObjectImpl.Container implements CxGridCellStyleGenerator {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridCellStyleGeneratorImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_CELL_STYLE_GENERATOR;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__TAGS:
+				return getTags();
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__ID:
+				return getId();
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__NAME:
+				return getName();
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__ID:
+				setId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__TAGS:
+				getTags().clear();
+				return;
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES:
+				getProperties().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridColumnImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridColumnImpl.java
new file mode 100644
index 0000000..89b58c9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridColumnImpl.java
@@ -0,0 +1,1472 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+import org.eclipse.osbp.ecview.core.common.model.core.YField;
+import org.eclipse.osbp.ecview.core.common.model.core.YHelperLayout;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YSearchField;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Column</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getPropertyId <em>Property Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#isEditable <em>Editable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getConverter <em>Converter</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getRenderer <em>Renderer</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getEditorField <em>Editor Field</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getSearchField <em>Search Field</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getHeaderCaption <em>Header Caption</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getHeaderCaptionI18nKey <em>Header Caption I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getExpandRatio <em>Expand Ratio</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#isHidden <em>Hidden</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#isHideable <em>Hideable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#isSortable <em>Sortable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getPropertyPath <em>Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getWidth <em>Width</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getMinWidthPixels <em>Min Width Pixels</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getMaxWidthPixels <em>Max Width Pixels</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getUsedInMetaCells <em>Used In Meta Cells</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridColumnImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridColumnImpl extends CxGridGroupableImpl implements
+		CxGridColumn {
+	
+	/**
+	 * The default value of the '{@link #getPropertyId() <em>Property Id</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getPropertyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String PROPERTY_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getPropertyId() <em>Property Id</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getPropertyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String propertyId = PROPERTY_ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected String label = LABEL_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_I1_8N_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String labelI18nKey = LABEL_I1_8N_KEY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isEditable() <em>Editable</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isEditable()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean EDITABLE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isEditable() <em>Editable</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isEditable()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean editable = EDITABLE_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getConverter() <em>Converter</em>}' containment reference.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getConverter()
+	 * @generated
+	 * @ordered
+	 */
+	protected YConverter converter;
+
+	/**
+	 * The cached value of the '{@link #getRenderer() <em>Renderer</em>}' containment reference.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getRenderer()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridRenderer renderer;
+
+	/**
+	 * The cached value of the '{@link #getEditorField() <em>Editor Field</em>}' containment reference.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getEditorField()
+	 * @generated
+	 * @ordered
+	 */
+	protected YField editorField;
+
+	/**
+	 * The cached value of the '{@link #getSearchField() <em>Search Field</em>}' containment reference.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getSearchField()
+	 * @generated
+	 * @ordered
+	 */
+	protected YSearchField searchField;
+
+	/**
+	 * The default value of the '{@link #getHeaderCaption() <em>Header Caption</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getHeaderCaption()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String HEADER_CAPTION_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getHeaderCaption() <em>Header Caption</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getHeaderCaption()
+	 * @generated
+	 * @ordered
+	 */
+	protected String headerCaption = HEADER_CAPTION_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getHeaderCaptionI18nKey() <em>Header Caption I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHeaderCaptionI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String HEADER_CAPTION_I1_8N_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getHeaderCaptionI18nKey() <em>Header Caption I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHeaderCaptionI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String headerCaptionI18nKey = HEADER_CAPTION_I1_8N_KEY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getExpandRatio() <em>Expand Ratio</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getExpandRatio()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int EXPAND_RATIO_EDEFAULT = -1;
+
+	/**
+	 * The cached value of the '{@link #getExpandRatio() <em>Expand Ratio</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getExpandRatio()
+	 * @generated
+	 * @ordered
+	 */
+	protected int expandRatio = EXPAND_RATIO_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isHidden() <em>Hidden</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isHidden()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean HIDDEN_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isHidden() <em>Hidden</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isHidden()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean hidden = HIDDEN_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isHideable() <em>Hideable</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isHideable()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean HIDEABLE_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isHideable() <em>Hideable</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isHideable()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean hideable = HIDEABLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isSortable() <em>Sortable</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isSortable()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean SORTABLE_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isSortable() <em>Sortable</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #isSortable()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean sortable = SORTABLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getPropertyPath() <em>Property Path</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getPropertyPath() <em>Property Path</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String propertyPath = PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getWidth() <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getWidth()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int WIDTH_EDEFAULT = -1;
+
+	/**
+	 * The cached value of the '{@link #getWidth() <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getWidth()
+	 * @generated
+	 * @ordered
+	 */
+	protected int width = WIDTH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMinWidthPixels() <em>Min Width Pixels</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getMinWidthPixels()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int MIN_WIDTH_PIXELS_EDEFAULT = -1;
+
+	/**
+	 * The cached value of the '{@link #getMinWidthPixels() <em>Min Width Pixels</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getMinWidthPixels()
+	 * @generated
+	 * @ordered
+	 */
+	protected int minWidthPixels = MIN_WIDTH_PIXELS_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMaxWidthPixels() <em>Max Width Pixels</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getMaxWidthPixels()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int MAX_WIDTH_PIXELS_EDEFAULT = -1;
+
+	/**
+	 * The cached value of the '{@link #getMaxWidthPixels() <em>Max Width Pixels</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getMaxWidthPixels()
+	 * @generated
+	 * @ordered
+	 */
+	protected int maxWidthPixels = MAX_WIDTH_PIXELS_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getUsedInMetaCells() <em>Used In Meta Cells</em>}' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUsedInMetaCells()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridMetaCell> usedInMetaCells;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridColumnImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_COLUMN;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getPropertyId()
+	 *         <em>Property Id</em>}' attribute
+	 * @generated
+	 */
+	public String getPropertyId() {
+		return propertyId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newPropertyId
+	 *            the new cached value of the '{@link #getPropertyId()
+	 *            <em>Property Id</em>}' attribute
+	 * @generated
+	 */
+	public void setPropertyId(String newPropertyId) {
+		String oldPropertyId = propertyId;
+		propertyId = newPropertyId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__PROPERTY_ID, oldPropertyId, propertyId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getConverter()
+	 *         <em>Converter</em>}' containment reference
+	 * @generated
+	 */
+	public YConverter getConverter() {
+		return converter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newConverter
+	 *            the new converter
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetConverter(YConverter newConverter,
+			NotificationChain msgs) {
+		YConverter oldConverter = converter;
+		converter = newConverter;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__CONVERTER, oldConverter, newConverter);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newConverter
+	 *            the new cached value of the '{@link #getConverter()
+	 *            <em>Converter</em>}' containment reference
+	 * @generated
+	 */
+	public void setConverter(YConverter newConverter) {
+		if (newConverter != converter) {
+			NotificationChain msgs = null;
+			if (converter != null)
+				msgs = ((InternalEObject)converter).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__CONVERTER, null, msgs);
+			if (newConverter != null)
+				msgs = ((InternalEObject)newConverter).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__CONVERTER, null, msgs);
+			msgs = basicSetConverter(newConverter, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__CONVERTER, newConverter, newConverter));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getRenderer() <em>Renderer</em>}
+	 *         ' containment reference
+	 * @generated
+	 */
+	public CxGridRenderer getRenderer() {
+		return renderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newRenderer
+	 *            the new renderer
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetRenderer(CxGridRenderer newRenderer,
+			NotificationChain msgs) {
+		CxGridRenderer oldRenderer = renderer;
+		renderer = newRenderer;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__RENDERER, oldRenderer, newRenderer);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newRenderer
+	 *            the new cached value of the '{@link #getRenderer()
+	 *            <em>Renderer</em>}' containment reference
+	 * @generated
+	 */
+	public void setRenderer(CxGridRenderer newRenderer) {
+		if (newRenderer != renderer) {
+			NotificationChain msgs = null;
+			if (renderer != null)
+				msgs = ((InternalEObject)renderer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__RENDERER, null, msgs);
+			if (newRenderer != null)
+				msgs = ((InternalEObject)newRenderer).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__RENDERER, null, msgs);
+			msgs = basicSetRenderer(newRenderer, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__RENDERER, newRenderer, newRenderer));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEditorField()
+	 *         <em>Editor Field</em>}' containment reference
+	 * @generated
+	 */
+	public YField getEditorField() {
+		return editorField;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditorField
+	 *            the new editor field
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetEditorField(YField newEditorField,
+			NotificationChain msgs) {
+		YField oldEditorField = editorField;
+		editorField = newEditorField;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD, oldEditorField, newEditorField);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditorField
+	 *            the new cached value of the '{@link #getEditorField()
+	 *            <em>Editor Field</em>}' containment reference
+	 * @generated
+	 */
+	public void setEditorField(YField newEditorField) {
+		if (newEditorField != editorField) {
+			NotificationChain msgs = null;
+			if (editorField != null)
+				msgs = ((InternalEObject)editorField).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD, null, msgs);
+			if (newEditorField != null)
+				msgs = ((InternalEObject)newEditorField).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD, null, msgs);
+			msgs = basicSetEditorField(newEditorField, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD, newEditorField, newEditorField));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSearchField()
+	 *         <em>Search Field</em>}' containment reference
+	 * @generated
+	 */
+	public YSearchField getSearchField() {
+		return searchField;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSearchField
+	 *            the new search field
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetSearchField(YSearchField newSearchField,
+			NotificationChain msgs) {
+		YSearchField oldSearchField = searchField;
+		searchField = newSearchField;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD, oldSearchField, newSearchField);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSearchField
+	 *            the new cached value of the '{@link #getSearchField()
+	 *            <em>Search Field</em>}' containment reference
+	 * @generated
+	 */
+	public void setSearchField(YSearchField newSearchField) {
+		if (newSearchField != searchField) {
+			NotificationChain msgs = null;
+			if (searchField != null)
+				msgs = ((InternalEObject)searchField).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD, null, msgs);
+			if (newSearchField != null)
+				msgs = ((InternalEObject)newSearchField).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD, null, msgs);
+			msgs = basicSetSearchField(newSearchField, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD, newSearchField, newSearchField));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getHeaderCaption()
+	 *         <em>Header Caption</em>}' attribute
+	 * @generated
+	 */
+	public String getHeaderCaption() {
+		return headerCaption;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHeaderCaption
+	 *            the new cached value of the '{@link #getHeaderCaption()
+	 *            <em>Header Caption</em>}' attribute
+	 * @generated
+	 */
+	public void setHeaderCaption(String newHeaderCaption) {
+		String oldHeaderCaption = headerCaption;
+		headerCaption = newHeaderCaption;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION, oldHeaderCaption, headerCaption));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getHeaderCaptionI18nKey()
+	 *         <em>Header Caption I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public String getHeaderCaptionI18nKey() {
+		return headerCaptionI18nKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHeaderCaptionI18nKey
+	 *            the new cached value of the '
+	 *            {@link #getHeaderCaptionI18nKey()
+	 *            <em>Header Caption I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public void setHeaderCaptionI18nKey(String newHeaderCaptionI18nKey) {
+		String oldHeaderCaptionI18nKey = headerCaptionI18nKey;
+		headerCaptionI18nKey = newHeaderCaptionI18nKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY, oldHeaderCaptionI18nKey, headerCaptionI18nKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getExpandRatio()
+	 *         <em>Expand Ratio</em>}' attribute
+	 * @generated
+	 */
+	public int getExpandRatio() {
+		return expandRatio;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newExpandRatio
+	 *            the new cached value of the '{@link #getExpandRatio()
+	 *            <em>Expand Ratio</em>}' attribute
+	 * @generated
+	 */
+	public void setExpandRatio(int newExpandRatio) {
+		int oldExpandRatio = expandRatio;
+		expandRatio = newExpandRatio;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__EXPAND_RATIO, oldExpandRatio, expandRatio));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isHidden() <em>Hidden</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isHidden() {
+		return hidden;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHidden
+	 *            the new cached value of the '{@link #isHidden()
+	 *            <em>Hidden</em>}' attribute
+	 * @generated
+	 */
+	public void setHidden(boolean newHidden) {
+		boolean oldHidden = hidden;
+		hidden = newHidden;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__HIDDEN, oldHidden, hidden));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isHideable() <em>Hideable</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isHideable() {
+		return hideable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHideable
+	 *            the new cached value of the '{@link #isHideable()
+	 *            <em>Hideable</em>}' attribute
+	 * @generated
+	 */
+	public void setHideable(boolean newHideable) {
+		boolean oldHideable = hideable;
+		hideable = newHideable;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__HIDEABLE, oldHideable, hideable));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isSortable() <em>Sortable</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isSortable() {
+		return sortable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSortable
+	 *            the new cached value of the '{@link #isSortable()
+	 *            <em>Sortable</em>}' attribute
+	 * @generated
+	 */
+	public void setSortable(boolean newSortable) {
+		boolean oldSortable = sortable;
+		sortable = newSortable;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__SORTABLE, oldSortable, sortable));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getPropertyPath()
+	 *         <em>Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getPropertyPath() {
+		return propertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newPropertyPath
+	 *            the new cached value of the '{@link #getPropertyPath()
+	 *            <em>Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setPropertyPath(String newPropertyPath) {
+		String oldPropertyPath = propertyPath;
+		propertyPath = newPropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__PROPERTY_PATH, oldPropertyPath, propertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getWidth() <em>Width</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public int getWidth() {
+		return width;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newWidth
+	 *            the new cached value of the '{@link #getWidth()
+	 *            <em>Width</em>}' attribute
+	 * @generated
+	 */
+	public void setWidth(int newWidth) {
+		int oldWidth = width;
+		width = newWidth;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__WIDTH, oldWidth, width));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabel() <em>Label</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabel
+	 *            the new cached value of the '{@link #getLabel()
+	 *            <em>Label</em>}' attribute
+	 * @generated
+	 */
+	public void setLabel(String newLabel) {
+		String oldLabel = label;
+		label = newLabel;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__LABEL, oldLabel, label));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabelI18nKey()
+	 *         <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public String getLabelI18nKey() {
+		return labelI18nKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabelI18nKey
+	 *            the new cached value of the '{@link #getLabelI18nKey()
+	 *            <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public void setLabelI18nKey(String newLabelI18nKey) {
+		String oldLabelI18nKey = labelI18nKey;
+		labelI18nKey = newLabelI18nKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__LABEL_I1_8N_KEY, oldLabelI18nKey, labelI18nKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isEditable() <em>Editable</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isEditable() {
+		return editable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditable
+	 *            the new cached value of the '{@link #isEditable()
+	 *            <em>Editable</em>}' attribute
+	 * @generated
+	 */
+	public void setEditable(boolean newEditable) {
+		boolean oldEditable = editable;
+		editable = newEditable;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__EDITABLE, oldEditable, editable));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getMinWidthPixels()
+	 *         <em>Min Width Pixels</em>}' attribute
+	 * @generated
+	 */
+	public int getMinWidthPixels() {
+		return minWidthPixels;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newMinWidthPixels
+	 *            the new cached value of the '{@link #getMinWidthPixels()
+	 *            <em>Min Width Pixels</em>}' attribute
+	 * @generated
+	 */
+	public void setMinWidthPixels(int newMinWidthPixels) {
+		int oldMinWidthPixels = minWidthPixels;
+		minWidthPixels = newMinWidthPixels;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__MIN_WIDTH_PIXELS, oldMinWidthPixels, minWidthPixels));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getMaxWidthPixels()
+	 *         <em>Max Width Pixels</em>}' attribute
+	 * @generated
+	 */
+	public int getMaxWidthPixels() {
+		return maxWidthPixels;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newMaxWidthPixels
+	 *            the new cached value of the '{@link #getMaxWidthPixels()
+	 *            <em>Max Width Pixels</em>}' attribute
+	 * @generated
+	 */
+	public void setMaxWidthPixels(int newMaxWidthPixels) {
+		int oldMaxWidthPixels = maxWidthPixels;
+		maxWidthPixels = newMaxWidthPixels;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__MAX_WIDTH_PIXELS, oldMaxWidthPixels, maxWidthPixels));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getUsedInMetaCells()
+	 *         <em>Used In Meta Cells</em>}' reference list
+	 * @generated
+	 */
+	public EList<CxGridMetaCell> getUsedInMetaCells() {
+		if (usedInMetaCells == null) {
+			usedInMetaCells = new EObjectWithInverseResolvingEList<CxGridMetaCell>(CxGridMetaCell.class, this, CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS, CxGridPackage.CX_GRID_META_CELL__TARGET);
+		}
+		return usedInMetaCells;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getType() <em>Type</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newType
+	 *            the new cached value of the '{@link #getType() <em>Type</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTypeQualifiedName()
+	 *         <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTypeQualifiedName
+	 *            the new cached value of the '{@link #getTypeQualifiedName()
+	 *            <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_COLUMN__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> Returns the layout which contains the editor
+	 * fields. <!-- end-user-doc -->
+	 *
+	 * @return the helper layout
+	 */
+	public YHelperLayout getHelperLayout() {
+		return getGrid() != null ? getGrid().createEditorFieldHelperLayout() : null;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getUsedInMetaCells()).basicAdd(otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_COLUMN__CONVERTER:
+				return basicSetConverter(null, msgs);
+			case CxGridPackage.CX_GRID_COLUMN__RENDERER:
+				return basicSetRenderer(null, msgs);
+			case CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD:
+				return basicSetEditorField(null, msgs);
+			case CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD:
+				return basicSetSearchField(null, msgs);
+			case CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS:
+				return ((InternalEList<?>)getUsedInMetaCells()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_ID:
+				return getPropertyId();
+			case CxGridPackage.CX_GRID_COLUMN__LABEL:
+				return getLabel();
+			case CxGridPackage.CX_GRID_COLUMN__LABEL_I1_8N_KEY:
+				return getLabelI18nKey();
+			case CxGridPackage.CX_GRID_COLUMN__EDITABLE:
+				return isEditable();
+			case CxGridPackage.CX_GRID_COLUMN__CONVERTER:
+				return getConverter();
+			case CxGridPackage.CX_GRID_COLUMN__RENDERER:
+				return getRenderer();
+			case CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD:
+				return getEditorField();
+			case CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD:
+				return getSearchField();
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION:
+				return getHeaderCaption();
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY:
+				return getHeaderCaptionI18nKey();
+			case CxGridPackage.CX_GRID_COLUMN__EXPAND_RATIO:
+				return getExpandRatio();
+			case CxGridPackage.CX_GRID_COLUMN__HIDDEN:
+				return isHidden();
+			case CxGridPackage.CX_GRID_COLUMN__HIDEABLE:
+				return isHideable();
+			case CxGridPackage.CX_GRID_COLUMN__SORTABLE:
+				return isSortable();
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_PATH:
+				return getPropertyPath();
+			case CxGridPackage.CX_GRID_COLUMN__WIDTH:
+				return getWidth();
+			case CxGridPackage.CX_GRID_COLUMN__MIN_WIDTH_PIXELS:
+				return getMinWidthPixels();
+			case CxGridPackage.CX_GRID_COLUMN__MAX_WIDTH_PIXELS:
+				return getMaxWidthPixels();
+			case CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS:
+				return getUsedInMetaCells();
+			case CxGridPackage.CX_GRID_COLUMN__TYPE:
+				return getType();
+			case CxGridPackage.CX_GRID_COLUMN__TYPE_QUALIFIED_NAME:
+				return getTypeQualifiedName();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_ID:
+				setPropertyId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__LABEL:
+				setLabel((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__LABEL_I1_8N_KEY:
+				setLabelI18nKey((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__EDITABLE:
+				setEditable((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__CONVERTER:
+				setConverter((YConverter)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__RENDERER:
+				setRenderer((CxGridRenderer)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD:
+				setEditorField((YField)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD:
+				setSearchField((YSearchField)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION:
+				setHeaderCaption((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY:
+				setHeaderCaptionI18nKey((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__EXPAND_RATIO:
+				setExpandRatio((Integer)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HIDDEN:
+				setHidden((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HIDEABLE:
+				setHideable((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__SORTABLE:
+				setSortable((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_PATH:
+				setPropertyPath((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__WIDTH:
+				setWidth((Integer)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__MIN_WIDTH_PIXELS:
+				setMinWidthPixels((Integer)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__MAX_WIDTH_PIXELS:
+				setMaxWidthPixels((Integer)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS:
+				getUsedInMetaCells().clear();
+				getUsedInMetaCells().addAll((Collection<? extends CxGridMetaCell>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__TYPE:
+				setType((Class<?>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_ID:
+				setPropertyId(PROPERTY_ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__LABEL:
+				setLabel(LABEL_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__LABEL_I1_8N_KEY:
+				setLabelI18nKey(LABEL_I1_8N_KEY_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__EDITABLE:
+				setEditable(EDITABLE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__CONVERTER:
+				setConverter((YConverter)null);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__RENDERER:
+				setRenderer((CxGridRenderer)null);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD:
+				setEditorField((YField)null);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD:
+				setSearchField((YSearchField)null);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION:
+				setHeaderCaption(HEADER_CAPTION_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY:
+				setHeaderCaptionI18nKey(HEADER_CAPTION_I1_8N_KEY_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__EXPAND_RATIO:
+				setExpandRatio(EXPAND_RATIO_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HIDDEN:
+				setHidden(HIDDEN_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__HIDEABLE:
+				setHideable(HIDEABLE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__SORTABLE:
+				setSortable(SORTABLE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_PATH:
+				setPropertyPath(PROPERTY_PATH_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__WIDTH:
+				setWidth(WIDTH_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__MIN_WIDTH_PIXELS:
+				setMinWidthPixels(MIN_WIDTH_PIXELS_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__MAX_WIDTH_PIXELS:
+				setMaxWidthPixels(MAX_WIDTH_PIXELS_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS:
+				getUsedInMetaCells().clear();
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__TYPE:
+				setType((Class<?>)null);
+				return;
+			case CxGridPackage.CX_GRID_COLUMN__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_ID:
+				return PROPERTY_ID_EDEFAULT == null ? propertyId != null : !PROPERTY_ID_EDEFAULT.equals(propertyId);
+			case CxGridPackage.CX_GRID_COLUMN__LABEL:
+				return LABEL_EDEFAULT == null ? label != null : !LABEL_EDEFAULT.equals(label);
+			case CxGridPackage.CX_GRID_COLUMN__LABEL_I1_8N_KEY:
+				return LABEL_I1_8N_KEY_EDEFAULT == null ? labelI18nKey != null : !LABEL_I1_8N_KEY_EDEFAULT.equals(labelI18nKey);
+			case CxGridPackage.CX_GRID_COLUMN__EDITABLE:
+				return editable != EDITABLE_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__CONVERTER:
+				return converter != null;
+			case CxGridPackage.CX_GRID_COLUMN__RENDERER:
+				return renderer != null;
+			case CxGridPackage.CX_GRID_COLUMN__EDITOR_FIELD:
+				return editorField != null;
+			case CxGridPackage.CX_GRID_COLUMN__SEARCH_FIELD:
+				return searchField != null;
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION:
+				return HEADER_CAPTION_EDEFAULT == null ? headerCaption != null : !HEADER_CAPTION_EDEFAULT.equals(headerCaption);
+			case CxGridPackage.CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY:
+				return HEADER_CAPTION_I1_8N_KEY_EDEFAULT == null ? headerCaptionI18nKey != null : !HEADER_CAPTION_I1_8N_KEY_EDEFAULT.equals(headerCaptionI18nKey);
+			case CxGridPackage.CX_GRID_COLUMN__EXPAND_RATIO:
+				return expandRatio != EXPAND_RATIO_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__HIDDEN:
+				return hidden != HIDDEN_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__HIDEABLE:
+				return hideable != HIDEABLE_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__SORTABLE:
+				return sortable != SORTABLE_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__PROPERTY_PATH:
+				return PROPERTY_PATH_EDEFAULT == null ? propertyPath != null : !PROPERTY_PATH_EDEFAULT.equals(propertyPath);
+			case CxGridPackage.CX_GRID_COLUMN__WIDTH:
+				return width != WIDTH_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__MIN_WIDTH_PIXELS:
+				return minWidthPixels != MIN_WIDTH_PIXELS_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__MAX_WIDTH_PIXELS:
+				return maxWidthPixels != MAX_WIDTH_PIXELS_EDEFAULT;
+			case CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS:
+				return usedInMetaCells != null && !usedInMetaCells.isEmpty();
+			case CxGridPackage.CX_GRID_COLUMN__TYPE:
+				return type != null;
+			case CxGridPackage.CX_GRID_COLUMN__TYPE_QUALIFIED_NAME:
+				return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (propertyId: ");
+		result.append(propertyId);
+		result.append(", label: ");
+		result.append(label);
+		result.append(", labelI18nKey: ");
+		result.append(labelI18nKey);
+		result.append(", editable: ");
+		result.append(editable);
+		result.append(", headerCaption: ");
+		result.append(headerCaption);
+		result.append(", headerCaptionI18nKey: ");
+		result.append(headerCaptionI18nKey);
+		result.append(", expandRatio: ");
+		result.append(expandRatio);
+		result.append(", hidden: ");
+		result.append(hidden);
+		result.append(", hideable: ");
+		result.append(hideable);
+		result.append(", sortable: ");
+		result.append(sortable);
+		result.append(", propertyPath: ");
+		result.append(propertyPath);
+		result.append(", width: ");
+		result.append(width);
+		result.append(", minWidthPixels: ");
+		result.append(minWidthPixels);
+		result.append(", maxWidthPixels: ");
+		result.append(maxWidthPixels);
+		result.append(", type: ");
+		result.append(type);
+		result.append(", typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(')');
+		return result.toString();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridDelegateCellStyleGeneratorImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridDelegateCellStyleGeneratorImpl.java
new file mode 100644
index 0000000..60778d7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridDelegateCellStyleGeneratorImpl.java
@@ -0,0 +1,196 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.emf.common.notify.Notification;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Delegate Cell Style Generator</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridDelegateCellStyleGeneratorImpl#getDelegateId <em>Delegate Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridDelegateCellStyleGeneratorImpl extends
+		CxGridCellStyleGeneratorImpl implements
+		CxGridDelegateCellStyleGenerator {
+	
+	/**
+	 * The default value of the '{@link #getDelegateId() <em>Delegate Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DELEGATE_ID_EDEFAULT = null;
+	/**
+	 * The cached value of the '{@link #getDelegateId() <em>Delegate Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String delegateId = DELEGATE_ID_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridDelegateCellStyleGeneratorImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDelegateId()
+	 *         <em>Delegate Id</em>}' attribute
+	 * @generated
+	 */
+	public String getDelegateId() {
+		return delegateId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDelegateId
+	 *            the new cached value of the '{@link #getDelegateId()
+	 *            <em>Delegate Id</em>}' attribute
+	 * @generated
+	 */
+	public void setDelegateId(String newDelegateId) {
+		String oldDelegateId = delegateId;
+		delegateId = newDelegateId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID, oldDelegateId, delegateId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID:
+				return getDelegateId();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID:
+				setDelegateId((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID:
+				setDelegateId(DELEGATE_ID_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID:
+				return DELEGATE_ID_EDEFAULT == null ? delegateId != null : !DELEGATE_ID_EDEFAULT.equals(delegateId);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (delegateId: ");
+		result.append(delegateId);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFactoryImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFactoryImpl.java
new file mode 100644
index 0000000..a9f62a4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFactoryImpl.java
@@ -0,0 +1,215 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.*;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridFactoryImpl extends EFactoryImpl implements CxGridFactory {
+	
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	public static CxGridFactory init() {
+		try {
+			CxGridFactory theCxGridFactory = (CxGridFactory)EPackage.Registry.INSTANCE.getEFactory(CxGridPackage.eNS_URI);
+			if (theCxGridFactory != null) {
+				return theCxGridFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new CxGridFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param eClass
+	 *            the e class
+	 * @return the e object
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case CxGridPackage.CX_GRID: return createCxGrid();
+			case CxGridPackage.CX_GRID_HEADER_ROW: return createCxGridHeaderRow();
+			case CxGridPackage.CX_GRID_FOOTER_ROW: return createCxGridFooterRow();
+			case CxGridPackage.CX_GRID_FILTER_ROW: return createCxGridFilterRow();
+			case CxGridPackage.CX_GRID_META_CELL: return createCxGridMetaCell();
+			case CxGridPackage.CX_GRID_GROUPED_CELL: return createCxGridGroupedCell();
+			case CxGridPackage.CX_GRID_COLUMN: return createCxGridColumn();
+			case CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR: return createCxGridDelegateCellStyleGenerator();
+			case CxGridPackage.CX_GRID_SORTABLE: return createCxGridSortable();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid
+	 * @generated
+	 */
+	public CxGrid createCxGrid() {
+		CxGridImpl cxGrid = new CxGridImpl();
+		return cxGrid;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid header row
+	 * @generated
+	 */
+	public CxGridHeaderRow createCxGridHeaderRow() {
+		CxGridHeaderRowImpl cxGridHeaderRow = new CxGridHeaderRowImpl();
+		return cxGridHeaderRow;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid footer row
+	 * @generated
+	 */
+	public CxGridFooterRow createCxGridFooterRow() {
+		CxGridFooterRowImpl cxGridFooterRow = new CxGridFooterRowImpl();
+		return cxGridFooterRow;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid filter row
+	 * @generated
+	 */
+	public CxGridFilterRow createCxGridFilterRow() {
+		CxGridFilterRowImpl cxGridFilterRow = new CxGridFilterRowImpl();
+		return cxGridFilterRow;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta cell
+	 * @generated
+	 */
+	public CxGridMetaCell createCxGridMetaCell() {
+		CxGridMetaCellImpl cxGridMetaCell = new CxGridMetaCellImpl();
+		return cxGridMetaCell;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid grouped cell
+	 * @generated
+	 */
+	public CxGridGroupedCell createCxGridGroupedCell() {
+		CxGridGroupedCellImpl cxGridGroupedCell = new CxGridGroupedCellImpl();
+		return cxGridGroupedCell;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column
+	 * @generated
+	 */
+	public CxGridColumn createCxGridColumn() {
+		CxGridColumnImpl cxGridColumn = new CxGridColumnImpl();
+		return cxGridColumn;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid delegate cell style generator
+	 * @generated
+	 */
+	public CxGridDelegateCellStyleGenerator createCxGridDelegateCellStyleGenerator() {
+		CxGridDelegateCellStyleGeneratorImpl cxGridDelegateCellStyleGenerator = new CxGridDelegateCellStyleGeneratorImpl();
+		return cxGridDelegateCellStyleGenerator;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid sortable
+	 * @generated
+	 */
+	public CxGridSortable createCxGridSortable() {
+		CxGridSortableImpl cxGridSortable = new CxGridSortableImpl();
+		return cxGridSortable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid package
+	 * @generated
+	 */
+	public CxGridPackage getCxGridPackage() {
+		return (CxGridPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the package
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static CxGridPackage getPackage() {
+		return CxGridPackage.eINSTANCE;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFilterRowImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFilterRowImpl.java
new file mode 100644
index 0000000..cb5e7cf
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFilterRowImpl.java
@@ -0,0 +1,452 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Filter Row</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl#getGroupings <em>Groupings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFilterRowImpl#getCustomCells <em>Custom Cells</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridFilterRowImpl extends MinimalEObjectImpl.Container implements CxGridFilterRow {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getGroupings() <em>Groupings</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGroupings()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridGroupedCell> groupings;
+
+	/**
+	 * The cached value of the '{@link #getCustomCells() <em>Custom Cells</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCustomCells()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridMetaCell> customCells;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridFilterRowImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_FILTER_ROW;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_FILTER_ROW__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_FILTER_ROW__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridPackage.CX_GRID_FILTER_ROW__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridPackage.CX_GRID_FILTER_ROW__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getGroupings()
+	 *         <em>Groupings</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridGroupedCell> getGroupings() {
+		if (groupings == null) {
+			groupings = new EObjectContainmentEList<CxGridGroupedCell>(CxGridGroupedCell.class, this, CxGridPackage.CX_GRID_FILTER_ROW__GROUPINGS);
+		}
+		return groupings;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCustomCells()
+	 *         <em>Custom Cells</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridMetaCell> getCustomCells() {
+		if (customCells == null) {
+			customCells = new EObjectContainmentEList<CxGridMetaCell>(CxGridMetaCell.class, this, CxGridPackage.CX_GRID_FILTER_ROW__CUSTOM_CELLS);
+		}
+		return customCells;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FILTER_ROW__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID_FILTER_ROW__GROUPINGS:
+				return ((InternalEList<?>)getGroupings()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID_FILTER_ROW__CUSTOM_CELLS:
+				return ((InternalEList<?>)getCustomCells()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FILTER_ROW__TAGS:
+				return getTags();
+			case CxGridPackage.CX_GRID_FILTER_ROW__ID:
+				return getId();
+			case CxGridPackage.CX_GRID_FILTER_ROW__NAME:
+				return getName();
+			case CxGridPackage.CX_GRID_FILTER_ROW__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case CxGridPackage.CX_GRID_FILTER_ROW__GROUPINGS:
+				return getGroupings();
+			case CxGridPackage.CX_GRID_FILTER_ROW__CUSTOM_CELLS:
+				return getCustomCells();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FILTER_ROW__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__ID:
+				setId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__GROUPINGS:
+				getGroupings().clear();
+				getGroupings().addAll((Collection<? extends CxGridGroupedCell>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__CUSTOM_CELLS:
+				getCustomCells().clear();
+				getCustomCells().addAll((Collection<? extends CxGridMetaCell>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FILTER_ROW__TAGS:
+				getTags().clear();
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__PROPERTIES:
+				getProperties().clear();
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__GROUPINGS:
+				getGroupings().clear();
+				return;
+			case CxGridPackage.CX_GRID_FILTER_ROW__CUSTOM_CELLS:
+				getCustomCells().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FILTER_ROW__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridPackage.CX_GRID_FILTER_ROW__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridPackage.CX_GRID_FILTER_ROW__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridPackage.CX_GRID_FILTER_ROW__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case CxGridPackage.CX_GRID_FILTER_ROW__GROUPINGS:
+				return groupings != null && !groupings.isEmpty();
+			case CxGridPackage.CX_GRID_FILTER_ROW__CUSTOM_CELLS:
+				return customCells != null && !customCells.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFooterRowImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFooterRowImpl.java
new file mode 100644
index 0000000..22f2773
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridFooterRowImpl.java
@@ -0,0 +1,452 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Footer Row</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl#getGroupings <em>Groupings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridFooterRowImpl#getCustomCells <em>Custom Cells</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridFooterRowImpl extends MinimalEObjectImpl.Container implements CxGridFooterRow {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getGroupings() <em>Groupings</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGroupings()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridGroupedCell> groupings;
+
+	/**
+	 * The cached value of the '{@link #getCustomCells() <em>Custom Cells</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCustomCells()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridMetaCell> customCells;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridFooterRowImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_FOOTER_ROW;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_FOOTER_ROW__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_FOOTER_ROW__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridPackage.CX_GRID_FOOTER_ROW__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridPackage.CX_GRID_FOOTER_ROW__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getGroupings()
+	 *         <em>Groupings</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridGroupedCell> getGroupings() {
+		if (groupings == null) {
+			groupings = new EObjectContainmentEList<CxGridGroupedCell>(CxGridGroupedCell.class, this, CxGridPackage.CX_GRID_FOOTER_ROW__GROUPINGS);
+		}
+		return groupings;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCustomCells()
+	 *         <em>Custom Cells</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridMetaCell> getCustomCells() {
+		if (customCells == null) {
+			customCells = new EObjectContainmentEList<CxGridMetaCell>(CxGridMetaCell.class, this, CxGridPackage.CX_GRID_FOOTER_ROW__CUSTOM_CELLS);
+		}
+		return customCells;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FOOTER_ROW__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID_FOOTER_ROW__GROUPINGS:
+				return ((InternalEList<?>)getGroupings()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID_FOOTER_ROW__CUSTOM_CELLS:
+				return ((InternalEList<?>)getCustomCells()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FOOTER_ROW__TAGS:
+				return getTags();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__ID:
+				return getId();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__NAME:
+				return getName();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__GROUPINGS:
+				return getGroupings();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__CUSTOM_CELLS:
+				return getCustomCells();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FOOTER_ROW__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__ID:
+				setId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__GROUPINGS:
+				getGroupings().clear();
+				getGroupings().addAll((Collection<? extends CxGridGroupedCell>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__CUSTOM_CELLS:
+				getCustomCells().clear();
+				getCustomCells().addAll((Collection<? extends CxGridMetaCell>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FOOTER_ROW__TAGS:
+				getTags().clear();
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__PROPERTIES:
+				getProperties().clear();
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__GROUPINGS:
+				getGroupings().clear();
+				return;
+			case CxGridPackage.CX_GRID_FOOTER_ROW__CUSTOM_CELLS:
+				getCustomCells().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_FOOTER_ROW__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridPackage.CX_GRID_FOOTER_ROW__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridPackage.CX_GRID_FOOTER_ROW__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__GROUPINGS:
+				return groupings != null && !groupings.isEmpty();
+			case CxGridPackage.CX_GRID_FOOTER_ROW__CUSTOM_CELLS:
+				return customCells != null && !customCells.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridGroupableImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridGroupableImpl.java
new file mode 100644
index 0000000..53ee4d4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridGroupableImpl.java
@@ -0,0 +1,373 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupable;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Groupable</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupableImpl#getProperties <em>Properties</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public abstract class CxGridGroupableImpl extends MinimalEObjectImpl.Container implements CxGridGroupable {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridGroupableImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_GROUPABLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_GROUPABLE__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_GROUPABLE__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridPackage.CX_GRID_GROUPABLE__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridPackage.CX_GRID_GROUPABLE__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPABLE__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPABLE__TAGS:
+				return getTags();
+			case CxGridPackage.CX_GRID_GROUPABLE__ID:
+				return getId();
+			case CxGridPackage.CX_GRID_GROUPABLE__NAME:
+				return getName();
+			case CxGridPackage.CX_GRID_GROUPABLE__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPABLE__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_GROUPABLE__ID:
+				setId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_GROUPABLE__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_GROUPABLE__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPABLE__TAGS:
+				getTags().clear();
+				return;
+			case CxGridPackage.CX_GRID_GROUPABLE__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_GROUPABLE__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_GROUPABLE__PROPERTIES:
+				getProperties().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPABLE__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridPackage.CX_GRID_GROUPABLE__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridPackage.CX_GRID_GROUPABLE__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridPackage.CX_GRID_GROUPABLE__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridGroupedCellImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridGroupedCellImpl.java
new file mode 100644
index 0000000..bce01a0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridGroupedCellImpl.java
@@ -0,0 +1,356 @@
+/**
+ *                                                                            
+} *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EObjectResolvingEList;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupable;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Grouped Cell</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl#getGroupables <em>Groupables</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridGroupedCellImpl#isUseHTML <em>Use HTML</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridGroupedCellImpl extends CxGridGroupableImpl implements CxGridGroupedCell {
+	
+	/**
+	 * The cached value of the '{@link #getGroupables() <em>Groupables</em>}' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGroupables()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridGroupable> groupables;
+
+	/**
+	 * The default value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected String label = LABEL_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_I1_8N_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String labelI18nKey = LABEL_I1_8N_KEY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isUseHTML() <em>Use HTML</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseHTML()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean USE_HTML_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isUseHTML() <em>Use HTML</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseHTML()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean useHTML = USE_HTML_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridGroupedCellImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_GROUPED_CELL;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getGroupables()
+	 *         <em>Groupables</em>}' reference list
+	 * @generated
+	 */
+	public EList<CxGridGroupable> getGroupables() {
+		if (groupables == null) {
+			groupables = new EObjectResolvingEList<CxGridGroupable>(CxGridGroupable.class, this, CxGridPackage.CX_GRID_GROUPED_CELL__GROUPABLES);
+		}
+		return groupables;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabel() <em>Label</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabel
+	 *            the new cached value of the '{@link #getLabel()
+	 *            <em>Label</em>}' attribute
+	 * @generated
+	 */
+	public void setLabel(String newLabel) {
+		String oldLabel = label;
+		label = newLabel;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_GROUPED_CELL__LABEL, oldLabel, label));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabelI18nKey()
+	 *         <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public String getLabelI18nKey() {
+		return labelI18nKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabelI18nKey
+	 *            the new cached value of the '{@link #getLabelI18nKey()
+	 *            <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public void setLabelI18nKey(String newLabelI18nKey) {
+		String oldLabelI18nKey = labelI18nKey;
+		labelI18nKey = newLabelI18nKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY, oldLabelI18nKey, labelI18nKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isUseHTML() <em>Use HTML</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isUseHTML() {
+		return useHTML;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newUseHTML
+	 *            the new cached value of the '{@link #isUseHTML()
+	 *            <em>Use HTML</em>}' attribute
+	 * @generated
+	 */
+	public void setUseHTML(boolean newUseHTML) {
+		boolean oldUseHTML = useHTML;
+		useHTML = newUseHTML;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_GROUPED_CELL__USE_HTML, oldUseHTML, useHTML));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPED_CELL__GROUPABLES:
+				return getGroupables();
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL:
+				return getLabel();
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY:
+				return getLabelI18nKey();
+			case CxGridPackage.CX_GRID_GROUPED_CELL__USE_HTML:
+				return isUseHTML();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPED_CELL__GROUPABLES:
+				getGroupables().clear();
+				getGroupables().addAll((Collection<? extends CxGridGroupable>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL:
+				setLabel((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY:
+				setLabelI18nKey((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_GROUPED_CELL__USE_HTML:
+				setUseHTML((Boolean)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPED_CELL__GROUPABLES:
+				getGroupables().clear();
+				return;
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL:
+				setLabel(LABEL_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY:
+				setLabelI18nKey(LABEL_I1_8N_KEY_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_GROUPED_CELL__USE_HTML:
+				setUseHTML(USE_HTML_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_GROUPED_CELL__GROUPABLES:
+				return groupables != null && !groupables.isEmpty();
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL:
+				return LABEL_EDEFAULT == null ? label != null : !LABEL_EDEFAULT.equals(label);
+			case CxGridPackage.CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY:
+				return LABEL_I1_8N_KEY_EDEFAULT == null ? labelI18nKey != null : !LABEL_I1_8N_KEY_EDEFAULT.equals(labelI18nKey);
+			case CxGridPackage.CX_GRID_GROUPED_CELL__USE_HTML:
+				return useHTML != USE_HTML_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (label: ");
+		result.append(label);
+		result.append(", labelI18nKey: ");
+		result.append(labelI18nKey);
+		result.append(", useHTML: ");
+		result.append(useHTML);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridHeaderRowImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridHeaderRowImpl.java
new file mode 100644
index 0000000..5dfa954
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridHeaderRowImpl.java
@@ -0,0 +1,451 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Header Row</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl#getGroupings <em>Groupings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridHeaderRowImpl#getCustomCells <em>Custom Cells</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridHeaderRowImpl extends MinimalEObjectImpl.Container implements CxGridHeaderRow {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getGroupings() <em>Groupings</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGroupings()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridGroupedCell> groupings;
+
+	/**
+	 * The cached value of the '{@link #getCustomCells() <em>Custom Cells</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCustomCells()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridMetaCell> customCells;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridHeaderRowImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_HEADER_ROW;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_HEADER_ROW__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_HEADER_ROW__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridPackage.CX_GRID_HEADER_ROW__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridPackage.CX_GRID_HEADER_ROW__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getGroupings()
+	 *         <em>Groupings</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridGroupedCell> getGroupings() {
+		if (groupings == null) {
+			groupings = new EObjectContainmentEList<CxGridGroupedCell>(CxGridGroupedCell.class, this, CxGridPackage.CX_GRID_HEADER_ROW__GROUPINGS);
+		}
+		return groupings;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCustomCells()
+	 *         <em>Custom Cells</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridMetaCell> getCustomCells() {
+		if (customCells == null) {
+			customCells = new EObjectContainmentEList<CxGridMetaCell>(CxGridMetaCell.class, this, CxGridPackage.CX_GRID_HEADER_ROW__CUSTOM_CELLS);
+		}
+		return customCells;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_HEADER_ROW__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID_HEADER_ROW__GROUPINGS:
+				return ((InternalEList<?>)getGroupings()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID_HEADER_ROW__CUSTOM_CELLS:
+				return ((InternalEList<?>)getCustomCells()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_HEADER_ROW__TAGS:
+				return getTags();
+			case CxGridPackage.CX_GRID_HEADER_ROW__ID:
+				return getId();
+			case CxGridPackage.CX_GRID_HEADER_ROW__NAME:
+				return getName();
+			case CxGridPackage.CX_GRID_HEADER_ROW__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case CxGridPackage.CX_GRID_HEADER_ROW__GROUPINGS:
+				return getGroupings();
+			case CxGridPackage.CX_GRID_HEADER_ROW__CUSTOM_CELLS:
+				return getCustomCells();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_HEADER_ROW__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__ID:
+				setId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__GROUPINGS:
+				getGroupings().clear();
+				getGroupings().addAll((Collection<? extends CxGridGroupedCell>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__CUSTOM_CELLS:
+				getCustomCells().clear();
+				getCustomCells().addAll((Collection<? extends CxGridMetaCell>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_HEADER_ROW__TAGS:
+				getTags().clear();
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__PROPERTIES:
+				getProperties().clear();
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__GROUPINGS:
+				getGroupings().clear();
+				return;
+			case CxGridPackage.CX_GRID_HEADER_ROW__CUSTOM_CELLS:
+				getCustomCells().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_HEADER_ROW__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridPackage.CX_GRID_HEADER_ROW__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridPackage.CX_GRID_HEADER_ROW__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridPackage.CX_GRID_HEADER_ROW__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case CxGridPackage.CX_GRID_HEADER_ROW__GROUPINGS:
+				return groupings != null && !groupings.isEmpty();
+			case CxGridPackage.CX_GRID_HEADER_ROW__CUSTOM_CELLS:
+				return customCells != null && !customCells.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridImpl.java
new file mode 100644
index 0000000..711bf4d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridImpl.java
@@ -0,0 +1,1902 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.binding.BindingFactory;
+import org.eclipse.osbp.ecview.core.common.model.binding.YECViewModelValueBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.binding.YValueBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableCollectionEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableMultiSelectionEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableSelectionEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YHelperLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YMultiSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YSelectionType;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.CxGridSortable;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Cx Grid</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getCollectionBindingEndpoint <em>Collection Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getSelectionBindingEndpoint <em>Selection Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getMultiSelectionBindingEndpoint <em>Multi Selection Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#isUseBeanService <em>Use Bean Service</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getSelectionType <em>Selection Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getSelectionEventTopic <em>Selection Event Topic</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getSelection <em>Selection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getMultiSelection <em>Multi Selection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getCollection <em>Collection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getEmfNsURI <em>Emf Ns URI</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getColumns <em>Columns</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getSortOrder <em>Sort Order</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#isColumnReorderingAllowed <em>Column Reordering Allowed</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getCellStyleGenerator <em>Cell Style Generator</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#isFilteringVisible <em>Filtering Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#isCustomFilters <em>Custom Filters</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getHeaders <em>Headers</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#isHeaderVisible <em>Header Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getFooters <em>Footers</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#isFooterVisible <em>Footer Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#isEditorEnabled <em>Editor Enabled</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getEditorCancelI18nLabelKey <em>Editor Cancel I1 8n Label Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getEditorSaveI18nLabelKey <em>Editor Save I1 8n Label Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridImpl#getEditorSaved <em>Editor Saved</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridImpl extends YInputImpl implements CxGrid {
+	
+	/**
+	 * The cached value of the '{@link #getCollectionBindingEndpoint() <em>Collection Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCollectionBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableCollectionEndpoint collectionBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getSelectionBindingEndpoint() <em>Selection Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSelectionBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableSelectionEndpoint selectionBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getMultiSelectionBindingEndpoint()
+	 * <em>Multi Selection Binding Endpoint</em>}' reference. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getMultiSelectionBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableMultiSelectionEndpoint multiSelectionBindingEndpoint;
+
+	/**
+	 * The default value of the '{@link #isUseBeanService() <em>Use Bean Service</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isUseBeanService()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean USE_BEAN_SERVICE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isUseBeanService() <em>Use Bean Service</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isUseBeanService()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean useBeanService = USE_BEAN_SERVICE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getSelectionType() <em>Selection Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getSelectionType()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final YSelectionType SELECTION_TYPE_EDEFAULT = YSelectionType.SINGLE;
+
+	/**
+	 * The cached value of the '{@link #getSelectionType() <em>Selection Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getSelectionType()
+	 * @generated
+	 * @ordered
+	 */
+	protected YSelectionType selectionType = SELECTION_TYPE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getSelectionEventTopic() <em>Selection Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getSelectionEventTopic()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String SELECTION_EVENT_TOPIC_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getSelectionEventTopic() <em>Selection Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getSelectionEventTopic()
+	 * @generated
+	 * @ordered
+	 */
+	protected String selectionEventTopic = SELECTION_EVENT_TOPIC_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getSelection() <em>Selection</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getSelection()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Object SELECTION_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getSelection() <em>Selection</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getSelection()
+	 * @generated
+	 * @ordered
+	 */
+	protected Object selection = SELECTION_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getMultiSelection() <em>Multi Selection</em>}' attribute list.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getMultiSelection()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Object> multiSelection;
+
+	/**
+	 * The cached value of the '{@link #getCollection() <em>Collection</em>}' attribute list.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getCollection()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Object> collection;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * The default value of the '{@link #getEmfNsURI() <em>Emf Ns URI</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getEmfNsURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String EMF_NS_URI_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getEmfNsURI() <em>Emf Ns URI</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getEmfNsURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected String emfNsURI = EMF_NS_URI_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getColumns() <em>Columns</em>}' containment reference list.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getColumns()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridColumn> columns;
+
+	/**
+	 * The cached value of the '{@link #getSortOrder() <em>Sort Order</em>}' containment reference list.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getSortOrder()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridSortable> sortOrder;
+
+	/**
+	 * The default value of the '{@link #isColumnReorderingAllowed() <em>Column Reordering Allowed</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isColumnReorderingAllowed()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean COLUMN_REORDERING_ALLOWED_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isColumnReorderingAllowed() <em>Column Reordering Allowed</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isColumnReorderingAllowed()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean columnReorderingAllowed = COLUMN_REORDERING_ALLOWED_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getCellStyleGenerator()
+	 * <em>Cell Style Generator</em>}' containment reference. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getCellStyleGenerator()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridCellStyleGenerator cellStyleGenerator;
+
+	/**
+	 * The default value of the '{@link #isFilteringVisible() <em>Filtering Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isFilteringVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean FILTERING_VISIBLE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isFilteringVisible() <em>Filtering Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isFilteringVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean filteringVisible = FILTERING_VISIBLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isCustomFilters() <em>Custom Filters</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isCustomFilters()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean CUSTOM_FILTERS_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isCustomFilters() <em>Custom Filters</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isCustomFilters()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean customFilters = CUSTOM_FILTERS_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getHeaders() <em>Headers</em>}' containment reference list.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getHeaders()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridHeaderRow> headers;
+
+	/**
+	 * The default value of the '{@link #isHeaderVisible() <em>Header Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isHeaderVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean HEADER_VISIBLE_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isHeaderVisible() <em>Header Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isHeaderVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean headerVisible = HEADER_VISIBLE_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getFooters() <em>Footers</em>}' containment reference list.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getFooters()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridFooterRow> footers;
+
+	/**
+	 * The default value of the '{@link #isFooterVisible() <em>Footer Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isFooterVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean FOOTER_VISIBLE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isFooterVisible() <em>Footer Visible</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isFooterVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean footerVisible = FOOTER_VISIBLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isEditorEnabled() <em>Editor Enabled</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isEditorEnabled()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean EDITOR_ENABLED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isEditorEnabled() <em>Editor Enabled</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #isEditorEnabled()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean editorEnabled = EDITOR_ENABLED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getEditorCancelI18nLabelKey() <em>Editor Cancel I1 8n Label Key</em>}' attribute.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @see #getEditorCancelI18nLabelKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String EDITOR_CANCEL_I1_8N_LABEL_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getEditorCancelI18nLabelKey() <em>Editor Cancel I1 8n Label Key</em>}' attribute.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @see #getEditorCancelI18nLabelKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String editorCancelI18nLabelKey = EDITOR_CANCEL_I1_8N_LABEL_KEY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getEditorSaveI18nLabelKey() <em>Editor Save I1 8n Label Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEditorSaveI18nLabelKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String EDITOR_SAVE_I1_8N_LABEL_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getEditorSaveI18nLabelKey() <em>Editor Save I1 8n Label Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEditorSaveI18nLabelKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String editorSaveI18nLabelKey = EDITOR_SAVE_I1_8N_LABEL_KEY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getEditorSaved() <em>Editor Saved</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getEditorSaved()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Object EDITOR_SAVED_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getEditorSaved() <em>Editor Saved</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getEditorSaved()
+	 * @generated
+	 * @ordered
+	 */
+	protected Object editorSaved = EDITOR_SAVED_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCollectionBindingEndpoint()
+	 *         <em>Collection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint getCollectionBindingEndpoint() {
+		if (collectionBindingEndpoint != null && collectionBindingEndpoint.eIsProxy()) {
+			InternalEObject oldCollectionBindingEndpoint = (InternalEObject)collectionBindingEndpoint;
+			collectionBindingEndpoint = (YEmbeddableCollectionEndpoint)eResolveProxy(oldCollectionBindingEndpoint);
+			if (collectionBindingEndpoint != oldCollectionBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT, oldCollectionBindingEndpoint, collectionBindingEndpoint));
+			}
+		}
+		return collectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable collection endpoint
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint basicGetCollectionBindingEndpoint() {
+		return collectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCollectionBindingEndpoint
+	 *            the new collection binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetCollectionBindingEndpoint(
+			YEmbeddableCollectionEndpoint newCollectionBindingEndpoint,
+			NotificationChain msgs) {
+		YEmbeddableCollectionEndpoint oldCollectionBindingEndpoint = collectionBindingEndpoint;
+		collectionBindingEndpoint = newCollectionBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT, oldCollectionBindingEndpoint, newCollectionBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCollectionBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getCollectionBindingEndpoint()
+	 *            <em>Collection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setCollectionBindingEndpoint(
+			YEmbeddableCollectionEndpoint newCollectionBindingEndpoint) {
+		if (newCollectionBindingEndpoint != collectionBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (collectionBindingEndpoint != null)
+				msgs = ((InternalEObject)collectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT, YEmbeddableCollectionEndpoint.class, msgs);
+			if (newCollectionBindingEndpoint != null)
+				msgs = ((InternalEObject)newCollectionBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT, YEmbeddableCollectionEndpoint.class, msgs);
+			msgs = basicSetCollectionBindingEndpoint(newCollectionBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT, newCollectionBindingEndpoint, newCollectionBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSelectionBindingEndpoint()
+	 *         <em>Selection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint getSelectionBindingEndpoint() {
+		if (selectionBindingEndpoint != null && selectionBindingEndpoint.eIsProxy()) {
+			InternalEObject oldSelectionBindingEndpoint = (InternalEObject)selectionBindingEndpoint;
+			selectionBindingEndpoint = (YEmbeddableSelectionEndpoint)eResolveProxy(oldSelectionBindingEndpoint);
+			if (selectionBindingEndpoint != oldSelectionBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT, oldSelectionBindingEndpoint, selectionBindingEndpoint));
+			}
+		}
+		return selectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable selection endpoint
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint basicGetSelectionBindingEndpoint() {
+		return selectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelectionBindingEndpoint
+	 *            the new selection binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetSelectionBindingEndpoint(
+			YEmbeddableSelectionEndpoint newSelectionBindingEndpoint,
+			NotificationChain msgs) {
+		YEmbeddableSelectionEndpoint oldSelectionBindingEndpoint = selectionBindingEndpoint;
+		selectionBindingEndpoint = newSelectionBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT, oldSelectionBindingEndpoint, newSelectionBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelectionBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getSelectionBindingEndpoint()
+	 *            <em>Selection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setSelectionBindingEndpoint(
+			YEmbeddableSelectionEndpoint newSelectionBindingEndpoint) {
+		if (newSelectionBindingEndpoint != selectionBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (selectionBindingEndpoint != null)
+				msgs = ((InternalEObject)selectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT, YEmbeddableSelectionEndpoint.class, msgs);
+			if (newSelectionBindingEndpoint != null)
+				msgs = ((InternalEObject)newSelectionBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT, YEmbeddableSelectionEndpoint.class, msgs);
+			msgs = basicSetSelectionBindingEndpoint(newSelectionBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT, newSelectionBindingEndpoint, newSelectionBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '
+	 *         {@link #getMultiSelectionBindingEndpoint()
+	 *         <em>Multi Selection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableMultiSelectionEndpoint getMultiSelectionBindingEndpoint() {
+		if (multiSelectionBindingEndpoint != null && multiSelectionBindingEndpoint.eIsProxy()) {
+			InternalEObject oldMultiSelectionBindingEndpoint = (InternalEObject)multiSelectionBindingEndpoint;
+			multiSelectionBindingEndpoint = (YEmbeddableMultiSelectionEndpoint)eResolveProxy(oldMultiSelectionBindingEndpoint);
+			if (multiSelectionBindingEndpoint != oldMultiSelectionBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT, oldMultiSelectionBindingEndpoint, multiSelectionBindingEndpoint));
+			}
+		}
+		return multiSelectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable multi selection endpoint
+	 * @generated
+	 */
+	public YEmbeddableMultiSelectionEndpoint basicGetMultiSelectionBindingEndpoint() {
+		return multiSelectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newMultiSelectionBindingEndpoint
+	 *            the new multi selection binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetMultiSelectionBindingEndpoint(
+			YEmbeddableMultiSelectionEndpoint newMultiSelectionBindingEndpoint,
+			NotificationChain msgs) {
+		YEmbeddableMultiSelectionEndpoint oldMultiSelectionBindingEndpoint = multiSelectionBindingEndpoint;
+		multiSelectionBindingEndpoint = newMultiSelectionBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT, oldMultiSelectionBindingEndpoint, newMultiSelectionBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newMultiSelectionBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getMultiSelectionBindingEndpoint()
+	 *            <em>Multi Selection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setMultiSelectionBindingEndpoint(
+			YEmbeddableMultiSelectionEndpoint newMultiSelectionBindingEndpoint) {
+		if (newMultiSelectionBindingEndpoint != multiSelectionBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (multiSelectionBindingEndpoint != null)
+				msgs = ((InternalEObject)multiSelectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_MULTI_SELECTION_ENDPOINT__ELEMENT, YEmbeddableMultiSelectionEndpoint.class, msgs);
+			if (newMultiSelectionBindingEndpoint != null)
+				msgs = ((InternalEObject)newMultiSelectionBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_MULTI_SELECTION_ENDPOINT__ELEMENT, YEmbeddableMultiSelectionEndpoint.class, msgs);
+			msgs = basicSetMultiSelectionBindingEndpoint(newMultiSelectionBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT, newMultiSelectionBindingEndpoint, newMultiSelectionBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isUseBeanService()
+	 *         <em>Use Bean Service</em>}' attribute
+	 * @generated
+	 */
+	public boolean isUseBeanService() {
+		return useBeanService;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newUseBeanService
+	 *            the new cached value of the '{@link #isUseBeanService()
+	 *            <em>Use Bean Service</em>}' attribute
+	 * @generated
+	 */
+	public void setUseBeanService(boolean newUseBeanService) {
+		boolean oldUseBeanService = useBeanService;
+		useBeanService = newUseBeanService;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__USE_BEAN_SERVICE, oldUseBeanService, useBeanService));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSelectionType()
+	 *         <em>Selection Type</em>}' attribute
+	 * @generated
+	 */
+	public YSelectionType getSelectionType() {
+		return selectionType;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelectionType
+	 *            the new cached value of the '{@link #getSelectionType()
+	 *            <em>Selection Type</em>}' attribute
+	 * @generated
+	 */
+	public void setSelectionType(YSelectionType newSelectionType) {
+		YSelectionType oldSelectionType = selectionType;
+		selectionType = newSelectionType == null ? SELECTION_TYPE_EDEFAULT : newSelectionType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__SELECTION_TYPE, oldSelectionType, selectionType));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSelectionEventTopic()
+	 *         <em>Selection Event Topic</em>}' attribute
+	 * @generated
+	 */
+	public String getSelectionEventTopic() {
+		return selectionEventTopic;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelectionEventTopic
+	 *            the new cached value of the '{@link #getSelectionEventTopic()
+	 *            <em>Selection Event Topic</em>}' attribute
+	 * @generated
+	 */
+	public void setSelectionEventTopic(String newSelectionEventTopic) {
+		String oldSelectionEventTopic = selectionEventTopic;
+		selectionEventTopic = newSelectionEventTopic;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__SELECTION_EVENT_TOPIC, oldSelectionEventTopic, selectionEventTopic));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSelection()
+	 *         <em>Selection</em>}' attribute
+	 * @generated
+	 */
+	public Object getSelection() {
+		return selection;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelection
+	 *            the new cached value of the '{@link #getSelection()
+	 *            <em>Selection</em>}' attribute
+	 * @generated
+	 */
+	public void setSelection(Object newSelection) {
+		Object oldSelection = selection;
+		selection = newSelection;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__SELECTION, oldSelection, selection));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getMultiSelection()
+	 *         <em>Multi Selection</em>}' attribute list
+	 * @generated
+	 */
+	public EList<Object> getMultiSelection() {
+		if (multiSelection == null) {
+			multiSelection = new EDataTypeUniqueEList<Object>(Object.class, this, CxGridPackage.CX_GRID__MULTI_SELECTION);
+		}
+		return multiSelection;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCollection()
+	 *         <em>Collection</em>}' attribute list
+	 * @generated
+	 */
+	public EList<Object> getCollection() {
+		if (collection == null) {
+			collection = new EDataTypeUniqueEList<Object>(Object.class, this, CxGridPackage.CX_GRID__COLLECTION);
+		}
+		return collection;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getType() <em>Type</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newType
+	 *            the new cached value of the '{@link #getType() <em>Type</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEmfNsURI()
+	 *         <em>Emf Ns URI</em>}' attribute
+	 * @generated
+	 */
+	public String getEmfNsURI() {
+		return emfNsURI;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEmfNsURI
+	 *            the new cached value of the '{@link #getEmfNsURI()
+	 *            <em>Emf Ns URI</em>}' attribute
+	 * @generated
+	 */
+	public void setEmfNsURI(String newEmfNsURI) {
+		String oldEmfNsURI = emfNsURI;
+		emfNsURI = newEmfNsURI;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__EMF_NS_URI, oldEmfNsURI, emfNsURI));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTypeQualifiedName()
+	 *         <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTypeQualifiedName
+	 *            the new cached value of the '{@link #getTypeQualifiedName()
+	 *            <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isEditorEnabled()
+	 *         <em>Editor Enabled</em>}' attribute
+	 * @generated
+	 */
+	public boolean isEditorEnabled() {
+		return editorEnabled;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditorEnabled
+	 *            the new cached value of the '{@link #isEditorEnabled()
+	 *            <em>Editor Enabled</em>}' attribute
+	 * @generated
+	 */
+	public void setEditorEnabled(boolean newEditorEnabled) {
+		boolean oldEditorEnabled = editorEnabled;
+		editorEnabled = newEditorEnabled;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__EDITOR_ENABLED, oldEditorEnabled, editorEnabled));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCellStyleGenerator()
+	 *         <em>Cell Style Generator</em>}' containment reference
+	 * @generated
+	 */
+	public CxGridCellStyleGenerator getCellStyleGenerator() {
+		return cellStyleGenerator;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCellStyleGenerator
+	 *            the new cell style generator
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetCellStyleGenerator(
+			CxGridCellStyleGenerator newCellStyleGenerator,
+			NotificationChain msgs) {
+		CxGridCellStyleGenerator oldCellStyleGenerator = cellStyleGenerator;
+		cellStyleGenerator = newCellStyleGenerator;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR, oldCellStyleGenerator, newCellStyleGenerator);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCellStyleGenerator
+	 *            the new cached value of the '{@link #getCellStyleGenerator()
+	 *            <em>Cell Style Generator</em>}' containment reference
+	 * @generated
+	 */
+	public void setCellStyleGenerator(
+			CxGridCellStyleGenerator newCellStyleGenerator) {
+		if (newCellStyleGenerator != cellStyleGenerator) {
+			NotificationChain msgs = null;
+			if (cellStyleGenerator != null)
+				msgs = ((InternalEObject)cellStyleGenerator).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR, null, msgs);
+			if (newCellStyleGenerator != null)
+				msgs = ((InternalEObject)newCellStyleGenerator).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR, null, msgs);
+			msgs = basicSetCellStyleGenerator(newCellStyleGenerator, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR, newCellStyleGenerator, newCellStyleGenerator));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isFilteringVisible()
+	 *         <em>Filtering Visible</em>}' attribute
+	 * @generated
+	 */
+	public boolean isFilteringVisible() {
+		return filteringVisible;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newFilteringVisible
+	 *            the new cached value of the '{@link #isFilteringVisible()
+	 *            <em>Filtering Visible</em>}' attribute
+	 * @generated
+	 */
+	public void setFilteringVisible(boolean newFilteringVisible) {
+		boolean oldFilteringVisible = filteringVisible;
+		filteringVisible = newFilteringVisible;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__FILTERING_VISIBLE, oldFilteringVisible, filteringVisible));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isCustomFilters()
+	 *         <em>Custom Filters</em>}' attribute
+	 * @generated
+	 */
+	public boolean isCustomFilters() {
+		return customFilters;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCustomFilters
+	 *            the new cached value of the '{@link #isCustomFilters()
+	 *            <em>Custom Filters</em>}' attribute
+	 * @generated
+	 */
+	public void setCustomFilters(boolean newCustomFilters) {
+		boolean oldCustomFilters = customFilters;
+		customFilters = newCustomFilters;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__CUSTOM_FILTERS, oldCustomFilters, customFilters));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getHeaders() <em>Headers</em>}'
+	 *         containment reference list
+	 * @generated
+	 */
+	public EList<CxGridHeaderRow> getHeaders() {
+		if (headers == null) {
+			headers = new EObjectContainmentEList<CxGridHeaderRow>(CxGridHeaderRow.class, this, CxGridPackage.CX_GRID__HEADERS);
+		}
+		return headers;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getColumns() <em>Columns</em>}'
+	 *         containment reference list
+	 * @generated
+	 */
+	public EList<CxGridColumn> getColumns() {
+		if (columns == null) {
+			columns = new EObjectContainmentEList<CxGridColumn>(CxGridColumn.class, this, CxGridPackage.CX_GRID__COLUMNS);
+		}
+		return columns;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSortOrder()
+	 *         <em>Sort Order</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridSortable> getSortOrder() {
+		if (sortOrder == null) {
+			sortOrder = new EObjectContainmentEList<CxGridSortable>(CxGridSortable.class, this, CxGridPackage.CX_GRID__SORT_ORDER);
+		}
+		return sortOrder;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isColumnReorderingAllowed()
+	 *         <em>Column Reordering Allowed</em>}' attribute
+	 * @generated
+	 */
+	public boolean isColumnReorderingAllowed() {
+		return columnReorderingAllowed;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newColumnReorderingAllowed
+	 *            the new cached value of the '
+	 *            {@link #isColumnReorderingAllowed()
+	 *            <em>Column Reordering Allowed</em>}' attribute
+	 * @generated
+	 */
+	public void setColumnReorderingAllowed(boolean newColumnReorderingAllowed) {
+		boolean oldColumnReorderingAllowed = columnReorderingAllowed;
+		columnReorderingAllowed = newColumnReorderingAllowed;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__COLUMN_REORDERING_ALLOWED, oldColumnReorderingAllowed, columnReorderingAllowed));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isFooterVisible()
+	 *         <em>Footer Visible</em>}' attribute
+	 * @generated
+	 */
+	public boolean isFooterVisible() {
+		return footerVisible;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newFooterVisible
+	 *            the new cached value of the '{@link #isFooterVisible()
+	 *            <em>Footer Visible</em>}' attribute
+	 * @generated
+	 */
+	public void setFooterVisible(boolean newFooterVisible) {
+		boolean oldFooterVisible = footerVisible;
+		footerVisible = newFooterVisible;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__FOOTER_VISIBLE, oldFooterVisible, footerVisible));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isHeaderVisible()
+	 *         <em>Header Visible</em>}' attribute
+	 * @generated
+	 */
+	public boolean isHeaderVisible() {
+		return headerVisible;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHeaderVisible
+	 *            the new cached value of the '{@link #isHeaderVisible()
+	 *            <em>Header Visible</em>}' attribute
+	 * @generated
+	 */
+	public void setHeaderVisible(boolean newHeaderVisible) {
+		boolean oldHeaderVisible = headerVisible;
+		headerVisible = newHeaderVisible;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__HEADER_VISIBLE, oldHeaderVisible, headerVisible));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getFooters() <em>Footers</em>}'
+	 *         containment reference list
+	 * @generated
+	 */
+	public EList<CxGridFooterRow> getFooters() {
+		if (footers == null) {
+			footers = new EObjectContainmentEList<CxGridFooterRow>(CxGridFooterRow.class, this, CxGridPackage.CX_GRID__FOOTERS);
+		}
+		return footers;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEditorCancelI18nLabelKey()
+	 *         <em>Editor Cancel I1 8n Label Key</em>}' attribute
+	 * @generated
+	 */
+	public String getEditorCancelI18nLabelKey() {
+		return editorCancelI18nLabelKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditorCancelI18nLabelKey
+	 *            the new cached value of the '
+	 *            {@link #getEditorCancelI18nLabelKey()
+	 *            <em>Editor Cancel I1 8n Label Key</em>}' attribute
+	 * @generated
+	 */
+	public void setEditorCancelI18nLabelKey(String newEditorCancelI18nLabelKey) {
+		String oldEditorCancelI18nLabelKey = editorCancelI18nLabelKey;
+		editorCancelI18nLabelKey = newEditorCancelI18nLabelKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY, oldEditorCancelI18nLabelKey, editorCancelI18nLabelKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEditorSaveI18nLabelKey()
+	 *         <em>Editor Save I1 8n Label Key</em>}' attribute
+	 * @generated
+	 */
+	public String getEditorSaveI18nLabelKey() {
+		return editorSaveI18nLabelKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditorSaveI18nLabelKey
+	 *            the new cached value of the '
+	 *            {@link #getEditorSaveI18nLabelKey()
+	 *            <em>Editor Save I1 8n Label Key</em>}' attribute
+	 * @generated
+	 */
+	public void setEditorSaveI18nLabelKey(String newEditorSaveI18nLabelKey) {
+		String oldEditorSaveI18nLabelKey = editorSaveI18nLabelKey;
+		editorSaveI18nLabelKey = newEditorSaveI18nLabelKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY, oldEditorSaveI18nLabelKey, editorSaveI18nLabelKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEditorSaved()
+	 *         <em>Editor Saved</em>}' attribute
+	 * @generated
+	 */
+	public Object getEditorSaved() {
+		return editorSaved;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditorSaved
+	 *            the new cached value of the '{@link #getEditorSaved()
+	 *            <em>Editor Saved</em>}' attribute
+	 * @generated
+	 */
+	public void setEditorSaved(Object newEditorSaved) {
+		Object oldEditorSaved = editorSaved;
+		editorSaved = newEditorSaved;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID__EDITOR_SAVED, oldEditorSaved, editorSaved));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * 
+	 * 
+	 * <!-- end-user-doc -->.
+	 *
+	 * @return the y helper layout
+	 */
+	public YHelperLayout createEditorFieldHelperLayout() {
+		YHelperLayout layout = CoreModelFactory.eINSTANCE.createYHelperLayout();
+		for (CxGridColumn col : getColumns()) {
+			if (col.getEditorField() != null) {
+				layout.addElement(col.getEditorField());
+			}
+		}
+		return layout;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YMultiSelectionBindable#createMultiSelectionEndpoint()
+	 */
+	public YEmbeddableMultiSelectionEndpoint createMultiSelectionEndpoint() {
+		YEmbeddableMultiSelectionEndpoint endpoint = CoreModelFactory.eINSTANCE
+				.createYEmbeddableMultiSelectionEndpoint();
+		endpoint.setElement(this);
+		return endpoint;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable#createSelectionEndpoint()
+	 */
+	public YEmbeddableSelectionEndpoint createSelectionEndpoint() {
+		YEmbeddableSelectionEndpoint endpoint = CoreModelFactory.eINSTANCE
+				.createYEmbeddableSelectionEndpoint();
+		endpoint.setElement(this);
+		return endpoint;
+	}
+
+	/**
+	 * Creates a collection endpoint to bind the input collection to the grid.
+	 *
+	 * @return the y embeddable collection endpoint
+	 */
+	public YEmbeddableCollectionEndpoint createCollectionEndpoint() {
+		YEmbeddableCollectionEndpoint endpoint = CoreModelFactory.eINSTANCE
+				.createYEmbeddableCollectionEndpoint();
+		endpoint.setElement(this);
+		return endpoint;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid#createEditorUpdatedEndpoint()
+	 */
+	@Override
+	public YValueBindingEndpoint createEditorUpdatedEndpoint() {
+		YECViewModelValueBindingEndpoint endpoint = BindingFactory.eINSTANCE
+				.createYECViewModelValueBindingEndpoint();
+		endpoint.setElement(this);
+		endpoint.getFeatures()
+				.add((EStructuralFeature) CxGridPackage.Literals.CX_GRID__EDITOR_SAVED);
+		return endpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT:
+				if (collectionBindingEndpoint != null)
+					msgs = ((InternalEObject)collectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT, YEmbeddableCollectionEndpoint.class, msgs);
+				return basicSetCollectionBindingEndpoint((YEmbeddableCollectionEndpoint)otherEnd, msgs);
+			case CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT:
+				if (selectionBindingEndpoint != null)
+					msgs = ((InternalEObject)selectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT, YEmbeddableSelectionEndpoint.class, msgs);
+				return basicSetSelectionBindingEndpoint((YEmbeddableSelectionEndpoint)otherEnd, msgs);
+			case CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT:
+				if (multiSelectionBindingEndpoint != null)
+					msgs = ((InternalEObject)multiSelectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_MULTI_SELECTION_ENDPOINT__ELEMENT, YEmbeddableMultiSelectionEndpoint.class, msgs);
+				return basicSetMultiSelectionBindingEndpoint((YEmbeddableMultiSelectionEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT:
+				return basicSetCollectionBindingEndpoint(null, msgs);
+			case CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT:
+				return basicSetSelectionBindingEndpoint(null, msgs);
+			case CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT:
+				return basicSetMultiSelectionBindingEndpoint(null, msgs);
+			case CxGridPackage.CX_GRID__COLUMNS:
+				return ((InternalEList<?>)getColumns()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID__SORT_ORDER:
+				return ((InternalEList<?>)getSortOrder()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR:
+				return basicSetCellStyleGenerator(null, msgs);
+			case CxGridPackage.CX_GRID__HEADERS:
+				return ((InternalEList<?>)getHeaders()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID__FOOTERS:
+				return ((InternalEList<?>)getFooters()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT:
+				if (resolve) return getCollectionBindingEndpoint();
+				return basicGetCollectionBindingEndpoint();
+			case CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT:
+				if (resolve) return getSelectionBindingEndpoint();
+				return basicGetSelectionBindingEndpoint();
+			case CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT:
+				if (resolve) return getMultiSelectionBindingEndpoint();
+				return basicGetMultiSelectionBindingEndpoint();
+			case CxGridPackage.CX_GRID__USE_BEAN_SERVICE:
+				return isUseBeanService();
+			case CxGridPackage.CX_GRID__SELECTION_TYPE:
+				return getSelectionType();
+			case CxGridPackage.CX_GRID__SELECTION_EVENT_TOPIC:
+				return getSelectionEventTopic();
+			case CxGridPackage.CX_GRID__SELECTION:
+				return getSelection();
+			case CxGridPackage.CX_GRID__MULTI_SELECTION:
+				return getMultiSelection();
+			case CxGridPackage.CX_GRID__COLLECTION:
+				return getCollection();
+			case CxGridPackage.CX_GRID__TYPE:
+				return getType();
+			case CxGridPackage.CX_GRID__EMF_NS_URI:
+				return getEmfNsURI();
+			case CxGridPackage.CX_GRID__TYPE_QUALIFIED_NAME:
+				return getTypeQualifiedName();
+			case CxGridPackage.CX_GRID__COLUMNS:
+				return getColumns();
+			case CxGridPackage.CX_GRID__SORT_ORDER:
+				return getSortOrder();
+			case CxGridPackage.CX_GRID__COLUMN_REORDERING_ALLOWED:
+				return isColumnReorderingAllowed();
+			case CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR:
+				return getCellStyleGenerator();
+			case CxGridPackage.CX_GRID__FILTERING_VISIBLE:
+				return isFilteringVisible();
+			case CxGridPackage.CX_GRID__CUSTOM_FILTERS:
+				return isCustomFilters();
+			case CxGridPackage.CX_GRID__HEADERS:
+				return getHeaders();
+			case CxGridPackage.CX_GRID__HEADER_VISIBLE:
+				return isHeaderVisible();
+			case CxGridPackage.CX_GRID__FOOTERS:
+				return getFooters();
+			case CxGridPackage.CX_GRID__FOOTER_VISIBLE:
+				return isFooterVisible();
+			case CxGridPackage.CX_GRID__EDITOR_ENABLED:
+				return isEditorEnabled();
+			case CxGridPackage.CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY:
+				return getEditorCancelI18nLabelKey();
+			case CxGridPackage.CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY:
+				return getEditorSaveI18nLabelKey();
+			case CxGridPackage.CX_GRID__EDITOR_SAVED:
+				return getEditorSaved();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT:
+				setCollectionBindingEndpoint((YEmbeddableCollectionEndpoint)newValue);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT:
+				setSelectionBindingEndpoint((YEmbeddableSelectionEndpoint)newValue);
+				return;
+			case CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT:
+				setMultiSelectionBindingEndpoint((YEmbeddableMultiSelectionEndpoint)newValue);
+				return;
+			case CxGridPackage.CX_GRID__USE_BEAN_SERVICE:
+				setUseBeanService((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION_TYPE:
+				setSelectionType((YSelectionType)newValue);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION_EVENT_TOPIC:
+				setSelectionEventTopic((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION:
+				setSelection(newValue);
+				return;
+			case CxGridPackage.CX_GRID__MULTI_SELECTION:
+				getMultiSelection().clear();
+				getMultiSelection().addAll((Collection<? extends Object>)newValue);
+				return;
+			case CxGridPackage.CX_GRID__COLLECTION:
+				getCollection().clear();
+				getCollection().addAll((Collection<? extends Object>)newValue);
+				return;
+			case CxGridPackage.CX_GRID__TYPE:
+				setType((Class<?>)newValue);
+				return;
+			case CxGridPackage.CX_GRID__EMF_NS_URI:
+				setEmfNsURI((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID__COLUMNS:
+				getColumns().clear();
+				getColumns().addAll((Collection<? extends CxGridColumn>)newValue);
+				return;
+			case CxGridPackage.CX_GRID__SORT_ORDER:
+				getSortOrder().clear();
+				getSortOrder().addAll((Collection<? extends CxGridSortable>)newValue);
+				return;
+			case CxGridPackage.CX_GRID__COLUMN_REORDERING_ALLOWED:
+				setColumnReorderingAllowed((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR:
+				setCellStyleGenerator((CxGridCellStyleGenerator)newValue);
+				return;
+			case CxGridPackage.CX_GRID__FILTERING_VISIBLE:
+				setFilteringVisible((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID__CUSTOM_FILTERS:
+				setCustomFilters((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID__HEADERS:
+				getHeaders().clear();
+				getHeaders().addAll((Collection<? extends CxGridHeaderRow>)newValue);
+				return;
+			case CxGridPackage.CX_GRID__HEADER_VISIBLE:
+				setHeaderVisible((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID__FOOTERS:
+				getFooters().clear();
+				getFooters().addAll((Collection<? extends CxGridFooterRow>)newValue);
+				return;
+			case CxGridPackage.CX_GRID__FOOTER_VISIBLE:
+				setFooterVisible((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_ENABLED:
+				setEditorEnabled((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY:
+				setEditorCancelI18nLabelKey((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY:
+				setEditorSaveI18nLabelKey((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_SAVED:
+				setEditorSaved(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT:
+				setCollectionBindingEndpoint((YEmbeddableCollectionEndpoint)null);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT:
+				setSelectionBindingEndpoint((YEmbeddableSelectionEndpoint)null);
+				return;
+			case CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT:
+				setMultiSelectionBindingEndpoint((YEmbeddableMultiSelectionEndpoint)null);
+				return;
+			case CxGridPackage.CX_GRID__USE_BEAN_SERVICE:
+				setUseBeanService(USE_BEAN_SERVICE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION_TYPE:
+				setSelectionType(SELECTION_TYPE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION_EVENT_TOPIC:
+				setSelectionEventTopic(SELECTION_EVENT_TOPIC_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__SELECTION:
+				setSelection(SELECTION_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__MULTI_SELECTION:
+				getMultiSelection().clear();
+				return;
+			case CxGridPackage.CX_GRID__COLLECTION:
+				getCollection().clear();
+				return;
+			case CxGridPackage.CX_GRID__TYPE:
+				setType((Class<?>)null);
+				return;
+			case CxGridPackage.CX_GRID__EMF_NS_URI:
+				setEmfNsURI(EMF_NS_URI_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__COLUMNS:
+				getColumns().clear();
+				return;
+			case CxGridPackage.CX_GRID__SORT_ORDER:
+				getSortOrder().clear();
+				return;
+			case CxGridPackage.CX_GRID__COLUMN_REORDERING_ALLOWED:
+				setColumnReorderingAllowed(COLUMN_REORDERING_ALLOWED_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR:
+				setCellStyleGenerator((CxGridCellStyleGenerator)null);
+				return;
+			case CxGridPackage.CX_GRID__FILTERING_VISIBLE:
+				setFilteringVisible(FILTERING_VISIBLE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__CUSTOM_FILTERS:
+				setCustomFilters(CUSTOM_FILTERS_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__HEADERS:
+				getHeaders().clear();
+				return;
+			case CxGridPackage.CX_GRID__HEADER_VISIBLE:
+				setHeaderVisible(HEADER_VISIBLE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__FOOTERS:
+				getFooters().clear();
+				return;
+			case CxGridPackage.CX_GRID__FOOTER_VISIBLE:
+				setFooterVisible(FOOTER_VISIBLE_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_ENABLED:
+				setEditorEnabled(EDITOR_ENABLED_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY:
+				setEditorCancelI18nLabelKey(EDITOR_CANCEL_I1_8N_LABEL_KEY_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY:
+				setEditorSaveI18nLabelKey(EDITOR_SAVE_I1_8N_LABEL_KEY_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID__EDITOR_SAVED:
+				setEditorSaved(EDITOR_SAVED_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT:
+				return collectionBindingEndpoint != null;
+			case CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT:
+				return selectionBindingEndpoint != null;
+			case CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT:
+				return multiSelectionBindingEndpoint != null;
+			case CxGridPackage.CX_GRID__USE_BEAN_SERVICE:
+				return useBeanService != USE_BEAN_SERVICE_EDEFAULT;
+			case CxGridPackage.CX_GRID__SELECTION_TYPE:
+				return selectionType != SELECTION_TYPE_EDEFAULT;
+			case CxGridPackage.CX_GRID__SELECTION_EVENT_TOPIC:
+				return SELECTION_EVENT_TOPIC_EDEFAULT == null ? selectionEventTopic != null : !SELECTION_EVENT_TOPIC_EDEFAULT.equals(selectionEventTopic);
+			case CxGridPackage.CX_GRID__SELECTION:
+				return SELECTION_EDEFAULT == null ? selection != null : !SELECTION_EDEFAULT.equals(selection);
+			case CxGridPackage.CX_GRID__MULTI_SELECTION:
+				return multiSelection != null && !multiSelection.isEmpty();
+			case CxGridPackage.CX_GRID__COLLECTION:
+				return collection != null && !collection.isEmpty();
+			case CxGridPackage.CX_GRID__TYPE:
+				return type != null;
+			case CxGridPackage.CX_GRID__EMF_NS_URI:
+				return EMF_NS_URI_EDEFAULT == null ? emfNsURI != null : !EMF_NS_URI_EDEFAULT.equals(emfNsURI);
+			case CxGridPackage.CX_GRID__TYPE_QUALIFIED_NAME:
+				return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+			case CxGridPackage.CX_GRID__COLUMNS:
+				return columns != null && !columns.isEmpty();
+			case CxGridPackage.CX_GRID__SORT_ORDER:
+				return sortOrder != null && !sortOrder.isEmpty();
+			case CxGridPackage.CX_GRID__COLUMN_REORDERING_ALLOWED:
+				return columnReorderingAllowed != COLUMN_REORDERING_ALLOWED_EDEFAULT;
+			case CxGridPackage.CX_GRID__CELL_STYLE_GENERATOR:
+				return cellStyleGenerator != null;
+			case CxGridPackage.CX_GRID__FILTERING_VISIBLE:
+				return filteringVisible != FILTERING_VISIBLE_EDEFAULT;
+			case CxGridPackage.CX_GRID__CUSTOM_FILTERS:
+				return customFilters != CUSTOM_FILTERS_EDEFAULT;
+			case CxGridPackage.CX_GRID__HEADERS:
+				return headers != null && !headers.isEmpty();
+			case CxGridPackage.CX_GRID__HEADER_VISIBLE:
+				return headerVisible != HEADER_VISIBLE_EDEFAULT;
+			case CxGridPackage.CX_GRID__FOOTERS:
+				return footers != null && !footers.isEmpty();
+			case CxGridPackage.CX_GRID__FOOTER_VISIBLE:
+				return footerVisible != FOOTER_VISIBLE_EDEFAULT;
+			case CxGridPackage.CX_GRID__EDITOR_ENABLED:
+				return editorEnabled != EDITOR_ENABLED_EDEFAULT;
+			case CxGridPackage.CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY:
+				return EDITOR_CANCEL_I1_8N_LABEL_KEY_EDEFAULT == null ? editorCancelI18nLabelKey != null : !EDITOR_CANCEL_I1_8N_LABEL_KEY_EDEFAULT.equals(editorCancelI18nLabelKey);
+			case CxGridPackage.CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY:
+				return EDITOR_SAVE_I1_8N_LABEL_KEY_EDEFAULT == null ? editorSaveI18nLabelKey != null : !EDITOR_SAVE_I1_8N_LABEL_KEY_EDEFAULT.equals(editorSaveI18nLabelKey);
+			case CxGridPackage.CX_GRID__EDITOR_SAVED:
+				return EDITOR_SAVED_EDEFAULT == null ? editorSaved != null : !EDITOR_SAVED_EDEFAULT.equals(editorSaved);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param derivedFeatureID
+	 *            the derived feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YCollectionBindable.class) {
+			switch (derivedFeatureID) {
+				case CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT: return CoreModelPackage.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YSelectionBindable.class) {
+			switch (derivedFeatureID) {
+				case CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT: return CoreModelPackage.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YMultiSelectionBindable.class) {
+			switch (derivedFeatureID) {
+				case CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT: return CoreModelPackage.YMULTI_SELECTION_BINDABLE__MULTI_SELECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YBeanServiceConsumer.class) {
+			switch (derivedFeatureID) {
+				case CxGridPackage.CX_GRID__USE_BEAN_SERVICE: return ExtensionModelPackage.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param baseFeatureID
+	 *            the base feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YCollectionBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT: return CxGridPackage.CX_GRID__COLLECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YSelectionBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT: return CxGridPackage.CX_GRID__SELECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YMultiSelectionBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YMULTI_SELECTION_BINDABLE__MULTI_SELECTION_BINDING_ENDPOINT: return CxGridPackage.CX_GRID__MULTI_SELECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YBeanServiceConsumer.class) {
+			switch (baseFeatureID) {
+				case ExtensionModelPackage.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE: return CxGridPackage.CX_GRID__USE_BEAN_SERVICE;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (useBeanService: ");
+		result.append(useBeanService);
+		result.append(", selectionType: ");
+		result.append(selectionType);
+		result.append(", selectionEventTopic: ");
+		result.append(selectionEventTopic);
+		result.append(", selection: ");
+		result.append(selection);
+		result.append(", multiSelection: ");
+		result.append(multiSelection);
+		result.append(", collection: ");
+		result.append(collection);
+		result.append(", type: ");
+		result.append(type);
+		result.append(", emfNsURI: ");
+		result.append(emfNsURI);
+		result.append(", typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(", columnReorderingAllowed: ");
+		result.append(columnReorderingAllowed);
+		result.append(", filteringVisible: ");
+		result.append(filteringVisible);
+		result.append(", customFilters: ");
+		result.append(customFilters);
+		result.append(", headerVisible: ");
+		result.append(headerVisible);
+		result.append(", footerVisible: ");
+		result.append(footerVisible);
+		result.append(", editorEnabled: ");
+		result.append(editorEnabled);
+		result.append(", editorCancelI18nLabelKey: ");
+		result.append(editorCancelI18nLabelKey);
+		result.append(", editorSaveI18nLabelKey: ");
+		result.append(editorSaveI18nLabelKey);
+		result.append(", editorSaved: ");
+		result.append(editorSaved);
+		result.append(')');
+		return result.toString();
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridMetaCellImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridMetaCellImpl.java
new file mode 100644
index 0000000..5ca6c21
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridMetaCellImpl.java
@@ -0,0 +1,745 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Meta Cell</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getTarget <em>Target</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#isUseHTML <em>Use HTML</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridMetaCellImpl#getElement <em>Element</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridMetaCellImpl extends MinimalEObjectImpl.Container implements CxGridMetaCell {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getTarget() <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTarget()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridColumn target;
+
+	/**
+	 * The default value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected String label = LABEL_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_I1_8N_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String labelI18nKey = LABEL_I1_8N_KEY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isUseHTML() <em>Use HTML</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseHTML()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean USE_HTML_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isUseHTML() <em>Use HTML</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseHTML()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean useHTML = USE_HTML_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getElement() <em>Element</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getElement()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddable element;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridMetaCellImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_META_CELL;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridPackage.CX_GRID_META_CELL__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridPackage.CX_GRID_META_CELL__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTarget() <em>Target</em>}'
+	 *         reference
+	 * @generated
+	 */
+	public CxGridColumn getTarget() {
+		if (target != null && target.eIsProxy()) {
+			InternalEObject oldTarget = (InternalEObject)target;
+			target = (CxGridColumn)eResolveProxy(oldTarget);
+			if (target != oldTarget) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, CxGridPackage.CX_GRID_META_CELL__TARGET, oldTarget, target));
+			}
+		}
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column
+	 * @generated
+	 */
+	public CxGridColumn basicGetTarget() {
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTarget
+	 *            the new target
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetTarget(CxGridColumn newTarget, NotificationChain msgs) {
+		CxGridColumn oldTarget = target;
+		target = newTarget;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__TARGET, oldTarget, newTarget);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTarget
+	 *            the new cached value of the '{@link #getTarget()
+	 *            <em>Target</em>}' reference
+	 * @generated
+	 */
+	public void setTarget(CxGridColumn newTarget) {
+		if (newTarget != target) {
+			NotificationChain msgs = null;
+			if (target != null)
+				msgs = ((InternalEObject)target).eInverseRemove(this, CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS, CxGridColumn.class, msgs);
+			if (newTarget != null)
+				msgs = ((InternalEObject)newTarget).eInverseAdd(this, CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS, CxGridColumn.class, msgs);
+			msgs = basicSetTarget(newTarget, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__TARGET, newTarget, newTarget));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabel() <em>Label</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabel
+	 *            the new cached value of the '{@link #getLabel()
+	 *            <em>Label</em>}' attribute
+	 * @generated
+	 */
+	public void setLabel(String newLabel) {
+		String oldLabel = label;
+		label = newLabel;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__LABEL, oldLabel, label));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabelI18nKey()
+	 *         <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public String getLabelI18nKey() {
+		return labelI18nKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabelI18nKey
+	 *            the new cached value of the '{@link #getLabelI18nKey()
+	 *            <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public void setLabelI18nKey(String newLabelI18nKey) {
+		String oldLabelI18nKey = labelI18nKey;
+		labelI18nKey = newLabelI18nKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__LABEL_I1_8N_KEY, oldLabelI18nKey, labelI18nKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isUseHTML() <em>Use HTML</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isUseHTML() {
+		return useHTML;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newUseHTML
+	 *            the new cached value of the '{@link #isUseHTML()
+	 *            <em>Use HTML</em>}' attribute
+	 * @generated
+	 */
+	public void setUseHTML(boolean newUseHTML) {
+		boolean oldUseHTML = useHTML;
+		useHTML = newUseHTML;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__USE_HTML, oldUseHTML, useHTML));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getElement() <em>Element</em>}'
+	 *         containment reference
+	 * @generated
+	 */
+	public YEmbeddable getElement() {
+		return element;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newElement
+	 *            the new element
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetElement(YEmbeddable newElement, NotificationChain msgs) {
+		YEmbeddable oldElement = element;
+		element = newElement;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__ELEMENT, oldElement, newElement);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newElement
+	 *            the new cached value of the '{@link #getElement()
+	 *            <em>Element</em>}' containment reference
+	 * @generated
+	 */
+	public void setElement(YEmbeddable newElement) {
+		if (newElement != element) {
+			NotificationChain msgs = null;
+			if (element != null)
+				msgs = ((InternalEObject)element).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_META_CELL__ELEMENT, null, msgs);
+			if (newElement != null)
+				msgs = ((InternalEObject)newElement).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridPackage.CX_GRID_META_CELL__ELEMENT, null, msgs);
+			msgs = basicSetElement(newElement, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_META_CELL__ELEMENT, newElement, newElement));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_META_CELL__TARGET:
+				if (target != null)
+					msgs = ((InternalEObject)target).eInverseRemove(this, CxGridPackage.CX_GRID_COLUMN__USED_IN_META_CELLS, CxGridColumn.class, msgs);
+				return basicSetTarget((CxGridColumn)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_META_CELL__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case CxGridPackage.CX_GRID_META_CELL__TARGET:
+				return basicSetTarget(null, msgs);
+			case CxGridPackage.CX_GRID_META_CELL__ELEMENT:
+				return basicSetElement(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_META_CELL__TAGS:
+				return getTags();
+			case CxGridPackage.CX_GRID_META_CELL__ID:
+				return getId();
+			case CxGridPackage.CX_GRID_META_CELL__NAME:
+				return getName();
+			case CxGridPackage.CX_GRID_META_CELL__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case CxGridPackage.CX_GRID_META_CELL__TARGET:
+				if (resolve) return getTarget();
+				return basicGetTarget();
+			case CxGridPackage.CX_GRID_META_CELL__LABEL:
+				return getLabel();
+			case CxGridPackage.CX_GRID_META_CELL__LABEL_I1_8N_KEY:
+				return getLabelI18nKey();
+			case CxGridPackage.CX_GRID_META_CELL__USE_HTML:
+				return isUseHTML();
+			case CxGridPackage.CX_GRID_META_CELL__ELEMENT:
+				return getElement();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_META_CELL__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__ID:
+				setId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__TARGET:
+				setTarget((CxGridColumn)newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__LABEL:
+				setLabel((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__LABEL_I1_8N_KEY:
+				setLabelI18nKey((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__USE_HTML:
+				setUseHTML((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__ELEMENT:
+				setElement((YEmbeddable)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_META_CELL__TAGS:
+				getTags().clear();
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__PROPERTIES:
+				getProperties().clear();
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__TARGET:
+				setTarget((CxGridColumn)null);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__LABEL:
+				setLabel(LABEL_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__LABEL_I1_8N_KEY:
+				setLabelI18nKey(LABEL_I1_8N_KEY_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__USE_HTML:
+				setUseHTML(USE_HTML_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_META_CELL__ELEMENT:
+				setElement((YEmbeddable)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_META_CELL__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridPackage.CX_GRID_META_CELL__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridPackage.CX_GRID_META_CELL__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridPackage.CX_GRID_META_CELL__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case CxGridPackage.CX_GRID_META_CELL__TARGET:
+				return target != null;
+			case CxGridPackage.CX_GRID_META_CELL__LABEL:
+				return LABEL_EDEFAULT == null ? label != null : !LABEL_EDEFAULT.equals(label);
+			case CxGridPackage.CX_GRID_META_CELL__LABEL_I1_8N_KEY:
+				return LABEL_I1_8N_KEY_EDEFAULT == null ? labelI18nKey != null : !LABEL_I1_8N_KEY_EDEFAULT.equals(labelI18nKey);
+			case CxGridPackage.CX_GRID_META_CELL__USE_HTML:
+				return useHTML != USE_HTML_EDEFAULT;
+			case CxGridPackage.CX_GRID_META_CELL__ELEMENT:
+				return element != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", label: ");
+		result.append(label);
+		result.append(", labelI18nKey: ");
+		result.append(labelI18nKey);
+		result.append(", useHTML: ");
+		result.append(useHTML);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridPackageImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridPackageImpl.java
new file mode 100644
index 0000000..e67ec1c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridPackageImpl.java
@@ -0,0 +1,1191 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EGenericType;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFactory;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupable;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.CxGridProvider;
+import org.eclipse.osbp.ecview.extension.grid.CxGridSortable;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+import org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridPackageImpl extends EPackageImpl implements CxGridPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridProviderEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridMetaRowEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridHeaderRowEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridFooterRowEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridFilterRowEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridGroupableEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridMetaCellEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridGroupedCellEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridColumnEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridCellStyleGeneratorEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridDelegateCellStyleGeneratorEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridSortableEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private CxGridPackageImpl() {
+		super(eNS_URI, CxGridFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model,
+	 * and for any others upon which it depends.
+	 * 
+	 * <p>
+	 * This method is used to initialize {@link CxGridPackage#eINSTANCE} when
+	 * that field is accessed. Clients should not invoke it directly. Instead,
+	 * they should simply access that field to obtain the package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the cx grid package
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static CxGridPackage init() {
+		if (isInited) return (CxGridPackage)EPackage.Registry.INSTANCE.getEPackage(CxGridPackage.eNS_URI);
+
+		// Obtain or create and register package
+		CxGridPackageImpl theCxGridPackage = (CxGridPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof CxGridPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new CxGridPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		ExtDatatypesPackage.eINSTANCE.eClass();
+		ExtensionModelPackage.eINSTANCE.eClass();
+
+		// Obtain or create and register interdependencies
+		CxGridRendererPackageImpl theCxGridRendererPackage = (CxGridRendererPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(CxGridRendererPackage.eNS_URI) instanceof CxGridRendererPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(CxGridRendererPackage.eNS_URI) : CxGridRendererPackage.eINSTANCE);
+		CxGridMementoPackageImpl theCxGridMementoPackage = (CxGridMementoPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(CxGridMementoPackage.eNS_URI) instanceof CxGridMementoPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(CxGridMementoPackage.eNS_URI) : CxGridMementoPackage.eINSTANCE);
+
+		// Create package meta-data objects
+		theCxGridPackage.createPackageContents();
+		theCxGridRendererPackage.createPackageContents();
+		theCxGridMementoPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theCxGridPackage.initializePackageContents();
+		theCxGridRendererPackage.initializePackageContents();
+		theCxGridMementoPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theCxGridPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(CxGridPackage.eNS_URI, theCxGridPackage);
+		return theCxGridPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid
+	 * @generated
+	 */
+	public EClass getCxGrid() {
+		return cxGridEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ selection type
+	 * @generated
+	 */
+	public EAttribute getCxGrid_SelectionType() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ selection event topic
+	 * @generated
+	 */
+	public EAttribute getCxGrid_SelectionEventTopic() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ selection
+	 * @generated
+	 */
+	public EAttribute getCxGrid_Selection() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ multi selection
+	 * @generated
+	 */
+	public EAttribute getCxGrid_MultiSelection() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ collection
+	 * @generated
+	 */
+	public EAttribute getCxGrid_Collection() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ type
+	 * @generated
+	 */
+	public EAttribute getCxGrid_Type() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ emf ns uri
+	 * @generated
+	 */
+	public EAttribute getCxGrid_EmfNsURI() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ type qualified name
+	 * @generated
+	 */
+	public EAttribute getCxGrid_TypeQualifiedName() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(7);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ editor enabled
+	 * @generated
+	 */
+	public EAttribute getCxGrid_EditorEnabled() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(18);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ cell style generator
+	 * @generated
+	 */
+	public EReference getCxGrid_CellStyleGenerator() {
+		return (EReference)cxGridEClass.getEStructuralFeatures().get(11);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ filtering visible
+	 * @generated
+	 */
+	public EAttribute getCxGrid_FilteringVisible() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(12);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ custom filters
+	 * @generated
+	 */
+	public EAttribute getCxGrid_CustomFilters() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(13);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ headers
+	 * @generated
+	 */
+	public EReference getCxGrid_Headers() {
+		return (EReference)cxGridEClass.getEStructuralFeatures().get(14);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ columns
+	 * @generated
+	 */
+	public EReference getCxGrid_Columns() {
+		return (EReference)cxGridEClass.getEStructuralFeatures().get(8);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ sort order
+	 * @generated
+	 */
+	public EReference getCxGrid_SortOrder() {
+		return (EReference)cxGridEClass.getEStructuralFeatures().get(9);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ column reordering allowed
+	 * @generated
+	 */
+	public EAttribute getCxGrid_ColumnReorderingAllowed() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(10);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ footer visible
+	 * @generated
+	 */
+	public EAttribute getCxGrid_FooterVisible() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(17);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ header visible
+	 * @generated
+	 */
+	public EAttribute getCxGrid_HeaderVisible() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(15);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ footers
+	 * @generated
+	 */
+	public EReference getCxGrid_Footers() {
+		return (EReference)cxGridEClass.getEStructuralFeatures().get(16);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ editor cancel i18n label key
+	 * @generated
+	 */
+	public EAttribute getCxGrid_EditorCancelI18nLabelKey() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(19);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ editor save i18n label key
+	 * @generated
+	 */
+	public EAttribute getCxGrid_EditorSaveI18nLabelKey() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(20);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid_ editor saved
+	 * @generated
+	 */
+	public EAttribute getCxGrid_EditorSaved() {
+		return (EAttribute)cxGridEClass.getEStructuralFeatures().get(21);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid provider
+	 * @generated
+	 */
+	public EClass getCxGridProvider() {
+		return cxGridProviderEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta row
+	 * @generated
+	 */
+	public EClass getCxGridMetaRow() {
+		return cxGridMetaRowEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta row_ groupings
+	 * @generated
+	 */
+	public EReference getCxGridMetaRow_Groupings() {
+		return (EReference)cxGridMetaRowEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta row_ custom cells
+	 * @generated
+	 */
+	public EReference getCxGridMetaRow_CustomCells() {
+		return (EReference)cxGridMetaRowEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid header row
+	 * @generated
+	 */
+	public EClass getCxGridHeaderRow() {
+		return cxGridHeaderRowEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid footer row
+	 * @generated
+	 */
+	public EClass getCxGridFooterRow() {
+		return cxGridFooterRowEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid filter row
+	 * @generated
+	 */
+	public EClass getCxGridFilterRow() {
+		return cxGridFilterRowEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid groupable
+	 * @generated
+	 */
+	public EClass getCxGridGroupable() {
+		return cxGridGroupableEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta cell
+	 * @generated
+	 */
+	public EClass getCxGridMetaCell() {
+		return cxGridMetaCellEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta cell_ target
+	 * @generated
+	 */
+	public EReference getCxGridMetaCell_Target() {
+		return (EReference)cxGridMetaCellEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta cell_ label
+	 * @generated
+	 */
+	public EAttribute getCxGridMetaCell_Label() {
+		return (EAttribute)cxGridMetaCellEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta cell_ label i18n key
+	 * @generated
+	 */
+	public EAttribute getCxGridMetaCell_LabelI18nKey() {
+		return (EAttribute)cxGridMetaCellEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta cell_ use html
+	 * @generated
+	 */
+	public EAttribute getCxGridMetaCell_UseHTML() {
+		return (EAttribute)cxGridMetaCellEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid meta cell_ element
+	 * @generated
+	 */
+	public EReference getCxGridMetaCell_Element() {
+		return (EReference)cxGridMetaCellEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid grouped cell
+	 * @generated
+	 */
+	public EClass getCxGridGroupedCell() {
+		return cxGridGroupedCellEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid grouped cell_ groupables
+	 * @generated
+	 */
+	public EReference getCxGridGroupedCell_Groupables() {
+		return (EReference)cxGridGroupedCellEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid grouped cell_ label
+	 * @generated
+	 */
+	public EAttribute getCxGridGroupedCell_Label() {
+		return (EAttribute)cxGridGroupedCellEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid grouped cell_ label i18n key
+	 * @generated
+	 */
+	public EAttribute getCxGridGroupedCell_LabelI18nKey() {
+		return (EAttribute)cxGridGroupedCellEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid grouped cell_ use html
+	 * @generated
+	 */
+	public EAttribute getCxGridGroupedCell_UseHTML() {
+		return (EAttribute)cxGridGroupedCellEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column
+	 * @generated
+	 */
+	public EClass getCxGridColumn() {
+		return cxGridColumnEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ property id
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_PropertyId() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ converter
+	 * @generated
+	 */
+	public EReference getCxGridColumn_Converter() {
+		return (EReference)cxGridColumnEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ renderer
+	 * @generated
+	 */
+	public EReference getCxGridColumn_Renderer() {
+		return (EReference)cxGridColumnEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ editor field
+	 * @generated
+	 */
+	public EReference getCxGridColumn_EditorField() {
+		return (EReference)cxGridColumnEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ search field
+	 * @generated
+	 */
+	public EReference getCxGridColumn_SearchField() {
+		return (EReference)cxGridColumnEClass.getEStructuralFeatures().get(7);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ header caption
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_HeaderCaption() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(8);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ header caption i18n key
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_HeaderCaptionI18nKey() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(9);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ expand ratio
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_ExpandRatio() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(10);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ hidden
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_Hidden() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(11);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ hideable
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_Hideable() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(12);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ sortable
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_Sortable() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(13);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ property path
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_PropertyPath() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(14);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ width
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_Width() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(15);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ label
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_Label() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ label i18n key
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_LabelI18nKey() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ editable
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_Editable() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ min width pixels
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_MinWidthPixels() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(16);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ max width pixels
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_MaxWidthPixels() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(17);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ used in meta cells
+	 * @generated
+	 */
+	public EReference getCxGridColumn_UsedInMetaCells() {
+		return (EReference)cxGridColumnEClass.getEStructuralFeatures().get(18);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ type
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_Type() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(19);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column_ type qualified name
+	 * @generated
+	 */
+	public EAttribute getCxGridColumn_TypeQualifiedName() {
+		return (EAttribute)cxGridColumnEClass.getEStructuralFeatures().get(20);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid cell style generator
+	 * @generated
+	 */
+	public EClass getCxGridCellStyleGenerator() {
+		return cxGridCellStyleGeneratorEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid delegate cell style generator
+	 * @generated
+	 */
+	public EClass getCxGridDelegateCellStyleGenerator() {
+		return cxGridDelegateCellStyleGeneratorEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid delegate cell style generator_ delegate id
+	 * @generated
+	 */
+	public EAttribute getCxGridDelegateCellStyleGenerator_DelegateId() {
+		return (EAttribute)cxGridDelegateCellStyleGeneratorEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid sortable
+	 * @generated
+	 */
+	public EClass getCxGridSortable() {
+		return cxGridSortableEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid sortable_ descending
+	 * @generated
+	 */
+	public EAttribute getCxGridSortable_Descending() {
+		return (EAttribute)cxGridSortableEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid sortable_ column
+	 * @generated
+	 */
+	public EReference getCxGridSortable_Column() {
+		return (EReference)cxGridSortableEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid factory
+	 * @generated
+	 */
+	public CxGridFactory getCxGridFactory() {
+		return (CxGridFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		cxGridEClass = createEClass(CX_GRID);
+		createEAttribute(cxGridEClass, CX_GRID__SELECTION_TYPE);
+		createEAttribute(cxGridEClass, CX_GRID__SELECTION_EVENT_TOPIC);
+		createEAttribute(cxGridEClass, CX_GRID__SELECTION);
+		createEAttribute(cxGridEClass, CX_GRID__MULTI_SELECTION);
+		createEAttribute(cxGridEClass, CX_GRID__COLLECTION);
+		createEAttribute(cxGridEClass, CX_GRID__TYPE);
+		createEAttribute(cxGridEClass, CX_GRID__EMF_NS_URI);
+		createEAttribute(cxGridEClass, CX_GRID__TYPE_QUALIFIED_NAME);
+		createEReference(cxGridEClass, CX_GRID__COLUMNS);
+		createEReference(cxGridEClass, CX_GRID__SORT_ORDER);
+		createEAttribute(cxGridEClass, CX_GRID__COLUMN_REORDERING_ALLOWED);
+		createEReference(cxGridEClass, CX_GRID__CELL_STYLE_GENERATOR);
+		createEAttribute(cxGridEClass, CX_GRID__FILTERING_VISIBLE);
+		createEAttribute(cxGridEClass, CX_GRID__CUSTOM_FILTERS);
+		createEReference(cxGridEClass, CX_GRID__HEADERS);
+		createEAttribute(cxGridEClass, CX_GRID__HEADER_VISIBLE);
+		createEReference(cxGridEClass, CX_GRID__FOOTERS);
+		createEAttribute(cxGridEClass, CX_GRID__FOOTER_VISIBLE);
+		createEAttribute(cxGridEClass, CX_GRID__EDITOR_ENABLED);
+		createEAttribute(cxGridEClass, CX_GRID__EDITOR_CANCEL_I1_8N_LABEL_KEY);
+		createEAttribute(cxGridEClass, CX_GRID__EDITOR_SAVE_I1_8N_LABEL_KEY);
+		createEAttribute(cxGridEClass, CX_GRID__EDITOR_SAVED);
+
+		cxGridProviderEClass = createEClass(CX_GRID_PROVIDER);
+
+		cxGridMetaRowEClass = createEClass(CX_GRID_META_ROW);
+		createEReference(cxGridMetaRowEClass, CX_GRID_META_ROW__GROUPINGS);
+		createEReference(cxGridMetaRowEClass, CX_GRID_META_ROW__CUSTOM_CELLS);
+
+		cxGridHeaderRowEClass = createEClass(CX_GRID_HEADER_ROW);
+
+		cxGridFooterRowEClass = createEClass(CX_GRID_FOOTER_ROW);
+
+		cxGridFilterRowEClass = createEClass(CX_GRID_FILTER_ROW);
+
+		cxGridGroupableEClass = createEClass(CX_GRID_GROUPABLE);
+
+		cxGridMetaCellEClass = createEClass(CX_GRID_META_CELL);
+		createEReference(cxGridMetaCellEClass, CX_GRID_META_CELL__TARGET);
+		createEAttribute(cxGridMetaCellEClass, CX_GRID_META_CELL__LABEL);
+		createEAttribute(cxGridMetaCellEClass, CX_GRID_META_CELL__LABEL_I1_8N_KEY);
+		createEAttribute(cxGridMetaCellEClass, CX_GRID_META_CELL__USE_HTML);
+		createEReference(cxGridMetaCellEClass, CX_GRID_META_CELL__ELEMENT);
+
+		cxGridGroupedCellEClass = createEClass(CX_GRID_GROUPED_CELL);
+		createEReference(cxGridGroupedCellEClass, CX_GRID_GROUPED_CELL__GROUPABLES);
+		createEAttribute(cxGridGroupedCellEClass, CX_GRID_GROUPED_CELL__LABEL);
+		createEAttribute(cxGridGroupedCellEClass, CX_GRID_GROUPED_CELL__LABEL_I1_8N_KEY);
+		createEAttribute(cxGridGroupedCellEClass, CX_GRID_GROUPED_CELL__USE_HTML);
+
+		cxGridColumnEClass = createEClass(CX_GRID_COLUMN);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__PROPERTY_ID);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__LABEL);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__LABEL_I1_8N_KEY);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__EDITABLE);
+		createEReference(cxGridColumnEClass, CX_GRID_COLUMN__CONVERTER);
+		createEReference(cxGridColumnEClass, CX_GRID_COLUMN__RENDERER);
+		createEReference(cxGridColumnEClass, CX_GRID_COLUMN__EDITOR_FIELD);
+		createEReference(cxGridColumnEClass, CX_GRID_COLUMN__SEARCH_FIELD);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__HEADER_CAPTION);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__HEADER_CAPTION_I1_8N_KEY);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__EXPAND_RATIO);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__HIDDEN);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__HIDEABLE);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__SORTABLE);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__PROPERTY_PATH);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__WIDTH);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__MIN_WIDTH_PIXELS);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__MAX_WIDTH_PIXELS);
+		createEReference(cxGridColumnEClass, CX_GRID_COLUMN__USED_IN_META_CELLS);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__TYPE);
+		createEAttribute(cxGridColumnEClass, CX_GRID_COLUMN__TYPE_QUALIFIED_NAME);
+
+		cxGridCellStyleGeneratorEClass = createEClass(CX_GRID_CELL_STYLE_GENERATOR);
+
+		cxGridDelegateCellStyleGeneratorEClass = createEClass(CX_GRID_DELEGATE_CELL_STYLE_GENERATOR);
+		createEAttribute(cxGridDelegateCellStyleGeneratorEClass, CX_GRID_DELEGATE_CELL_STYLE_GENERATOR__DELEGATE_ID);
+
+		cxGridSortableEClass = createEClass(CX_GRID_SORTABLE);
+		createEAttribute(cxGridSortableEClass, CX_GRID_SORTABLE__DESCENDING);
+		createEReference(cxGridSortableEClass, CX_GRID_SORTABLE__COLUMN);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		CxGridRendererPackage theCxGridRendererPackage = (CxGridRendererPackage)EPackage.Registry.INSTANCE.getEPackage(CxGridRendererPackage.eNS_URI);
+		CxGridMementoPackage theCxGridMementoPackage = (CxGridMementoPackage)EPackage.Registry.INSTANCE.getEPackage(CxGridMementoPackage.eNS_URI);
+		ExtensionModelPackage theExtensionModelPackage = (ExtensionModelPackage)EPackage.Registry.INSTANCE.getEPackage(ExtensionModelPackage.eNS_URI);
+		CoreModelPackage theCoreModelPackage = (CoreModelPackage)EPackage.Registry.INSTANCE.getEPackage(CoreModelPackage.eNS_URI);
+
+		// Add subpackages
+		getESubpackages().add(theCxGridRendererPackage);
+		getESubpackages().add(theCxGridMementoPackage);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		cxGridEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		cxGridEClass.getESuperTypes().add(theCoreModelPackage.getYCollectionBindable());
+		cxGridEClass.getESuperTypes().add(theCoreModelPackage.getYSelectionBindable());
+		cxGridEClass.getESuperTypes().add(theCoreModelPackage.getYMultiSelectionBindable());
+		cxGridEClass.getESuperTypes().add(theExtensionModelPackage.getYBeanServiceConsumer());
+		cxGridMetaRowEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		cxGridMetaRowEClass.getESuperTypes().add(this.getCxGridProvider());
+		cxGridHeaderRowEClass.getESuperTypes().add(this.getCxGridMetaRow());
+		cxGridFooterRowEClass.getESuperTypes().add(this.getCxGridMetaRow());
+		cxGridFilterRowEClass.getESuperTypes().add(this.getCxGridMetaRow());
+		cxGridGroupableEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		cxGridGroupableEClass.getESuperTypes().add(this.getCxGridProvider());
+		cxGridMetaCellEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		cxGridMetaCellEClass.getESuperTypes().add(this.getCxGridProvider());
+		cxGridGroupedCellEClass.getESuperTypes().add(this.getCxGridGroupable());
+		cxGridColumnEClass.getESuperTypes().add(this.getCxGridGroupable());
+		cxGridColumnEClass.getESuperTypes().add(theCoreModelPackage.getYHelperLayoutProvider());
+		cxGridCellStyleGeneratorEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		cxGridCellStyleGeneratorEClass.getESuperTypes().add(this.getCxGridProvider());
+		cxGridDelegateCellStyleGeneratorEClass.getESuperTypes().add(this.getCxGridCellStyleGenerator());
+		cxGridSortableEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(cxGridEClass, CxGrid.class, "CxGrid", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGrid_SelectionType(), theExtensionModelPackage.getYSelectionType(), "selectionType", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_SelectionEventTopic(), ecorePackage.getEString(), "selectionEventTopic", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_Selection(), ecorePackage.getEJavaObject(), "selection", null, 0, 1, CxGrid.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_MultiSelection(), ecorePackage.getEJavaObject(), "multiSelection", null, 0, -1, CxGrid.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_Collection(), ecorePackage.getEJavaObject(), "collection", null, 0, -1, CxGrid.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		EGenericType g1 = createEGenericType(ecorePackage.getEJavaClass());
+		EGenericType g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getCxGrid_Type(), g1, "type", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_EmfNsURI(), ecorePackage.getEString(), "emfNsURI", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGrid_Columns(), this.getCxGridColumn(), null, "columns", null, 0, -1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGrid_SortOrder(), this.getCxGridSortable(), null, "sortOrder", null, 0, -1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_ColumnReorderingAllowed(), ecorePackage.getEBoolean(), "columnReorderingAllowed", "true", 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGrid_CellStyleGenerator(), this.getCxGridCellStyleGenerator(), null, "cellStyleGenerator", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_FilteringVisible(), ecorePackage.getEBoolean(), "filteringVisible", null, 0, 1, CxGrid.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_CustomFilters(), ecorePackage.getEBoolean(), "customFilters", "false", 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGrid_Headers(), this.getCxGridHeaderRow(), null, "headers", null, 0, -1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_HeaderVisible(), ecorePackage.getEBoolean(), "headerVisible", "true", 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGrid_Footers(), this.getCxGridFooterRow(), null, "footers", null, 0, -1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_FooterVisible(), ecorePackage.getEBoolean(), "footerVisible", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_EditorEnabled(), ecorePackage.getEBoolean(), "editorEnabled", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_EditorCancelI18nLabelKey(), ecorePackage.getEString(), "editorCancelI18nLabelKey", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_EditorSaveI18nLabelKey(), ecorePackage.getEString(), "editorSaveI18nLabelKey", null, 0, 1, CxGrid.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGrid_EditorSaved(), ecorePackage.getEJavaObject(), "editorSaved", null, 0, 1, CxGrid.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		addEOperation(cxGridEClass, theCoreModelPackage.getYHelperLayout(), "createEditorFieldHelperLayout", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(cxGridProviderEClass, CxGridProvider.class, "CxGridProvider", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridMetaRowEClass, CxGridMetaRow.class, "CxGridMetaRow", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getCxGridMetaRow_Groupings(), this.getCxGridGroupedCell(), null, "groupings", null, 0, -1, CxGridMetaRow.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridMetaRow_CustomCells(), this.getCxGridMetaCell(), null, "customCells", null, 0, -1, CxGridMetaRow.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridHeaderRowEClass, CxGridHeaderRow.class, "CxGridHeaderRow", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridFooterRowEClass, CxGridFooterRow.class, "CxGridFooterRow", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridFilterRowEClass, CxGridFilterRow.class, "CxGridFilterRow", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridGroupableEClass, CxGridGroupable.class, "CxGridGroupable", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridMetaCellEClass, CxGridMetaCell.class, "CxGridMetaCell", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getCxGridMetaCell_Target(), this.getCxGridColumn(), this.getCxGridColumn_UsedInMetaCells(), "target", null, 0, 1, CxGridMetaCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMetaCell_Label(), ecorePackage.getEString(), "label", null, 0, 1, CxGridMetaCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMetaCell_LabelI18nKey(), ecorePackage.getEString(), "labelI18nKey", null, 0, 1, CxGridMetaCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMetaCell_UseHTML(), ecorePackage.getEBoolean(), "useHTML", null, 0, 1, CxGridMetaCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridMetaCell_Element(), theCoreModelPackage.getYEmbeddable(), null, "element", null, 0, 1, CxGridMetaCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridGroupedCellEClass, CxGridGroupedCell.class, "CxGridGroupedCell", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getCxGridGroupedCell_Groupables(), this.getCxGridGroupable(), null, "groupables", null, 0, -1, CxGridGroupedCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridGroupedCell_Label(), ecorePackage.getEString(), "label", null, 0, 1, CxGridGroupedCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridGroupedCell_LabelI18nKey(), ecorePackage.getEString(), "labelI18nKey", null, 0, 1, CxGridGroupedCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridGroupedCell_UseHTML(), ecorePackage.getEBoolean(), "useHTML", null, 0, 1, CxGridGroupedCell.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridColumnEClass, CxGridColumn.class, "CxGridColumn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridColumn_PropertyId(), ecorePackage.getEString(), "propertyId", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_Label(), ecorePackage.getEString(), "label", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_LabelI18nKey(), ecorePackage.getEString(), "labelI18nKey", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_Editable(), ecorePackage.getEBoolean(), "editable", "false", 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridColumn_Converter(), theCoreModelPackage.getYConverter(), null, "converter", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridColumn_Renderer(), theCxGridRendererPackage.getCxGridRenderer(), null, "renderer", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridColumn_EditorField(), theCoreModelPackage.getYField(), null, "editorField", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridColumn_SearchField(), theExtensionModelPackage.getYSearchField(), null, "searchField", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_HeaderCaption(), ecorePackage.getEString(), "headerCaption", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_HeaderCaptionI18nKey(), ecorePackage.getEString(), "headerCaptionI18nKey", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_ExpandRatio(), ecorePackage.getEInt(), "expandRatio", "-1", 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_Hidden(), ecorePackage.getEBoolean(), "hidden", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_Hideable(), ecorePackage.getEBoolean(), "hideable", "true", 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_Sortable(), ecorePackage.getEBoolean(), "sortable", "true", 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_PropertyPath(), ecorePackage.getEString(), "propertyPath", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_Width(), ecorePackage.getEInt(), "width", "-1", 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_MinWidthPixels(), ecorePackage.getEInt(), "minWidthPixels", "-1", 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_MaxWidthPixels(), ecorePackage.getEInt(), "maxWidthPixels", "-1", 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridColumn_UsedInMetaCells(), this.getCxGridMetaCell(), this.getCxGridMetaCell_Target(), "usedInMetaCells", null, 0, -1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEJavaClass());
+		g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getCxGridColumn_Type(), g1, "type", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridColumn_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, CxGridColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridCellStyleGeneratorEClass, CxGridCellStyleGenerator.class, "CxGridCellStyleGenerator", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridDelegateCellStyleGeneratorEClass, CxGridDelegateCellStyleGenerator.class, "CxGridDelegateCellStyleGenerator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridDelegateCellStyleGenerator_DelegateId(), ecorePackage.getEString(), "delegateId", null, 1, 1, CxGridDelegateCellStyleGenerator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridSortableEClass, CxGridSortable.class, "CxGridSortable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridSortable_Descending(), ecorePackage.getEBoolean(), "descending", "false", 0, 1, CxGridSortable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridSortable_Column(), this.getCxGridColumn(), null, "column", null, 1, 1, CxGridSortable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		// Create resource
+		createResource(eNS_URI);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridSortableImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridSortableImpl.java
new file mode 100644
index 0000000..e57b30b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/impl/CxGridSortableImpl.java
@@ -0,0 +1,495 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.CxGridSortable;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Sortable</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl#isDescending <em>Descending</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.impl.CxGridSortableImpl#getColumn <em>Column</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridSortableImpl extends MinimalEObjectImpl.Container implements CxGridSortable {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #isDescending() <em>Descending</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isDescending()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean DESCENDING_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isDescending() <em>Descending</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isDescending()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean descending = DESCENDING_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getColumn() <em>Column</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getColumn()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridColumn column;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridSortableImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridPackage.Literals.CX_GRID_SORTABLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_SORTABLE__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_SORTABLE__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridPackage.CX_GRID_SORTABLE__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridPackage.CX_GRID_SORTABLE__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isDescending()
+	 *         <em>Descending</em>}' attribute
+	 * @generated
+	 */
+	public boolean isDescending() {
+		return descending;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDescending
+	 *            the new cached value of the '{@link #isDescending()
+	 *            <em>Descending</em>}' attribute
+	 * @generated
+	 */
+	public void setDescending(boolean newDescending) {
+		boolean oldDescending = descending;
+		descending = newDescending;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_SORTABLE__DESCENDING, oldDescending, descending));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getColumn() <em>Column</em>}'
+	 *         reference
+	 * @generated
+	 */
+	public CxGridColumn getColumn() {
+		if (column != null && column.eIsProxy()) {
+			InternalEObject oldColumn = (InternalEObject)column;
+			column = (CxGridColumn)eResolveProxy(oldColumn);
+			if (column != oldColumn) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, CxGridPackage.CX_GRID_SORTABLE__COLUMN, oldColumn, column));
+			}
+		}
+		return column;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid column
+	 * @generated
+	 */
+	public CxGridColumn basicGetColumn() {
+		return column;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newColumn
+	 *            the new cached value of the '{@link #getColumn()
+	 *            <em>Column</em>}' reference
+	 * @generated
+	 */
+	public void setColumn(CxGridColumn newColumn) {
+		CxGridColumn oldColumn = column;
+		column = newColumn;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridPackage.CX_GRID_SORTABLE__COLUMN, oldColumn, column));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_SORTABLE__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_SORTABLE__TAGS:
+				return getTags();
+			case CxGridPackage.CX_GRID_SORTABLE__ID:
+				return getId();
+			case CxGridPackage.CX_GRID_SORTABLE__NAME:
+				return getName();
+			case CxGridPackage.CX_GRID_SORTABLE__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case CxGridPackage.CX_GRID_SORTABLE__DESCENDING:
+				return isDescending();
+			case CxGridPackage.CX_GRID_SORTABLE__COLUMN:
+				if (resolve) return getColumn();
+				return basicGetColumn();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_SORTABLE__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__ID:
+				setId((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__DESCENDING:
+				setDescending((Boolean)newValue);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__COLUMN:
+				setColumn((CxGridColumn)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_SORTABLE__TAGS:
+				getTags().clear();
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__PROPERTIES:
+				getProperties().clear();
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__DESCENDING:
+				setDescending(DESCENDING_EDEFAULT);
+				return;
+			case CxGridPackage.CX_GRID_SORTABLE__COLUMN:
+				setColumn((CxGridColumn)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridPackage.CX_GRID_SORTABLE__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridPackage.CX_GRID_SORTABLE__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridPackage.CX_GRID_SORTABLE__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridPackage.CX_GRID_SORTABLE__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case CxGridPackage.CX_GRID_SORTABLE__DESCENDING:
+				return descending != DESCENDING_EDEFAULT;
+			case CxGridPackage.CX_GRID_SORTABLE__COLUMN:
+				return column != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", descending: ");
+		result.append(descending);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMemento.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMemento.java
new file mode 100644
index 0000000..4798600
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMemento.java
@@ -0,0 +1,206 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.core.YMemento;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Memento</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getGridId <em>Grid Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isHeaderVisible <em>Header Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFilterVisible <em>Filter Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFooterVisible <em>Footer Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isEditorEnabled <em>Editor Enabled</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getColumns <em>Columns</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getSortOrders <em>Sort Orders</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento()
+ * @model
+ * @generated
+ */
+public interface CxGridMemento extends YMemento {
+	
+	/**
+	 * Returns the value of the '<em><b>Grid Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Grid Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Grid Id</em>' attribute.
+	 * @see #setGridId(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento_GridId()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getGridId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getGridId <em>Grid Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Grid Id</em>' attribute.
+	 * @see #getGridId()
+	 * @generated
+	 */
+	void setGridId(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Header Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Header Visible</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Header Visible</em>' attribute.
+	 * @see #setHeaderVisible(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento_HeaderVisible()
+	 * @model
+	 * @generated
+	 */
+	boolean isHeaderVisible();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isHeaderVisible <em>Header Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Header Visible</em>' attribute.
+	 * @see #isHeaderVisible()
+	 * @generated
+	 */
+	void setHeaderVisible(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Filter Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Filter Visible</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Filter Visible</em>' attribute.
+	 * @see #setFilterVisible(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento_FilterVisible()
+	 * @model
+	 * @generated
+	 */
+	boolean isFilterVisible();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFilterVisible <em>Filter Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Filter Visible</em>' attribute.
+	 * @see #isFilterVisible()
+	 * @generated
+	 */
+	void setFilterVisible(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Footer Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Footer Visible</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Footer Visible</em>' attribute.
+	 * @see #setFooterVisible(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento_FooterVisible()
+	 * @model
+	 * @generated
+	 */
+	boolean isFooterVisible();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFooterVisible <em>Footer Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Footer Visible</em>' attribute.
+	 * @see #isFooterVisible()
+	 * @generated
+	 */
+	void setFooterVisible(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Editor Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editor Enabled</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Editor Enabled</em>' attribute.
+	 * @see #setEditorEnabled(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento_EditorEnabled()
+	 * @model
+	 * @generated
+	 */
+	boolean isEditorEnabled();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isEditorEnabled <em>Editor Enabled</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Editor Enabled</em>' attribute.
+	 * @see #isEditorEnabled()
+	 * @generated
+	 */
+	void setEditorEnabled(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Columns</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Columns</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Columns</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento_Columns()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridMementoColumn> getColumns();
+
+	/**
+	 * Returns the value of the '<em><b>Sort Orders</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Sort Orders</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Sort Orders</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMemento_SortOrders()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<CxGridMementoSortable> getSortOrders();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoColumn.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoColumn.java
new file mode 100644
index 0000000..e5ea4b3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoColumn.java
@@ -0,0 +1,231 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Column</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getPropertyId <em>Property Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isEditable <em>Editable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getExpandRatio <em>Expand Ratio</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHidden <em>Hidden</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHideable <em>Hideable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isSortable <em>Sortable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getWidth <em>Width</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn()
+ * @model
+ * @generated
+ */
+public interface CxGridMementoColumn extends EObject {
+	
+	/**
+	 * Returns the value of the '<em><b>Property Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Property Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Property Id</em>' attribute.
+	 * @see #setPropertyId(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn_PropertyId()
+	 * @model
+	 * @generated
+	 */
+	String getPropertyId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getPropertyId <em>Property Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Property Id</em>' attribute.
+	 * @see #getPropertyId()
+	 * @generated
+	 */
+	void setPropertyId(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Editable</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Editable</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Editable</em>' attribute.
+	 * @see #setEditable(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn_Editable()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isEditable();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isEditable <em>Editable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Editable</em>' attribute.
+	 * @see #isEditable()
+	 * @generated
+	 */
+	void setEditable(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Expand Ratio</b></em>' attribute.
+	 * The default value is <code>"-1"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Expand Ratio</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Expand Ratio</em>' attribute.
+	 * @see #setExpandRatio(int)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn_ExpandRatio()
+	 * @model default="-1"
+	 * @generated
+	 */
+	int getExpandRatio();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getExpandRatio <em>Expand Ratio</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Expand Ratio</em>' attribute.
+	 * @see #getExpandRatio()
+	 * @generated
+	 */
+	void setExpandRatio(int value);
+
+	/**
+	 * Returns the value of the '<em><b>Hidden</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Hidden</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Hidden</em>' attribute.
+	 * @see #setHidden(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn_Hidden()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isHidden();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHidden <em>Hidden</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Hidden</em>' attribute.
+	 * @see #isHidden()
+	 * @generated
+	 */
+	void setHidden(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Hideable</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Hideable</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Hideable</em>' attribute.
+	 * @see #setHideable(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn_Hideable()
+	 * @model default="true"
+	 * @generated
+	 */
+	boolean isHideable();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHideable <em>Hideable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Hideable</em>' attribute.
+	 * @see #isHideable()
+	 * @generated
+	 */
+	void setHideable(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Sortable</b></em>' attribute.
+	 * The default value is <code>"true"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Sortable</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Sortable</em>' attribute.
+	 * @see #setSortable(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn_Sortable()
+	 * @model default="true"
+	 * @generated
+	 */
+	boolean isSortable();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isSortable <em>Sortable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Sortable</em>' attribute.
+	 * @see #isSortable()
+	 * @generated
+	 */
+	void setSortable(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Width</b></em>' attribute.
+	 * The default value is <code>"-1"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Width</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Width</em>' attribute.
+	 * @see #setWidth(int)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoColumn_Width()
+	 * @model default="-1"
+	 * @generated
+	 */
+	int getWidth();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getWidth <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Width</em>' attribute.
+	 * @see #getWidth()
+	 * @generated
+	 */
+	void setWidth(int value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoFactory.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoFactory.java
new file mode 100644
index 0000000..378f8eb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoFactory.java
@@ -0,0 +1,73 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage
+ * @generated
+ */
+public interface CxGridMementoFactory extends EFactory {
+	
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	CxGridMementoFactory eINSTANCE = org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Memento</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Memento</em>'.
+	 * @generated
+	 */
+	CxGridMemento createCxGridMemento();
+
+	/**
+	 * Returns a new object of class '<em>Column</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Column</em>'.
+	 * @generated
+	 */
+	CxGridMementoColumn createCxGridMementoColumn();
+
+	/**
+	 * Returns a new object of class '<em>Sortable</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Sortable</em>'.
+	 * @generated
+	 */
+	CxGridMementoSortable createCxGridMementoSortable();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	CxGridMementoPackage getCxGridMementoPackage();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoPackage.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoPackage.java
new file mode 100644
index 0000000..38b4540
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoPackage.java
@@ -0,0 +1,698 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface CxGridMementoPackage extends EPackage {
+	
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "memento";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://osbp.de/ecview/v1/extension/grid/memento";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "memento";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	CxGridMementoPackage eINSTANCE = org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl <em>Cx Grid Memento</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl#getCxGridMemento()
+	 * @generated
+	 */
+	int CX_GRID_MEMENTO = 0;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__TAGS = CoreModelPackage.YMEMENTO__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__ID = CoreModelPackage.YMEMENTO__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__NAME = CoreModelPackage.YMEMENTO__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__PROPERTIES = CoreModelPackage.YMEMENTO__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Grid Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__GRID_ID = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Header Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__HEADER_VISIBLE = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Filter Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__FILTER_VISIBLE = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Footer Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__FOOTER_VISIBLE = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Editor Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__EDITOR_ENABLED = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Columns</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__COLUMNS = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Sort Orders</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO__SORT_ORDERS = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 6;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Memento</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_FEATURE_COUNT = CoreModelPackage.YMEMENTO_FEATURE_COUNT + 7;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl <em>Column</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl#getCxGridMementoColumn()
+	 * @generated
+	 */
+	int CX_GRID_MEMENTO_COLUMN = 1;
+
+	/**
+	 * The feature id for the '<em><b>Property Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN__PROPERTY_ID = 0;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN__EDITABLE = 1;
+
+	/**
+	 * The feature id for the '<em><b>Expand Ratio</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO = 2;
+
+	/**
+	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN__HIDDEN = 3;
+
+	/**
+	 * The feature id for the '<em><b>Hideable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN__HIDEABLE = 4;
+
+	/**
+	 * The feature id for the '<em><b>Sortable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN__SORTABLE = 5;
+
+	/**
+	 * The feature id for the '<em><b>Width</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN__WIDTH = 6;
+
+	/**
+	 * The number of structural features of the '<em>Column</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_COLUMN_FEATURE_COUNT = 7;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoSortableImpl <em>Sortable</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoSortableImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl#getCxGridMementoSortable()
+	 * @generated
+	 */
+	int CX_GRID_MEMENTO_SORTABLE = 2;
+
+	/**
+	 * The feature id for the '<em><b>Descending</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_SORTABLE__DESCENDING = 0;
+
+	/**
+	 * The feature id for the '<em><b>Column</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_SORTABLE__COLUMN = 1;
+
+	/**
+	 * The number of structural features of the '<em>Sortable</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_MEMENTO_SORTABLE_FEATURE_COUNT = 2;
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento <em>Cx Grid Memento</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Memento</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento
+	 * @generated
+	 */
+	EClass getCxGridMemento();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getGridId <em>Grid Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Grid Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getGridId()
+	 * @see #getCxGridMemento()
+	 * @generated
+	 */
+	EAttribute getCxGridMemento_GridId();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isHeaderVisible <em>Header Visible</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Header Visible</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isHeaderVisible()
+	 * @see #getCxGridMemento()
+	 * @generated
+	 */
+	EAttribute getCxGridMemento_HeaderVisible();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFilterVisible <em>Filter Visible</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Filter Visible</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFilterVisible()
+	 * @see #getCxGridMemento()
+	 * @generated
+	 */
+	EAttribute getCxGridMemento_FilterVisible();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFooterVisible <em>Footer Visible</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Footer Visible</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isFooterVisible()
+	 * @see #getCxGridMemento()
+	 * @generated
+	 */
+	EAttribute getCxGridMemento_FooterVisible();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isEditorEnabled <em>Editor Enabled</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Editor Enabled</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#isEditorEnabled()
+	 * @see #getCxGridMemento()
+	 * @generated
+	 */
+	EAttribute getCxGridMemento_EditorEnabled();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getColumns <em>Columns</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Columns</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getColumns()
+	 * @see #getCxGridMemento()
+	 * @generated
+	 */
+	EReference getCxGridMemento_Columns();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getSortOrders <em>Sort Orders</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Sort Orders</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento#getSortOrders()
+	 * @see #getCxGridMemento()
+	 * @generated
+	 */
+	EReference getCxGridMemento_SortOrders();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn <em>Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Column</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn
+	 * @generated
+	 */
+	EClass getCxGridMementoColumn();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getPropertyId <em>Property Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Property Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getPropertyId()
+	 * @see #getCxGridMementoColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoColumn_PropertyId();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isEditable <em>Editable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Editable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isEditable()
+	 * @see #getCxGridMementoColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoColumn_Editable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getExpandRatio <em>Expand Ratio</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Expand Ratio</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getExpandRatio()
+	 * @see #getCxGridMementoColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoColumn_ExpandRatio();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHidden <em>Hidden</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Hidden</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHidden()
+	 * @see #getCxGridMementoColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoColumn_Hidden();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHideable <em>Hideable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Hideable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isHideable()
+	 * @see #getCxGridMementoColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoColumn_Hideable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isSortable <em>Sortable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Sortable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#isSortable()
+	 * @see #getCxGridMementoColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoColumn_Sortable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getWidth <em>Width</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Width</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn#getWidth()
+	 * @see #getCxGridMementoColumn()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoColumn_Width();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable <em>Sortable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Sortable</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable
+	 * @generated
+	 */
+	EClass getCxGridMementoSortable();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#isDescending <em>Descending</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Descending</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#isDescending()
+	 * @see #getCxGridMementoSortable()
+	 * @generated
+	 */
+	EAttribute getCxGridMementoSortable_Descending();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#getColumn <em>Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Column</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#getColumn()
+	 * @see #getCxGridMementoSortable()
+	 * @generated
+	 */
+	EReference getCxGridMementoSortable_Column();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	CxGridMementoFactory getCxGridMementoFactory();
+
+	/**
+	 * <!-- begin-user-doc --> Defines literals for the meta objects that
+	 * represent
+	 * <ul>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl <em>Cx Grid Memento</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl#getCxGridMemento()
+		 * @generated
+		 */
+		EClass CX_GRID_MEMENTO = eINSTANCE.getCxGridMemento();
+
+		/**
+		 * The meta object literal for the '<em><b>Grid Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO__GRID_ID = eINSTANCE.getCxGridMemento_GridId();
+
+		/**
+		 * The meta object literal for the '<em><b>Header Visible</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO__HEADER_VISIBLE = eINSTANCE.getCxGridMemento_HeaderVisible();
+
+		/**
+		 * The meta object literal for the '<em><b>Filter Visible</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO__FILTER_VISIBLE = eINSTANCE.getCxGridMemento_FilterVisible();
+
+		/**
+		 * The meta object literal for the '<em><b>Footer Visible</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO__FOOTER_VISIBLE = eINSTANCE.getCxGridMemento_FooterVisible();
+
+		/**
+		 * The meta object literal for the '<em><b>Editor Enabled</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO__EDITOR_ENABLED = eINSTANCE.getCxGridMemento_EditorEnabled();
+
+		/**
+		 * The meta object literal for the '<em><b>Columns</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_MEMENTO__COLUMNS = eINSTANCE.getCxGridMemento_Columns();
+
+		/**
+		 * The meta object literal for the '<em><b>Sort Orders</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_MEMENTO__SORT_ORDERS = eINSTANCE.getCxGridMemento_SortOrders();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl <em>Column</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl#getCxGridMementoColumn()
+		 * @generated
+		 */
+		EClass CX_GRID_MEMENTO_COLUMN = eINSTANCE.getCxGridMementoColumn();
+
+		/**
+		 * The meta object literal for the '<em><b>Property Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_COLUMN__PROPERTY_ID = eINSTANCE.getCxGridMementoColumn_PropertyId();
+
+		/**
+		 * The meta object literal for the '<em><b>Editable</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_COLUMN__EDITABLE = eINSTANCE.getCxGridMementoColumn_Editable();
+
+		/**
+		 * The meta object literal for the '<em><b>Expand Ratio</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO = eINSTANCE.getCxGridMementoColumn_ExpandRatio();
+
+		/**
+		 * The meta object literal for the '<em><b>Hidden</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_COLUMN__HIDDEN = eINSTANCE.getCxGridMementoColumn_Hidden();
+
+		/**
+		 * The meta object literal for the '<em><b>Hideable</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_COLUMN__HIDEABLE = eINSTANCE.getCxGridMementoColumn_Hideable();
+
+		/**
+		 * The meta object literal for the '<em><b>Sortable</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_COLUMN__SORTABLE = eINSTANCE.getCxGridMementoColumn_Sortable();
+
+		/**
+		 * The meta object literal for the '<em><b>Width</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_COLUMN__WIDTH = eINSTANCE.getCxGridMementoColumn_Width();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoSortableImpl <em>Sortable</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoSortableImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl#getCxGridMementoSortable()
+		 * @generated
+		 */
+		EClass CX_GRID_MEMENTO_SORTABLE = eINSTANCE.getCxGridMementoSortable();
+
+		/**
+		 * The meta object literal for the '<em><b>Descending</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_MEMENTO_SORTABLE__DESCENDING = eINSTANCE.getCxGridMementoSortable_Descending();
+
+		/**
+		 * The meta object literal for the '<em><b>Column</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_MEMENTO_SORTABLE__COLUMN = eINSTANCE.getCxGridMementoSortable_Column();
+
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoSortable.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoSortable.java
new file mode 100644
index 0000000..310e255
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/CxGridMementoSortable.java
@@ -0,0 +1,91 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Sortable</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#isDescending <em>Descending</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#getColumn <em>Column</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoSortable()
+ * @model
+ * @generated
+ */
+public interface CxGridMementoSortable extends EObject {
+	
+	/**
+	 * Returns the value of the '<em><b>Descending</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Descending</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Descending</em>' attribute.
+	 * @see #setDescending(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoSortable_Descending()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isDescending();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#isDescending <em>Descending</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Descending</em>' attribute.
+	 * @see #isDescending()
+	 * @generated
+	 */
+	void setDescending(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Column</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Column</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Column</em>' reference.
+	 * @see #setColumn(CxGridMementoColumn)
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#getCxGridMementoSortable_Column()
+	 * @model required="true"
+	 * @generated
+	 */
+	CxGridMementoColumn getColumn();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable#getColumn <em>Column</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Column</em>' reference.
+	 * @see #getColumn()
+	 * @generated
+	 */
+	void setColumn(CxGridMementoColumn value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoColumnImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoColumnImpl.java
new file mode 100644
index 0000000..382a096
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoColumnImpl.java
@@ -0,0 +1,553 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Column</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl#getPropertyId <em>Property Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl#isEditable <em>Editable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl#getExpandRatio <em>Expand Ratio</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl#isHidden <em>Hidden</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl#isHideable <em>Hideable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl#isSortable <em>Sortable</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoColumnImpl#getWidth <em>Width</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridMementoColumnImpl extends MinimalEObjectImpl.Container implements CxGridMementoColumn {
+	
+	/**
+	 * The default value of the '{@link #getPropertyId() <em>Property Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getPropertyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String PROPERTY_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getPropertyId() <em>Property Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getPropertyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String propertyId = PROPERTY_ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isEditable() <em>Editable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isEditable()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean EDITABLE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isEditable() <em>Editable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isEditable()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean editable = EDITABLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getExpandRatio() <em>Expand Ratio</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getExpandRatio()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int EXPAND_RATIO_EDEFAULT = -1;
+
+	/**
+	 * The cached value of the '{@link #getExpandRatio() <em>Expand Ratio</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getExpandRatio()
+	 * @generated
+	 * @ordered
+	 */
+	protected int expandRatio = EXPAND_RATIO_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isHidden() <em>Hidden</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHidden()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean HIDDEN_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isHidden() <em>Hidden</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHidden()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean hidden = HIDDEN_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isHideable() <em>Hideable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHideable()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean HIDEABLE_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isHideable() <em>Hideable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHideable()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean hideable = HIDEABLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isSortable() <em>Sortable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSortable()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean SORTABLE_EDEFAULT = true;
+
+	/**
+	 * The cached value of the '{@link #isSortable() <em>Sortable</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSortable()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean sortable = SORTABLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getWidth() <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getWidth()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int WIDTH_EDEFAULT = -1;
+
+	/**
+	 * The cached value of the '{@link #getWidth() <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getWidth()
+	 * @generated
+	 * @ordered
+	 */
+	protected int width = WIDTH_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridMementoColumnImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridMementoPackage.Literals.CX_GRID_MEMENTO_COLUMN;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getPropertyId()
+	 *         <em>Property Id</em>}' attribute
+	 * @generated
+	 */
+	public String getPropertyId() {
+		return propertyId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newPropertyId
+	 *            the new cached value of the '{@link #getPropertyId()
+	 *            <em>Property Id</em>}' attribute
+	 * @generated
+	 */
+	public void setPropertyId(String newPropertyId) {
+		String oldPropertyId = propertyId;
+		propertyId = newPropertyId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__PROPERTY_ID, oldPropertyId, propertyId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isEditable() <em>Editable</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isEditable() {
+		return editable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditable
+	 *            the new cached value of the '{@link #isEditable()
+	 *            <em>Editable</em>}' attribute
+	 * @generated
+	 */
+	public void setEditable(boolean newEditable) {
+		boolean oldEditable = editable;
+		editable = newEditable;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EDITABLE, oldEditable, editable));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getExpandRatio()
+	 *         <em>Expand Ratio</em>}' attribute
+	 * @generated
+	 */
+	public int getExpandRatio() {
+		return expandRatio;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newExpandRatio
+	 *            the new cached value of the '{@link #getExpandRatio()
+	 *            <em>Expand Ratio</em>}' attribute
+	 * @generated
+	 */
+	public void setExpandRatio(int newExpandRatio) {
+		int oldExpandRatio = expandRatio;
+		expandRatio = newExpandRatio;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO, oldExpandRatio, expandRatio));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isHidden() <em>Hidden</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isHidden() {
+		return hidden;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHidden
+	 *            the new cached value of the '{@link #isHidden()
+	 *            <em>Hidden</em>}' attribute
+	 * @generated
+	 */
+	public void setHidden(boolean newHidden) {
+		boolean oldHidden = hidden;
+		hidden = newHidden;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDDEN, oldHidden, hidden));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isHideable() <em>Hideable</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isHideable() {
+		return hideable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHideable
+	 *            the new cached value of the '{@link #isHideable()
+	 *            <em>Hideable</em>}' attribute
+	 * @generated
+	 */
+	public void setHideable(boolean newHideable) {
+		boolean oldHideable = hideable;
+		hideable = newHideable;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDEABLE, oldHideable, hideable));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isSortable() <em>Sortable</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public boolean isSortable() {
+		return sortable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSortable
+	 *            the new cached value of the '{@link #isSortable()
+	 *            <em>Sortable</em>}' attribute
+	 * @generated
+	 */
+	public void setSortable(boolean newSortable) {
+		boolean oldSortable = sortable;
+		sortable = newSortable;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__SORTABLE, oldSortable, sortable));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getWidth() <em>Width</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public int getWidth() {
+		return width;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newWidth
+	 *            the new cached value of the '{@link #getWidth()
+	 *            <em>Width</em>}' attribute
+	 * @generated
+	 */
+	public void setWidth(int newWidth) {
+		int oldWidth = width;
+		width = newWidth;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__WIDTH, oldWidth, width));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__PROPERTY_ID:
+				return getPropertyId();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EDITABLE:
+				return isEditable();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO:
+				return getExpandRatio();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDDEN:
+				return isHidden();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDEABLE:
+				return isHideable();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__SORTABLE:
+				return isSortable();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__WIDTH:
+				return getWidth();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__PROPERTY_ID:
+				setPropertyId((String)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EDITABLE:
+				setEditable((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO:
+				setExpandRatio((Integer)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDDEN:
+				setHidden((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDEABLE:
+				setHideable((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__SORTABLE:
+				setSortable((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__WIDTH:
+				setWidth((Integer)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__PROPERTY_ID:
+				setPropertyId(PROPERTY_ID_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EDITABLE:
+				setEditable(EDITABLE_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO:
+				setExpandRatio(EXPAND_RATIO_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDDEN:
+				setHidden(HIDDEN_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDEABLE:
+				setHideable(HIDEABLE_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__SORTABLE:
+				setSortable(SORTABLE_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__WIDTH:
+				setWidth(WIDTH_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__PROPERTY_ID:
+				return PROPERTY_ID_EDEFAULT == null ? propertyId != null : !PROPERTY_ID_EDEFAULT.equals(propertyId);
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EDITABLE:
+				return editable != EDITABLE_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO:
+				return expandRatio != EXPAND_RATIO_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDDEN:
+				return hidden != HIDDEN_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__HIDEABLE:
+				return hideable != HIDEABLE_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__SORTABLE:
+				return sortable != SORTABLE_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN__WIDTH:
+				return width != WIDTH_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (propertyId: ");
+		result.append(propertyId);
+		result.append(", editable: ");
+		result.append(editable);
+		result.append(", expandRatio: ");
+		result.append(expandRatio);
+		result.append(", hidden: ");
+		result.append(hidden);
+		result.append(", hideable: ");
+		result.append(hideable);
+		result.append(", sortable: ");
+		result.append(sortable);
+		result.append(", width: ");
+		result.append(width);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoFactoryImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoFactoryImpl.java
new file mode 100644
index 0000000..130e83c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoFactoryImpl.java
@@ -0,0 +1,138 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.*;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridMementoFactoryImpl extends EFactoryImpl implements CxGridMementoFactory {
+	
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	public static CxGridMementoFactory init() {
+		try {
+			CxGridMementoFactory theCxGridMementoFactory = (CxGridMementoFactory)EPackage.Registry.INSTANCE.getEFactory(CxGridMementoPackage.eNS_URI);
+			if (theCxGridMementoFactory != null) {
+				return theCxGridMementoFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new CxGridMementoFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridMementoFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param eClass
+	 *            the e class
+	 * @return the e object
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO: return createCxGridMemento();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN: return createCxGridMementoColumn();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE: return createCxGridMementoSortable();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento
+	 * @generated
+	 */
+	public CxGridMemento createCxGridMemento() {
+		CxGridMementoImpl cxGridMemento = new CxGridMementoImpl();
+		return cxGridMemento;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column
+	 * @generated
+	 */
+	public CxGridMementoColumn createCxGridMementoColumn() {
+		CxGridMementoColumnImpl cxGridMementoColumn = new CxGridMementoColumnImpl();
+		return cxGridMementoColumn;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento sortable
+	 * @generated
+	 */
+	public CxGridMementoSortable createCxGridMementoSortable() {
+		CxGridMementoSortableImpl cxGridMementoSortable = new CxGridMementoSortableImpl();
+		return cxGridMementoSortable;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento package
+	 * @generated
+	 */
+	public CxGridMementoPackage getCxGridMementoPackage() {
+		return (CxGridMementoPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the package
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static CxGridMementoPackage getPackage() {
+		return CxGridMementoPackage.eINSTANCE;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoImpl.java
new file mode 100644
index 0000000..1ea100c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoImpl.java
@@ -0,0 +1,735 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Memento</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#getGridId <em>Grid Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#isHeaderVisible <em>Header Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#isFilterVisible <em>Filter Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#isFooterVisible <em>Footer Visible</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#isEditorEnabled <em>Editor Enabled</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#getColumns <em>Columns</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoImpl#getSortOrders <em>Sort Orders</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridMementoImpl extends MinimalEObjectImpl.Container implements CxGridMemento {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getGridId() <em>Grid Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGridId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String GRID_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getGridId() <em>Grid Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGridId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String gridId = GRID_ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isHeaderVisible() <em>Header Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHeaderVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean HEADER_VISIBLE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isHeaderVisible() <em>Header Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isHeaderVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean headerVisible = HEADER_VISIBLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isFilterVisible() <em>Filter Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isFilterVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean FILTER_VISIBLE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isFilterVisible() <em>Filter Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isFilterVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean filterVisible = FILTER_VISIBLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isFooterVisible() <em>Footer Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isFooterVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean FOOTER_VISIBLE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isFooterVisible() <em>Footer Visible</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isFooterVisible()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean footerVisible = FOOTER_VISIBLE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isEditorEnabled() <em>Editor Enabled</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isEditorEnabled()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean EDITOR_ENABLED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isEditorEnabled() <em>Editor Enabled</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isEditorEnabled()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean editorEnabled = EDITOR_ENABLED_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getColumns() <em>Columns</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getColumns()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridMementoColumn> columns;
+
+	/**
+	 * The cached value of the '{@link #getSortOrders() <em>Sort Orders</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSortOrders()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<CxGridMementoSortable> sortOrders;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridMementoImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridMementoPackage.Literals.CX_GRID_MEMENTO;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridMementoPackage.CX_GRID_MEMENTO__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridMementoPackage.CX_GRID_MEMENTO__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getGridId() <em>Grid Id</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getGridId() {
+		return gridId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newGridId
+	 *            the new cached value of the '{@link #getGridId()
+	 *            <em>Grid Id</em>}' attribute
+	 * @generated
+	 */
+	public void setGridId(String newGridId) {
+		String oldGridId = gridId;
+		gridId = newGridId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO__GRID_ID, oldGridId, gridId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isHeaderVisible()
+	 *         <em>Header Visible</em>}' attribute
+	 * @generated
+	 */
+	public boolean isHeaderVisible() {
+		return headerVisible;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHeaderVisible
+	 *            the new cached value of the '{@link #isHeaderVisible()
+	 *            <em>Header Visible</em>}' attribute
+	 * @generated
+	 */
+	public void setHeaderVisible(boolean newHeaderVisible) {
+		boolean oldHeaderVisible = headerVisible;
+		headerVisible = newHeaderVisible;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO__HEADER_VISIBLE, oldHeaderVisible, headerVisible));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isFilterVisible()
+	 *         <em>Filter Visible</em>}' attribute
+	 * @generated
+	 */
+	public boolean isFilterVisible() {
+		return filterVisible;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newFilterVisible
+	 *            the new cached value of the '{@link #isFilterVisible()
+	 *            <em>Filter Visible</em>}' attribute
+	 * @generated
+	 */
+	public void setFilterVisible(boolean newFilterVisible) {
+		boolean oldFilterVisible = filterVisible;
+		filterVisible = newFilterVisible;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO__FILTER_VISIBLE, oldFilterVisible, filterVisible));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isFooterVisible()
+	 *         <em>Footer Visible</em>}' attribute
+	 * @generated
+	 */
+	public boolean isFooterVisible() {
+		return footerVisible;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newFooterVisible
+	 *            the new cached value of the '{@link #isFooterVisible()
+	 *            <em>Footer Visible</em>}' attribute
+	 * @generated
+	 */
+	public void setFooterVisible(boolean newFooterVisible) {
+		boolean oldFooterVisible = footerVisible;
+		footerVisible = newFooterVisible;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO__FOOTER_VISIBLE, oldFooterVisible, footerVisible));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isEditorEnabled()
+	 *         <em>Editor Enabled</em>}' attribute
+	 * @generated
+	 */
+	public boolean isEditorEnabled() {
+		return editorEnabled;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEditorEnabled
+	 *            the new cached value of the '{@link #isEditorEnabled()
+	 *            <em>Editor Enabled</em>}' attribute
+	 * @generated
+	 */
+	public void setEditorEnabled(boolean newEditorEnabled) {
+		boolean oldEditorEnabled = editorEnabled;
+		editorEnabled = newEditorEnabled;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO__EDITOR_ENABLED, oldEditorEnabled, editorEnabled));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getColumns() <em>Columns</em>}'
+	 *         containment reference list
+	 * @generated
+	 */
+	public EList<CxGridMementoColumn> getColumns() {
+		if (columns == null) {
+			columns = new EObjectContainmentEList<CxGridMementoColumn>(CxGridMementoColumn.class, this, CxGridMementoPackage.CX_GRID_MEMENTO__COLUMNS);
+		}
+		return columns;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSortOrders()
+	 *         <em>Sort Orders</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<CxGridMementoSortable> getSortOrders() {
+		if (sortOrders == null) {
+			sortOrders = new EObjectContainmentEList<CxGridMementoSortable>(CxGridMementoSortable.class, this, CxGridMementoPackage.CX_GRID_MEMENTO__SORT_ORDERS);
+		}
+		return sortOrders;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case CxGridMementoPackage.CX_GRID_MEMENTO__COLUMNS:
+				return ((InternalEList<?>)getColumns()).basicRemove(otherEnd, msgs);
+			case CxGridMementoPackage.CX_GRID_MEMENTO__SORT_ORDERS:
+				return ((InternalEList<?>)getSortOrders()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO__TAGS:
+				return getTags();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__ID:
+				return getId();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__NAME:
+				return getName();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__GRID_ID:
+				return getGridId();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__HEADER_VISIBLE:
+				return isHeaderVisible();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FILTER_VISIBLE:
+				return isFilterVisible();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FOOTER_VISIBLE:
+				return isFooterVisible();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__EDITOR_ENABLED:
+				return isEditorEnabled();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__COLUMNS:
+				return getColumns();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__SORT_ORDERS:
+				return getSortOrders();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__ID:
+				setId((String)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__GRID_ID:
+				setGridId((String)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__HEADER_VISIBLE:
+				setHeaderVisible((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FILTER_VISIBLE:
+				setFilterVisible((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FOOTER_VISIBLE:
+				setFooterVisible((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__EDITOR_ENABLED:
+				setEditorEnabled((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__COLUMNS:
+				getColumns().clear();
+				getColumns().addAll((Collection<? extends CxGridMementoColumn>)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__SORT_ORDERS:
+				getSortOrders().clear();
+				getSortOrders().addAll((Collection<? extends CxGridMementoSortable>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO__TAGS:
+				getTags().clear();
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__PROPERTIES:
+				getProperties().clear();
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__GRID_ID:
+				setGridId(GRID_ID_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__HEADER_VISIBLE:
+				setHeaderVisible(HEADER_VISIBLE_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FILTER_VISIBLE:
+				setFilterVisible(FILTER_VISIBLE_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FOOTER_VISIBLE:
+				setFooterVisible(FOOTER_VISIBLE_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__EDITOR_ENABLED:
+				setEditorEnabled(EDITOR_ENABLED_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__COLUMNS:
+				getColumns().clear();
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__SORT_ORDERS:
+				getSortOrders().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridMementoPackage.CX_GRID_MEMENTO__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridMementoPackage.CX_GRID_MEMENTO__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__GRID_ID:
+				return GRID_ID_EDEFAULT == null ? gridId != null : !GRID_ID_EDEFAULT.equals(gridId);
+			case CxGridMementoPackage.CX_GRID_MEMENTO__HEADER_VISIBLE:
+				return headerVisible != HEADER_VISIBLE_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FILTER_VISIBLE:
+				return filterVisible != FILTER_VISIBLE_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__FOOTER_VISIBLE:
+				return footerVisible != FOOTER_VISIBLE_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__EDITOR_ENABLED:
+				return editorEnabled != EDITOR_ENABLED_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO__COLUMNS:
+				return columns != null && !columns.isEmpty();
+			case CxGridMementoPackage.CX_GRID_MEMENTO__SORT_ORDERS:
+				return sortOrders != null && !sortOrders.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", gridId: ");
+		result.append(gridId);
+		result.append(", headerVisible: ");
+		result.append(headerVisible);
+		result.append(", filterVisible: ");
+		result.append(filterVisible);
+		result.append(", footerVisible: ");
+		result.append(footerVisible);
+		result.append(", editorEnabled: ");
+		result.append(editorEnabled);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoPackageImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoPackageImpl.java
new file mode 100644
index 0000000..37fb197
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoPackageImpl.java
@@ -0,0 +1,440 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+import org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoFactory;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridMementoPackageImpl extends EPackageImpl implements CxGridMementoPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridMementoEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridMementoColumnEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridMementoSortableEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private CxGridMementoPackageImpl() {
+		super(eNS_URI, CxGridMementoFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model,
+	 * and for any others upon which it depends.
+	 * 
+	 * <p>
+	 * This method is used to initialize {@link CxGridMementoPackage#eINSTANCE}
+	 * when that field is accessed. Clients should not invoke it directly.
+	 * Instead, they should simply access that field to obtain the package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the cx grid memento package
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static CxGridMementoPackage init() {
+		if (isInited) return (CxGridMementoPackage)EPackage.Registry.INSTANCE.getEPackage(CxGridMementoPackage.eNS_URI);
+
+		// Obtain or create and register package
+		CxGridMementoPackageImpl theCxGridMementoPackage = (CxGridMementoPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof CxGridMementoPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new CxGridMementoPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		ExtDatatypesPackage.eINSTANCE.eClass();
+		ExtensionModelPackage.eINSTANCE.eClass();
+
+		// Obtain or create and register interdependencies
+		CxGridPackageImpl theCxGridPackage = (CxGridPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(CxGridPackage.eNS_URI) instanceof CxGridPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(CxGridPackage.eNS_URI) : CxGridPackage.eINSTANCE);
+		CxGridRendererPackageImpl theCxGridRendererPackage = (CxGridRendererPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(CxGridRendererPackage.eNS_URI) instanceof CxGridRendererPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(CxGridRendererPackage.eNS_URI) : CxGridRendererPackage.eINSTANCE);
+
+		// Create package meta-data objects
+		theCxGridMementoPackage.createPackageContents();
+		theCxGridPackage.createPackageContents();
+		theCxGridRendererPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theCxGridMementoPackage.initializePackageContents();
+		theCxGridPackage.initializePackageContents();
+		theCxGridRendererPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theCxGridMementoPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(CxGridMementoPackage.eNS_URI, theCxGridMementoPackage);
+		return theCxGridMementoPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento
+	 * @generated
+	 */
+	public EClass getCxGridMemento() {
+		return cxGridMementoEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento_ grid id
+	 * @generated
+	 */
+	public EAttribute getCxGridMemento_GridId() {
+		return (EAttribute)cxGridMementoEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento_ header visible
+	 * @generated
+	 */
+	public EAttribute getCxGridMemento_HeaderVisible() {
+		return (EAttribute)cxGridMementoEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento_ filter visible
+	 * @generated
+	 */
+	public EAttribute getCxGridMemento_FilterVisible() {
+		return (EAttribute)cxGridMementoEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento_ footer visible
+	 * @generated
+	 */
+	public EAttribute getCxGridMemento_FooterVisible() {
+		return (EAttribute)cxGridMementoEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento_ editor enabled
+	 * @generated
+	 */
+	public EAttribute getCxGridMemento_EditorEnabled() {
+		return (EAttribute)cxGridMementoEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento_ columns
+	 * @generated
+	 */
+	public EReference getCxGridMemento_Columns() {
+		return (EReference)cxGridMementoEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento_ sort orders
+	 * @generated
+	 */
+	public EReference getCxGridMemento_SortOrders() {
+		return (EReference)cxGridMementoEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column
+	 * @generated
+	 */
+	public EClass getCxGridMementoColumn() {
+		return cxGridMementoColumnEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column_ property id
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoColumn_PropertyId() {
+		return (EAttribute)cxGridMementoColumnEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column_ editable
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoColumn_Editable() {
+		return (EAttribute)cxGridMementoColumnEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column_ expand ratio
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoColumn_ExpandRatio() {
+		return (EAttribute)cxGridMementoColumnEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column_ hidden
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoColumn_Hidden() {
+		return (EAttribute)cxGridMementoColumnEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column_ hideable
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoColumn_Hideable() {
+		return (EAttribute)cxGridMementoColumnEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column_ sortable
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoColumn_Sortable() {
+		return (EAttribute)cxGridMementoColumnEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column_ width
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoColumn_Width() {
+		return (EAttribute)cxGridMementoColumnEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento sortable
+	 * @generated
+	 */
+	public EClass getCxGridMementoSortable() {
+		return cxGridMementoSortableEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento sortable_ descending
+	 * @generated
+	 */
+	public EAttribute getCxGridMementoSortable_Descending() {
+		return (EAttribute)cxGridMementoSortableEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento sortable_ column
+	 * @generated
+	 */
+	public EReference getCxGridMementoSortable_Column() {
+		return (EReference)cxGridMementoSortableEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento factory
+	 * @generated
+	 */
+	public CxGridMementoFactory getCxGridMementoFactory() {
+		return (CxGridMementoFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		cxGridMementoEClass = createEClass(CX_GRID_MEMENTO);
+		createEAttribute(cxGridMementoEClass, CX_GRID_MEMENTO__GRID_ID);
+		createEAttribute(cxGridMementoEClass, CX_GRID_MEMENTO__HEADER_VISIBLE);
+		createEAttribute(cxGridMementoEClass, CX_GRID_MEMENTO__FILTER_VISIBLE);
+		createEAttribute(cxGridMementoEClass, CX_GRID_MEMENTO__FOOTER_VISIBLE);
+		createEAttribute(cxGridMementoEClass, CX_GRID_MEMENTO__EDITOR_ENABLED);
+		createEReference(cxGridMementoEClass, CX_GRID_MEMENTO__COLUMNS);
+		createEReference(cxGridMementoEClass, CX_GRID_MEMENTO__SORT_ORDERS);
+
+		cxGridMementoColumnEClass = createEClass(CX_GRID_MEMENTO_COLUMN);
+		createEAttribute(cxGridMementoColumnEClass, CX_GRID_MEMENTO_COLUMN__PROPERTY_ID);
+		createEAttribute(cxGridMementoColumnEClass, CX_GRID_MEMENTO_COLUMN__EDITABLE);
+		createEAttribute(cxGridMementoColumnEClass, CX_GRID_MEMENTO_COLUMN__EXPAND_RATIO);
+		createEAttribute(cxGridMementoColumnEClass, CX_GRID_MEMENTO_COLUMN__HIDDEN);
+		createEAttribute(cxGridMementoColumnEClass, CX_GRID_MEMENTO_COLUMN__HIDEABLE);
+		createEAttribute(cxGridMementoColumnEClass, CX_GRID_MEMENTO_COLUMN__SORTABLE);
+		createEAttribute(cxGridMementoColumnEClass, CX_GRID_MEMENTO_COLUMN__WIDTH);
+
+		cxGridMementoSortableEClass = createEClass(CX_GRID_MEMENTO_SORTABLE);
+		createEAttribute(cxGridMementoSortableEClass, CX_GRID_MEMENTO_SORTABLE__DESCENDING);
+		createEReference(cxGridMementoSortableEClass, CX_GRID_MEMENTO_SORTABLE__COLUMN);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		CoreModelPackage theCoreModelPackage = (CoreModelPackage)EPackage.Registry.INSTANCE.getEPackage(CoreModelPackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		cxGridMementoEClass.getESuperTypes().add(theCoreModelPackage.getYMemento());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(cxGridMementoEClass, CxGridMemento.class, "CxGridMemento", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridMemento_GridId(), ecorePackage.getEString(), "gridId", null, 1, 1, CxGridMemento.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMemento_HeaderVisible(), ecorePackage.getEBoolean(), "headerVisible", null, 0, 1, CxGridMemento.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMemento_FilterVisible(), ecorePackage.getEBoolean(), "filterVisible", null, 0, 1, CxGridMemento.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMemento_FooterVisible(), ecorePackage.getEBoolean(), "footerVisible", null, 0, 1, CxGridMemento.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMemento_EditorEnabled(), ecorePackage.getEBoolean(), "editorEnabled", null, 0, 1, CxGridMemento.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridMemento_Columns(), this.getCxGridMementoColumn(), null, "columns", null, 0, -1, CxGridMemento.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridMemento_SortOrders(), this.getCxGridMementoSortable(), null, "sortOrders", null, 0, -1, CxGridMemento.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridMementoColumnEClass, CxGridMementoColumn.class, "CxGridMementoColumn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridMementoColumn_PropertyId(), ecorePackage.getEString(), "propertyId", null, 0, 1, CxGridMementoColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMementoColumn_Editable(), ecorePackage.getEBoolean(), "editable", "false", 0, 1, CxGridMementoColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMementoColumn_ExpandRatio(), ecorePackage.getEInt(), "expandRatio", "-1", 0, 1, CxGridMementoColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMementoColumn_Hidden(), ecorePackage.getEBoolean(), "hidden", "false", 0, 1, CxGridMementoColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMementoColumn_Hideable(), ecorePackage.getEBoolean(), "hideable", "true", 0, 1, CxGridMementoColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMementoColumn_Sortable(), ecorePackage.getEBoolean(), "sortable", "true", 0, 1, CxGridMementoColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridMementoColumn_Width(), ecorePackage.getEInt(), "width", "-1", 0, 1, CxGridMementoColumn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridMementoSortableEClass, CxGridMementoSortable.class, "CxGridMementoSortable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridMementoSortable_Descending(), ecorePackage.getEBoolean(), "descending", "false", 0, 1, CxGridMementoSortable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridMementoSortable_Column(), this.getCxGridMementoColumn(), null, "column", null, 1, 1, CxGridMementoSortable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoSortableImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoSortableImpl.java
new file mode 100644
index 0000000..8a2d474
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/impl/CxGridMementoSortableImpl.java
@@ -0,0 +1,267 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Sortable</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoSortableImpl#isDescending <em>Descending</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoSortableImpl#getColumn <em>Column</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridMementoSortableImpl extends MinimalEObjectImpl.Container implements CxGridMementoSortable {
+	
+	/**
+	 * The default value of the '{@link #isDescending() <em>Descending</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isDescending()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean DESCENDING_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isDescending() <em>Descending</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isDescending()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean descending = DESCENDING_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getColumn() <em>Column</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getColumn()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridMementoColumn column;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridMementoSortableImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridMementoPackage.Literals.CX_GRID_MEMENTO_SORTABLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isDescending()
+	 *         <em>Descending</em>}' attribute
+	 * @generated
+	 */
+	public boolean isDescending() {
+		return descending;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDescending
+	 *            the new cached value of the '{@link #isDescending()
+	 *            <em>Descending</em>}' attribute
+	 * @generated
+	 */
+	public void setDescending(boolean newDescending) {
+		boolean oldDescending = descending;
+		descending = newDescending;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__DESCENDING, oldDescending, descending));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getColumn() <em>Column</em>}'
+	 *         reference
+	 * @generated
+	 */
+	public CxGridMementoColumn getColumn() {
+		if (column != null && column.eIsProxy()) {
+			InternalEObject oldColumn = (InternalEObject)column;
+			column = (CxGridMementoColumn)eResolveProxy(oldColumn);
+			if (column != oldColumn) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__COLUMN, oldColumn, column));
+			}
+		}
+		return column;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid memento column
+	 * @generated
+	 */
+	public CxGridMementoColumn basicGetColumn() {
+		return column;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newColumn
+	 *            the new cached value of the '{@link #getColumn()
+	 *            <em>Column</em>}' reference
+	 * @generated
+	 */
+	public void setColumn(CxGridMementoColumn newColumn) {
+		CxGridMementoColumn oldColumn = column;
+		column = newColumn;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__COLUMN, oldColumn, column));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__DESCENDING:
+				return isDescending();
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__COLUMN:
+				if (resolve) return getColumn();
+				return basicGetColumn();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__DESCENDING:
+				setDescending((Boolean)newValue);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__COLUMN:
+				setColumn((CxGridMementoColumn)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__DESCENDING:
+				setDescending(DESCENDING_EDEFAULT);
+				return;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__COLUMN:
+				setColumn((CxGridMementoColumn)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__DESCENDING:
+				return descending != DESCENDING_EDEFAULT;
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE__COLUMN:
+				return column != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (descending: ");
+		result.append(descending);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/util/CxGridMementoAdapterFactory.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/util/CxGridMementoAdapterFactory.java
new file mode 100644
index 0000000..25a24fe
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/util/CxGridMementoAdapterFactory.java
@@ -0,0 +1,226 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento.util;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.*;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YMemento;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage
+ * @generated
+ */
+public class CxGridMementoAdapterFactory extends AdapterFactoryImpl {
+	
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static CxGridMementoPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridMementoAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = CxGridMementoPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc --> This implementation returns <code>true</code> if
+	 * the object is either the model's package or is an instance object of the
+	 * model. <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridMementoSwitch<Adapter> modelSwitch =
+		new CxGridMementoSwitch<Adapter>() {
+			@Override
+			public Adapter caseCxGridMemento(CxGridMemento object) {
+				return createCxGridMementoAdapter();
+			}
+			@Override
+			public Adapter caseCxGridMementoColumn(CxGridMementoColumn object) {
+				return createCxGridMementoColumnAdapter();
+			}
+			@Override
+			public Adapter caseCxGridMementoSortable(CxGridMementoSortable object) {
+				return createCxGridMementoSortableAdapter();
+			}
+			@Override
+			public Adapter caseYTaggable(YTaggable object) {
+				return createYTaggableAdapter();
+			}
+			@Override
+			public Adapter caseYElement(YElement object) {
+				return createYElementAdapter();
+			}
+			@Override
+			public Adapter caseYMemento(YMemento object) {
+				return createYMementoAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento <em>Cx Grid Memento</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMemento
+	 * @generated
+	 */
+	public Adapter createCxGridMementoAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn <em>Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoColumn
+	 * @generated
+	 */
+	public Adapter createCxGridMementoColumnAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable <em>Sortable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoSortable
+	 * @generated
+	 */
+	public Adapter createCxGridMementoSortableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YTaggable <em>YTaggable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YTaggable
+	 * @generated
+	 */
+	public Adapter createYTaggableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YElement <em>YElement</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YElement
+	 * @generated
+	 */
+	public Adapter createYElementAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YMemento <em>YMemento</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YMemento
+	 * @generated
+	 */
+	public Adapter createYMementoAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/util/CxGridMementoSwitch.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/util/CxGridMementoSwitch.java
new file mode 100644
index 0000000..a557770
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/memento/util/CxGridMementoSwitch.java
@@ -0,0 +1,214 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.memento.util;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.*;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YMemento;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+
+/**
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance
+ * hierarchy. It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the
+ * inheritance hierarchy until a non-null result is returned, which is the
+ * result of the switch. <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage
+ * @generated
+ */
+public class CxGridMementoSwitch<T> extends Switch<T> {
+	
+	/**
+	 * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected static CxGridMementoPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridMementoSwitch() {
+		if (modelPackage == null) {
+			modelPackage = CxGridMementoPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param ePackage
+	 *            the e package
+	 * @return whether this is a switch for the given package.
+	 * @parameter ePackage the package in question.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case CxGridMementoPackage.CX_GRID_MEMENTO: {
+				CxGridMemento cxGridMemento = (CxGridMemento)theEObject;
+				T result = caseCxGridMemento(cxGridMemento);
+				if (result == null) result = caseYMemento(cxGridMemento);
+				if (result == null) result = caseYElement(cxGridMemento);
+				if (result == null) result = caseYTaggable(cxGridMemento);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridMementoPackage.CX_GRID_MEMENTO_COLUMN: {
+				CxGridMementoColumn cxGridMementoColumn = (CxGridMementoColumn)theEObject;
+				T result = caseCxGridMementoColumn(cxGridMementoColumn);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridMementoPackage.CX_GRID_MEMENTO_SORTABLE: {
+				CxGridMementoSortable cxGridMementoSortable = (CxGridMementoSortable)theEObject;
+				T result = caseCxGridMementoSortable(cxGridMementoSortable);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Memento</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Memento</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridMemento(CxGridMemento object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Column</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Column</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridMementoColumn(CxGridMementoColumn object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Sortable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Sortable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridMementoSortable(CxGridMementoSortable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTaggable(YTaggable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYElement(YElement object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YMemento</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YMemento</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYMemento(YMemento object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridBooleanRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridBooleanRenderer.java
new file mode 100644
index 0000000..9b5b351
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridBooleanRenderer.java
@@ -0,0 +1,30 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Boolean Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridBooleanRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridBooleanRenderer extends CxGridRenderer {
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridButtonRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridButtonRenderer.java
new file mode 100644
index 0000000..7eb446e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridButtonRenderer.java
@@ -0,0 +1,129 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.YECViewModelValueBindingEndpoint;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Button Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getNullRepresentation <em>Null Representation</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getLastClickEvent <em>Last Click Event</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getEventTopic <em>Event Topic</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridButtonRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridButtonRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Null Representation</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Null Representation</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Null Representation</em>' attribute.
+	 * @see #setNullRepresentation(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridButtonRenderer_NullRepresentation()
+	 * @model default=""
+	 * @generated
+	 */
+	String getNullRepresentation();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getNullRepresentation <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Null Representation</em>' attribute.
+	 * @see #getNullRepresentation()
+	 * @generated
+	 */
+	void setNullRepresentation(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Last Click Event</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Last Click Event</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Last Click Event</em>' containment reference.
+	 * @see #setLastClickEvent(CxGridRendererClickEvent)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridButtonRenderer_LastClickEvent()
+	 * @model containment="true"
+	 * @generated
+	 */
+	CxGridRendererClickEvent getLastClickEvent();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getLastClickEvent <em>Last Click Event</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Last Click Event</em>' containment reference.
+	 * @see #getLastClickEvent()
+	 * @generated
+	 */
+	void setLastClickEvent(CxGridRendererClickEvent value);
+
+	/**
+	 * Returns the value of the '<em><b>Event Topic</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Event Topic</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Event Topic</em>' attribute.
+	 * @see #setEventTopic(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridButtonRenderer_EventTopic()
+	 * @model default=""
+	 * @generated
+	 */
+	String getEventTopic();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getEventTopic <em>Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Event Topic</em>' attribute.
+	 * @see #getEventTopic()
+	 * @generated
+	 */
+	void setEventTopic(String value);
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the YEC view model value binding endpoint
+	 * @model
+	 * @generated
+	 */
+	YECViewModelValueBindingEndpoint createLastClickEventEndpoint();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridDateRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridDateRenderer.java
new file mode 100644
index 0000000..1c497f6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridDateRenderer.java
@@ -0,0 +1,62 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Date Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer#getDateFormat <em>Date Format</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridDateRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridDateRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Date Format</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Date Format</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Date Format</em>' attribute.
+	 * @see #setDateFormat(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridDateRenderer_DateFormat()
+	 * @model
+	 * @generated
+	 */
+	String getDateFormat();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer#getDateFormat <em>Date Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Date Format</em>' attribute.
+	 * @see #getDateFormat()
+	 * @generated
+	 */
+	void setDateFormat(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridDelegateRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridDelegateRenderer.java
new file mode 100644
index 0000000..8342cd6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridDelegateRenderer.java
@@ -0,0 +1,62 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Delegate Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer#getDelegateId <em>Delegate Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridDelegateRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridDelegateRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Delegate Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Delegate Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Delegate Id</em>' attribute.
+	 * @see #setDelegateId(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridDelegateRenderer_DelegateId()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getDelegateId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer#getDelegateId <em>Delegate Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Delegate Id</em>' attribute.
+	 * @see #getDelegateId()
+	 * @generated
+	 */
+	void setDelegateId(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridHtmlRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridHtmlRenderer.java
new file mode 100644
index 0000000..4c2d85f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridHtmlRenderer.java
@@ -0,0 +1,63 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Html Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer#getNullRepresentation <em>Null Representation</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridHtmlRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridHtmlRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Null Representation</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Null Representation</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Null Representation</em>' attribute.
+	 * @see #setNullRepresentation(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridHtmlRenderer_NullRepresentation()
+	 * @model default=""
+	 * @generated
+	 */
+	String getNullRepresentation();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer#getNullRepresentation <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Null Representation</em>' attribute.
+	 * @see #getNullRepresentation()
+	 * @generated
+	 */
+	void setNullRepresentation(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridImageRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridImageRenderer.java
new file mode 100644
index 0000000..a13e720
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridImageRenderer.java
@@ -0,0 +1,101 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.YECViewModelValueBindingEndpoint;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Image Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getLastClickEvent <em>Last Click Event</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getEventTopic <em>Event Topic</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridImageRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridImageRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Last Click Event</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Last Click Event</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Last Click Event</em>' containment reference.
+	 * @see #setLastClickEvent(CxGridRendererClickEvent)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridImageRenderer_LastClickEvent()
+	 * @model containment="true"
+	 * @generated
+	 */
+	CxGridRendererClickEvent getLastClickEvent();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getLastClickEvent <em>Last Click Event</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Last Click Event</em>' containment reference.
+	 * @see #getLastClickEvent()
+	 * @generated
+	 */
+	void setLastClickEvent(CxGridRendererClickEvent value);
+
+	/**
+	 * Returns the value of the '<em><b>Event Topic</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Event Topic</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Event Topic</em>' attribute.
+	 * @see #setEventTopic(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridImageRenderer_EventTopic()
+	 * @model default=""
+	 * @generated
+	 */
+	String getEventTopic();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getEventTopic <em>Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Event Topic</em>' attribute.
+	 * @see #getEventTopic()
+	 * @generated
+	 */
+	void setEventTopic(String value);
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the YEC view model value binding endpoint
+	 * @model
+	 * @generated
+	 */
+	YECViewModelValueBindingEndpoint createLastClickEventEndpoint();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridIndicatorRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridIndicatorRenderer.java
new file mode 100644
index 0000000..c111688
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridIndicatorRenderer.java
@@ -0,0 +1,89 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Indicator Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getRedEnds <em>Red Ends</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getGreenStarts <em>Green Starts</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridIndicatorRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridIndicatorRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Red Ends</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Red Ends</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Red Ends</em>' attribute.
+	 * @see #setRedEnds(double)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridIndicatorRenderer_RedEnds()
+	 * @model
+	 * @generated
+	 */
+	double getRedEnds();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getRedEnds <em>Red Ends</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Red Ends</em>' attribute.
+	 * @see #getRedEnds()
+	 * @generated
+	 */
+	void setRedEnds(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Green Starts</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Green Starts</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Green Starts</em>' attribute.
+	 * @see #setGreenStarts(double)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridIndicatorRenderer_GreenStarts()
+	 * @model
+	 * @generated
+	 */
+	double getGreenStarts();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getGreenStarts <em>Green Starts</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Green Starts</em>' attribute.
+	 * @see #getGreenStarts()
+	 * @generated
+	 */
+	void setGreenStarts(double value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridNumberRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridNumberRenderer.java
new file mode 100644
index 0000000..0b26fcf
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridNumberRenderer.java
@@ -0,0 +1,91 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Number Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNumberFormat <em>Number Format</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNullRepresentation <em>Null Representation</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridNumberRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridNumberRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Number Format</b></em>' attribute.
+	 * The default value is <code>"#,##0.00"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Number Format</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Number Format</em>' attribute.
+	 * @see #setNumberFormat(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridNumberRenderer_NumberFormat()
+	 * @model default="#,##0.00"
+	 * @generated
+	 */
+	String getNumberFormat();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNumberFormat <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Number Format</em>' attribute.
+	 * @see #getNumberFormat()
+	 * @generated
+	 */
+	void setNumberFormat(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Null Representation</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Null Representation</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Null Representation</em>' attribute.
+	 * @see #setNullRepresentation(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridNumberRenderer_NullRepresentation()
+	 * @model default=""
+	 * @generated
+	 */
+	String getNullRepresentation();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNullRepresentation <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Null Representation</em>' attribute.
+	 * @see #getNullRepresentation()
+	 * @generated
+	 */
+	void setNullRepresentation(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridPriceRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridPriceRenderer.java
new file mode 100644
index 0000000..ce4d7e1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridPriceRenderer.java
@@ -0,0 +1,173 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Price Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getValuePropertyPath <em>Value Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getCurrencyPropertyPath <em>Currency Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNullRepresentation <em>Null Representation</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getHtmlPattern <em>Html Pattern</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNumberFormat <em>Number Format</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridPriceRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridPriceRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Value Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value Property Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value Property Path</em>' attribute.
+	 * @see #setValuePropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridPriceRenderer_ValuePropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getValuePropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getValuePropertyPath <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value Property Path</em>' attribute.
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 */
+	void setValuePropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Currency Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Currency Property Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Currency Property Path</em>' attribute.
+	 * @see #setCurrencyPropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridPriceRenderer_CurrencyPropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getCurrencyPropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getCurrencyPropertyPath <em>Currency Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Currency Property Path</em>' attribute.
+	 * @see #getCurrencyPropertyPath()
+	 * @generated
+	 */
+	void setCurrencyPropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Null Representation</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Null Representation</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Null Representation</em>' attribute.
+	 * @see #setNullRepresentation(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridPriceRenderer_NullRepresentation()
+	 * @model default=""
+	 * @generated
+	 */
+	String getNullRepresentation();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNullRepresentation <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Null Representation</em>' attribute.
+	 * @see #getNullRepresentation()
+	 * @generated
+	 */
+	void setNullRepresentation(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Html Pattern</b></em>' attribute.
+	 * The default value is <code>"<b>{@value}</b> <i>{@currency}</i>"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Html Pattern</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Html Pattern</em>' attribute.
+	 * @see #setHtmlPattern(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridPriceRenderer_HtmlPattern()
+	 * @model default="<b>{@value}</b> <i>{@currency}</i>" required="true"
+	 * @generated
+	 */
+	String getHtmlPattern();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getHtmlPattern <em>Html Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Html Pattern</em>' attribute.
+	 * @see #getHtmlPattern()
+	 * @generated
+	 */
+	void setHtmlPattern(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Number Format</b></em>' attribute.
+	 * The default value is <code>"#,##0.00"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Number Format</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Number Format</em>' attribute.
+	 * @see #setNumberFormat(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridPriceRenderer_NumberFormat()
+	 * @model default="#,##0.00" required="true"
+	 * @generated
+	 */
+	String getNumberFormat();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNumberFormat <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Number Format</em>' attribute.
+	 * @see #getNumberFormat()
+	 * @generated
+	 */
+	void setNumberFormat(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridProgressBarRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridProgressBarRenderer.java
new file mode 100644
index 0000000..c0951cb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridProgressBarRenderer.java
@@ -0,0 +1,63 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Progress Bar Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer#getMaxValue <em>Max Value</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridProgressBarRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridProgressBarRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Max Value</b></em>' attribute.
+	 * The default value is <code>"1"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Max Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Max Value</em>' attribute.
+	 * @see #setMaxValue(double)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridProgressBarRenderer_MaxValue()
+	 * @model default="1"
+	 * @generated
+	 */
+	double getMaxValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer#getMaxValue <em>Max Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Max Value</em>' attribute.
+	 * @see #getMaxValue()
+	 * @generated
+	 */
+	void setMaxValue(double value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridQuantityRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridQuantityRenderer.java
new file mode 100644
index 0000000..4468603
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridQuantityRenderer.java
@@ -0,0 +1,173 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Quantity Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getValuePropertyPath <em>Value Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getUomPropertyPath <em>Uom Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNullRepresentation <em>Null Representation</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getHtmlPattern <em>Html Pattern</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNumberFormat <em>Number Format</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridQuantityRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridQuantityRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Value Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value Property Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value Property Path</em>' attribute.
+	 * @see #setValuePropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridQuantityRenderer_ValuePropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getValuePropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getValuePropertyPath <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value Property Path</em>' attribute.
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 */
+	void setValuePropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Uom Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Uom Property Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Uom Property Path</em>' attribute.
+	 * @see #setUomPropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridQuantityRenderer_UomPropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getUomPropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getUomPropertyPath <em>Uom Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Uom Property Path</em>' attribute.
+	 * @see #getUomPropertyPath()
+	 * @generated
+	 */
+	void setUomPropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Null Representation</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Null Representation</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Null Representation</em>' attribute.
+	 * @see #setNullRepresentation(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridQuantityRenderer_NullRepresentation()
+	 * @model default=""
+	 * @generated
+	 */
+	String getNullRepresentation();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNullRepresentation <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Null Representation</em>' attribute.
+	 * @see #getNullRepresentation()
+	 * @generated
+	 */
+	void setNullRepresentation(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Html Pattern</b></em>' attribute.
+	 * The default value is <code>"<b>{@value}</b> <i>{@currency}</i>"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Html Pattern</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Html Pattern</em>' attribute.
+	 * @see #setHtmlPattern(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridQuantityRenderer_HtmlPattern()
+	 * @model default="<b>{@value}</b> <i>{@currency}</i>" required="true"
+	 * @generated
+	 */
+	String getHtmlPattern();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getHtmlPattern <em>Html Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Html Pattern</em>' attribute.
+	 * @see #getHtmlPattern()
+	 * @generated
+	 */
+	void setHtmlPattern(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Number Format</b></em>' attribute.
+	 * The default value is <code>"#,##0.00"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Number Format</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Number Format</em>' attribute.
+	 * @see #setNumberFormat(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridQuantityRenderer_NumberFormat()
+	 * @model default="#,##0.00" required="true"
+	 * @generated
+	 */
+	String getNumberFormat();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNumberFormat <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Number Format</em>' attribute.
+	 * @see #getNumberFormat()
+	 * @generated
+	 */
+	void setNumberFormat(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRenderer.java
new file mode 100644
index 0000000..f0116ae
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRenderer.java
@@ -0,0 +1,33 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridProvider;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridRenderer()
+ * @model abstract="true"
+ * @generated
+ */
+public interface CxGridRenderer extends YElement, CxGridProvider {
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererClickEvent.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererClickEvent.java
new file mode 100644
index 0000000..286ea62
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererClickEvent.java
@@ -0,0 +1,90 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Click Event</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getRenderer <em>Renderer</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getLastClickTime <em>Last Click Time</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridRendererClickEvent()
+ * @model
+ * @generated
+ */
+public interface CxGridRendererClickEvent extends EObject {
+	
+	/**
+	 * Returns the value of the '<em><b>Renderer</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Renderer</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Renderer</em>' reference.
+	 * @see #setRenderer(CxGridRenderer)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridRendererClickEvent_Renderer()
+	 * @model required="true"
+	 * @generated
+	 */
+	CxGridRenderer getRenderer();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getRenderer <em>Renderer</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Renderer</em>' reference.
+	 * @see #getRenderer()
+	 * @generated
+	 */
+	void setRenderer(CxGridRenderer value);
+
+	/**
+	 * Returns the value of the '<em><b>Last Click Time</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Last Click Time</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Last Click Time</em>' attribute.
+	 * @see #setLastClickTime(long)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridRendererClickEvent_LastClickTime()
+	 * @model
+	 * @generated
+	 */
+	long getLastClickTime();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getLastClickTime <em>Last Click Time</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Last Click Time</em>' attribute.
+	 * @see #getLastClickTime()
+	 * @generated
+	 */
+	void setLastClickTime(long value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererFactory.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererFactory.java
new file mode 100644
index 0000000..dfedd47
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererFactory.java
@@ -0,0 +1,163 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage
+ * @generated
+ */
+public interface CxGridRendererFactory extends EFactory {
+	
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	CxGridRendererFactory eINSTANCE = org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Delegate Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Delegate Renderer</em>'.
+	 * @generated
+	 */
+	CxGridDelegateRenderer createCxGridDelegateRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Date Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Date Renderer</em>'.
+	 * @generated
+	 */
+	CxGridDateRenderer createCxGridDateRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Html Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Html Renderer</em>'.
+	 * @generated
+	 */
+	CxGridHtmlRenderer createCxGridHtmlRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Number Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Number Renderer</em>'.
+	 * @generated
+	 */
+	CxGridNumberRenderer createCxGridNumberRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Progress Bar Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Progress Bar Renderer</em>'.
+	 * @generated
+	 */
+	CxGridProgressBarRenderer createCxGridProgressBarRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Text Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Text Renderer</em>'.
+	 * @generated
+	 */
+	CxGridTextRenderer createCxGridTextRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Button Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Button Renderer</em>'.
+	 * @generated
+	 */
+	CxGridButtonRenderer createCxGridButtonRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Image Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Image Renderer</em>'.
+	 * @generated
+	 */
+	CxGridImageRenderer createCxGridImageRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Click Event</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Click Event</em>'.
+	 * @generated
+	 */
+	CxGridRendererClickEvent createCxGridRendererClickEvent();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Boolean Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Boolean Renderer</em>'.
+	 * @generated
+	 */
+	CxGridBooleanRenderer createCxGridBooleanRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Quantity Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Quantity Renderer</em>'.
+	 * @generated
+	 */
+	CxGridQuantityRenderer createCxGridQuantityRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Price Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Price Renderer</em>'.
+	 * @generated
+	 */
+	CxGridPriceRenderer createCxGridPriceRenderer();
+
+	/**
+	 * Returns a new object of class '<em>Cx Grid Indicator Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Cx Grid Indicator Renderer</em>'.
+	 * @generated
+	 */
+	CxGridIndicatorRenderer createCxGridIndicatorRenderer();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	CxGridRendererPackage getCxGridRendererPackage();
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererPackage.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererPackage.java
new file mode 100644
index 0000000..cd51922
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridRendererPackage.java
@@ -0,0 +1,1845 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface CxGridRendererPackage extends EPackage {
+	
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "renderer";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://osbp.de/ecview/v1/extension/grid/renderer";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "renderer";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	CxGridRendererPackage eINSTANCE = org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl <em>Cx Grid Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridRenderer()
+	 * @generated
+	 */
+	int CX_GRID_RENDERER = 0;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDelegateRendererImpl <em>Cx Grid Delegate Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDelegateRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridDelegateRenderer()
+	 * @generated
+	 */
+	int CX_GRID_DELEGATE_RENDERER = 1;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Delegate Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_RENDERER__DELEGATE_ID = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Delegate Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DELEGATE_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDateRendererImpl <em>Cx Grid Date Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDateRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridDateRenderer()
+	 * @generated
+	 */
+	int CX_GRID_DATE_RENDERER = 2;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DATE_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DATE_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DATE_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DATE_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Date Format</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DATE_RENDERER__DATE_FORMAT = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Date Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_DATE_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridHtmlRendererImpl <em>Cx Grid Html Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridHtmlRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridHtmlRenderer()
+	 * @generated
+	 */
+	int CX_GRID_HTML_RENDERER = 3;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HTML_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HTML_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HTML_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HTML_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Null Representation</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HTML_RENDERER__NULL_REPRESENTATION = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Html Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_HTML_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridNumberRendererImpl <em>Cx Grid Number Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridNumberRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridNumberRenderer()
+	 * @generated
+	 */
+	int CX_GRID_NUMBER_RENDERER = 4;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_NUMBER_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_NUMBER_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_NUMBER_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_NUMBER_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Number Format</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Null Representation</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Number Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_NUMBER_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 2;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridProgressBarRendererImpl <em>Cx Grid Progress Bar Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridProgressBarRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridProgressBarRenderer()
+	 * @generated
+	 */
+	int CX_GRID_PROGRESS_BAR_RENDERER = 5;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PROGRESS_BAR_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PROGRESS_BAR_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PROGRESS_BAR_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PROGRESS_BAR_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Max Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Progress Bar Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PROGRESS_BAR_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridTextRendererImpl <em>Cx Grid Text Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridTextRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridTextRenderer()
+	 * @generated
+	 */
+	int CX_GRID_TEXT_RENDERER = 6;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_TEXT_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_TEXT_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_TEXT_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_TEXT_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Null Representation</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Text Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_TEXT_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridButtonRendererImpl <em>Cx Grid Button Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridButtonRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridButtonRenderer()
+	 * @generated
+	 */
+	int CX_GRID_BUTTON_RENDERER = 7;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Null Representation</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Last Click Event</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Event Topic</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER__EVENT_TOPIC = CX_GRID_RENDERER_FEATURE_COUNT + 2;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Button Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BUTTON_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 3;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridImageRendererImpl <em>Cx Grid Image Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridImageRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridImageRenderer()
+	 * @generated
+	 */
+	int CX_GRID_IMAGE_RENDERER = 8;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_IMAGE_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_IMAGE_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_IMAGE_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_IMAGE_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Last Click Event</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Event Topic</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_IMAGE_RENDERER__EVENT_TOPIC = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Image Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_IMAGE_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 2;
+
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererClickEventImpl <em>Click Event</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererClickEventImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridRendererClickEvent()
+	 * @generated
+	 */
+	int CX_GRID_RENDERER_CLICK_EVENT = 9;
+
+	/**
+	 * The feature id for the '<em><b>Renderer</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER_CLICK_EVENT__RENDERER = 0;
+
+	/**
+	 * The feature id for the '<em><b>Last Click Time</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME = 1;
+
+	/**
+	 * The number of structural features of the '<em>Click Event</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_RENDERER_CLICK_EVENT_FEATURE_COUNT = 2;
+
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridBooleanRendererImpl <em>Cx Grid Boolean Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridBooleanRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridBooleanRenderer()
+	 * @generated
+	 */
+	int CX_GRID_BOOLEAN_RENDERER = 10;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BOOLEAN_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BOOLEAN_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BOOLEAN_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BOOLEAN_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Boolean Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_BOOLEAN_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl <em>Cx Grid Quantity Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridQuantityRenderer()
+	 * @generated
+	 */
+	int CX_GRID_QUANTITY_RENDERER = 11;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Value Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Uom Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Null Representation</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION = CX_GRID_RENDERER_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Html Pattern</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__HTML_PATTERN = CX_GRID_RENDERER_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Number Format</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT = CX_GRID_RENDERER_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Quantity Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_QUANTITY_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 5;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl <em>Cx Grid Price Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridPriceRenderer()
+	 * @generated
+	 */
+	int CX_GRID_PRICE_RENDERER = 12;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Value Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Currency Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Null Representation</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION = CX_GRID_RENDERER_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Html Pattern</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__HTML_PATTERN = CX_GRID_RENDERER_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Number Format</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER__NUMBER_FORMAT = CX_GRID_RENDERER_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Price Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_PRICE_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 5;
+
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridIndicatorRendererImpl <em>Cx Grid Indicator Renderer</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridIndicatorRendererImpl
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridIndicatorRenderer()
+	 * @generated
+	 */
+	int CX_GRID_INDICATOR_RENDERER = 13;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_INDICATOR_RENDERER__TAGS = CX_GRID_RENDERER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_INDICATOR_RENDERER__ID = CX_GRID_RENDERER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_INDICATOR_RENDERER__NAME = CX_GRID_RENDERER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_INDICATOR_RENDERER__PROPERTIES = CX_GRID_RENDERER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Red Ends</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_INDICATOR_RENDERER__RED_ENDS = CX_GRID_RENDERER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Green Starts</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_INDICATOR_RENDERER__GREEN_STARTS = CX_GRID_RENDERER_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>Cx Grid Indicator Renderer</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CX_GRID_INDICATOR_RENDERER_FEATURE_COUNT = CX_GRID_RENDERER_FEATURE_COUNT + 2;
+
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer <em>Cx Grid Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer
+	 * @generated
+	 */
+	EClass getCxGridRenderer();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer <em>Cx Grid Delegate Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Delegate Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer
+	 * @generated
+	 */
+	EClass getCxGridDelegateRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer#getDelegateId <em>Delegate Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Delegate Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer#getDelegateId()
+	 * @see #getCxGridDelegateRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridDelegateRenderer_DelegateId();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer <em>Cx Grid Date Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Date Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer
+	 * @generated
+	 */
+	EClass getCxGridDateRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer#getDateFormat <em>Date Format</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Date Format</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer#getDateFormat()
+	 * @see #getCxGridDateRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridDateRenderer_DateFormat();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer <em>Cx Grid Html Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Html Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer
+	 * @generated
+	 */
+	EClass getCxGridHtmlRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer#getNullRepresentation <em>Null Representation</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Null Representation</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer#getNullRepresentation()
+	 * @see #getCxGridHtmlRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridHtmlRenderer_NullRepresentation();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer <em>Cx Grid Number Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Number Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer
+	 * @generated
+	 */
+	EClass getCxGridNumberRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNumberFormat <em>Number Format</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Number Format</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNumberFormat()
+	 * @see #getCxGridNumberRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridNumberRenderer_NumberFormat();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNullRepresentation <em>Null Representation</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Null Representation</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer#getNullRepresentation()
+	 * @see #getCxGridNumberRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridNumberRenderer_NullRepresentation();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer <em>Cx Grid Progress Bar Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Progress Bar Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer
+	 * @generated
+	 */
+	EClass getCxGridProgressBarRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer#getMaxValue <em>Max Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Max Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer#getMaxValue()
+	 * @see #getCxGridProgressBarRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridProgressBarRenderer_MaxValue();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer <em>Cx Grid Text Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Text Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer
+	 * @generated
+	 */
+	EClass getCxGridTextRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer#getNullRepresentation <em>Null Representation</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Null Representation</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer#getNullRepresentation()
+	 * @see #getCxGridTextRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridTextRenderer_NullRepresentation();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer <em>Cx Grid Button Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Button Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer
+	 * @generated
+	 */
+	EClass getCxGridButtonRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getNullRepresentation <em>Null Representation</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Null Representation</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getNullRepresentation()
+	 * @see #getCxGridButtonRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridButtonRenderer_NullRepresentation();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getLastClickEvent <em>Last Click Event</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Last Click Event</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getLastClickEvent()
+	 * @see #getCxGridButtonRenderer()
+	 * @generated
+	 */
+	EReference getCxGridButtonRenderer_LastClickEvent();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getEventTopic <em>Event Topic</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Event Topic</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer#getEventTopic()
+	 * @see #getCxGridButtonRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridButtonRenderer_EventTopic();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer <em>Cx Grid Image Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Image Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer
+	 * @generated
+	 */
+	EClass getCxGridImageRenderer();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getLastClickEvent <em>Last Click Event</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Last Click Event</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getLastClickEvent()
+	 * @see #getCxGridImageRenderer()
+	 * @generated
+	 */
+	EReference getCxGridImageRenderer_LastClickEvent();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getEventTopic <em>Event Topic</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Event Topic</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer#getEventTopic()
+	 * @see #getCxGridImageRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridImageRenderer_EventTopic();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent <em>Click Event</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Click Event</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent
+	 * @generated
+	 */
+	EClass getCxGridRendererClickEvent();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getRenderer <em>Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getRenderer()
+	 * @see #getCxGridRendererClickEvent()
+	 * @generated
+	 */
+	EReference getCxGridRendererClickEvent_Renderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getLastClickTime <em>Last Click Time</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Last Click Time</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent#getLastClickTime()
+	 * @see #getCxGridRendererClickEvent()
+	 * @generated
+	 */
+	EAttribute getCxGridRendererClickEvent_LastClickTime();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer <em>Cx Grid Boolean Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Boolean Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer
+	 * @generated
+	 */
+	EClass getCxGridBooleanRenderer();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer <em>Cx Grid Quantity Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Quantity Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer
+	 * @generated
+	 */
+	EClass getCxGridQuantityRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getValuePropertyPath <em>Value Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getValuePropertyPath()
+	 * @see #getCxGridQuantityRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridQuantityRenderer_ValuePropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getUomPropertyPath <em>Uom Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Uom Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getUomPropertyPath()
+	 * @see #getCxGridQuantityRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridQuantityRenderer_UomPropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNullRepresentation <em>Null Representation</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Null Representation</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNullRepresentation()
+	 * @see #getCxGridQuantityRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridQuantityRenderer_NullRepresentation();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getHtmlPattern <em>Html Pattern</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Html Pattern</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getHtmlPattern()
+	 * @see #getCxGridQuantityRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridQuantityRenderer_HtmlPattern();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNumberFormat <em>Number Format</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Number Format</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer#getNumberFormat()
+	 * @see #getCxGridQuantityRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridQuantityRenderer_NumberFormat();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer <em>Cx Grid Price Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Price Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer
+	 * @generated
+	 */
+	EClass getCxGridPriceRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getValuePropertyPath <em>Value Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getValuePropertyPath()
+	 * @see #getCxGridPriceRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridPriceRenderer_ValuePropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getCurrencyPropertyPath <em>Currency Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Currency Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getCurrencyPropertyPath()
+	 * @see #getCxGridPriceRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridPriceRenderer_CurrencyPropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNullRepresentation <em>Null Representation</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Null Representation</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNullRepresentation()
+	 * @see #getCxGridPriceRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridPriceRenderer_NullRepresentation();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getHtmlPattern <em>Html Pattern</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Html Pattern</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getHtmlPattern()
+	 * @see #getCxGridPriceRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridPriceRenderer_HtmlPattern();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNumberFormat <em>Number Format</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Number Format</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer#getNumberFormat()
+	 * @see #getCxGridPriceRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridPriceRenderer_NumberFormat();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer <em>Cx Grid Indicator Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Cx Grid Indicator Renderer</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer
+	 * @generated
+	 */
+	EClass getCxGridIndicatorRenderer();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getRedEnds <em>Red Ends</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Red Ends</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getRedEnds()
+	 * @see #getCxGridIndicatorRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridIndicatorRenderer_RedEnds();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getGreenStarts <em>Green Starts</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Green Starts</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer#getGreenStarts()
+	 * @see #getCxGridIndicatorRenderer()
+	 * @generated
+	 */
+	EAttribute getCxGridIndicatorRenderer_GreenStarts();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	CxGridRendererFactory getCxGridRendererFactory();
+
+	/**
+	 * <!-- begin-user-doc --> Defines literals for the meta objects that
+	 * represent
+	 * <ul>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl <em>Cx Grid Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_RENDERER = eINSTANCE.getCxGridRenderer();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDelegateRendererImpl <em>Cx Grid Delegate Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDelegateRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridDelegateRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_DELEGATE_RENDERER = eINSTANCE.getCxGridDelegateRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Delegate Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_DELEGATE_RENDERER__DELEGATE_ID = eINSTANCE.getCxGridDelegateRenderer_DelegateId();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDateRendererImpl <em>Cx Grid Date Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDateRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridDateRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_DATE_RENDERER = eINSTANCE.getCxGridDateRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Date Format</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_DATE_RENDERER__DATE_FORMAT = eINSTANCE.getCxGridDateRenderer_DateFormat();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridHtmlRendererImpl <em>Cx Grid Html Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridHtmlRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridHtmlRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_HTML_RENDERER = eINSTANCE.getCxGridHtmlRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Null Representation</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_HTML_RENDERER__NULL_REPRESENTATION = eINSTANCE.getCxGridHtmlRenderer_NullRepresentation();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridNumberRendererImpl <em>Cx Grid Number Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridNumberRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridNumberRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_NUMBER_RENDERER = eINSTANCE.getCxGridNumberRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Number Format</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT = eINSTANCE.getCxGridNumberRenderer_NumberFormat();
+
+		/**
+		 * The meta object literal for the '<em><b>Null Representation</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION = eINSTANCE.getCxGridNumberRenderer_NullRepresentation();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridProgressBarRendererImpl <em>Cx Grid Progress Bar Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridProgressBarRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridProgressBarRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_PROGRESS_BAR_RENDERER = eINSTANCE.getCxGridProgressBarRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Max Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE = eINSTANCE.getCxGridProgressBarRenderer_MaxValue();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridTextRendererImpl <em>Cx Grid Text Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridTextRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridTextRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_TEXT_RENDERER = eINSTANCE.getCxGridTextRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Null Representation</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION = eINSTANCE.getCxGridTextRenderer_NullRepresentation();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridButtonRendererImpl <em>Cx Grid Button Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridButtonRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridButtonRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_BUTTON_RENDERER = eINSTANCE.getCxGridButtonRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Null Representation</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION = eINSTANCE.getCxGridButtonRenderer_NullRepresentation();
+
+		/**
+		 * The meta object literal for the '<em><b>Last Click Event</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT = eINSTANCE.getCxGridButtonRenderer_LastClickEvent();
+
+		/**
+		 * The meta object literal for the '<em><b>Event Topic</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_BUTTON_RENDERER__EVENT_TOPIC = eINSTANCE.getCxGridButtonRenderer_EventTopic();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridImageRendererImpl <em>Cx Grid Image Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridImageRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridImageRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_IMAGE_RENDERER = eINSTANCE.getCxGridImageRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Last Click Event</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT = eINSTANCE.getCxGridImageRenderer_LastClickEvent();
+
+		/**
+		 * The meta object literal for the '<em><b>Event Topic</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_IMAGE_RENDERER__EVENT_TOPIC = eINSTANCE.getCxGridImageRenderer_EventTopic();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererClickEventImpl <em>Click Event</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererClickEventImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridRendererClickEvent()
+		 * @generated
+		 */
+		EClass CX_GRID_RENDERER_CLICK_EVENT = eINSTANCE.getCxGridRendererClickEvent();
+
+		/**
+		 * The meta object literal for the '<em><b>Renderer</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference CX_GRID_RENDERER_CLICK_EVENT__RENDERER = eINSTANCE.getCxGridRendererClickEvent_Renderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Last Click Time</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME = eINSTANCE.getCxGridRendererClickEvent_LastClickTime();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridBooleanRendererImpl <em>Cx Grid Boolean Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridBooleanRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridBooleanRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_BOOLEAN_RENDERER = eINSTANCE.getCxGridBooleanRenderer();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl <em>Cx Grid Quantity Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridQuantityRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_QUANTITY_RENDERER = eINSTANCE.getCxGridQuantityRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Value Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH = eINSTANCE.getCxGridQuantityRenderer_ValuePropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Uom Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH = eINSTANCE.getCxGridQuantityRenderer_UomPropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Null Representation</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION = eINSTANCE.getCxGridQuantityRenderer_NullRepresentation();
+
+		/**
+		 * The meta object literal for the '<em><b>Html Pattern</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_QUANTITY_RENDERER__HTML_PATTERN = eINSTANCE.getCxGridQuantityRenderer_HtmlPattern();
+
+		/**
+		 * The meta object literal for the '<em><b>Number Format</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT = eINSTANCE.getCxGridQuantityRenderer_NumberFormat();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl <em>Cx Grid Price Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridPriceRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_PRICE_RENDERER = eINSTANCE.getCxGridPriceRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Value Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH = eINSTANCE.getCxGridPriceRenderer_ValuePropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Currency Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH = eINSTANCE.getCxGridPriceRenderer_CurrencyPropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Null Representation</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION = eINSTANCE.getCxGridPriceRenderer_NullRepresentation();
+
+		/**
+		 * The meta object literal for the '<em><b>Html Pattern</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_PRICE_RENDERER__HTML_PATTERN = eINSTANCE.getCxGridPriceRenderer_HtmlPattern();
+
+		/**
+		 * The meta object literal for the '<em><b>Number Format</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_PRICE_RENDERER__NUMBER_FORMAT = eINSTANCE.getCxGridPriceRenderer_NumberFormat();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridIndicatorRendererImpl <em>Cx Grid Indicator Renderer</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridIndicatorRendererImpl
+		 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererPackageImpl#getCxGridIndicatorRenderer()
+		 * @generated
+		 */
+		EClass CX_GRID_INDICATOR_RENDERER = eINSTANCE.getCxGridIndicatorRenderer();
+
+		/**
+		 * The meta object literal for the '<em><b>Red Ends</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_INDICATOR_RENDERER__RED_ENDS = eINSTANCE.getCxGridIndicatorRenderer_RedEnds();
+
+		/**
+		 * The meta object literal for the '<em><b>Green Starts</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CX_GRID_INDICATOR_RENDERER__GREEN_STARTS = eINSTANCE.getCxGridIndicatorRenderer_GreenStarts();
+
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridTextRenderer.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridTextRenderer.java
new file mode 100644
index 0000000..4aad7ba
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/CxGridTextRenderer.java
@@ -0,0 +1,63 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Cx Grid Text Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer#getNullRepresentation <em>Null Representation</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridTextRenderer()
+ * @model
+ * @generated
+ */
+public interface CxGridTextRenderer extends CxGridRenderer {
+	
+	/**
+	 * Returns the value of the '<em><b>Null Representation</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Null Representation</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Null Representation</em>' attribute.
+	 * @see #setNullRepresentation(String)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#getCxGridTextRenderer_NullRepresentation()
+	 * @model default=""
+	 * @generated
+	 */
+	String getNullRepresentation();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer#getNullRepresentation <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Null Representation</em>' attribute.
+	 * @see #getNullRepresentation()
+	 * @generated
+	 */
+	void setNullRepresentation(String value);
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridBooleanRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridBooleanRendererImpl.java
new file mode 100644
index 0000000..ca1afa6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridBooleanRendererImpl.java
@@ -0,0 +1,53 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Boolean Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridBooleanRendererImpl extends CxGridRendererImpl implements CxGridBooleanRenderer {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridBooleanRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_BOOLEAN_RENDERER;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridButtonRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridButtonRendererImpl.java
new file mode 100644
index 0000000..941d8e1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridButtonRendererImpl.java
@@ -0,0 +1,371 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.binding.BindingFactory;
+import org.eclipse.osbp.ecview.core.common.model.binding.YECViewModelValueBindingEndpoint;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Cx Grid Button Renderer</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridButtonRendererImpl#getNullRepresentation <em>Null Representation</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridButtonRendererImpl#getLastClickEvent <em>Last Click Event</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridButtonRendererImpl#getEventTopic <em>Event Topic</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridButtonRendererImpl extends CxGridRendererImpl implements
+		CxGridButtonRenderer {
+	
+	/**
+	 * The default value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NULL_REPRESENTATION_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected String nullRepresentation = NULL_REPRESENTATION_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getLastClickEvent() <em>Last Click Event</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLastClickEvent()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridRendererClickEvent lastClickEvent;
+
+	/**
+	 * The default value of the '{@link #getEventTopic() <em>Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEventTopic()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String EVENT_TOPIC_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getEventTopic() <em>Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEventTopic()
+	 * @generated
+	 * @ordered
+	 */
+	protected String eventTopic = EVENT_TOPIC_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridButtonRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_BUTTON_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNullRepresentation()
+	 *         <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public String getNullRepresentation() {
+		return nullRepresentation;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNullRepresentation
+	 *            the new cached value of the '{@link #getNullRepresentation()
+	 *            <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public void setNullRepresentation(String newNullRepresentation) {
+		String oldNullRepresentation = nullRepresentation;
+		nullRepresentation = newNullRepresentation;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION, oldNullRepresentation, nullRepresentation));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLastClickEvent()
+	 *         <em>Last Click Event</em>}' containment reference
+	 * @generated
+	 */
+	public CxGridRendererClickEvent getLastClickEvent() {
+		return lastClickEvent;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLastClickEvent
+	 *            the new last click event
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetLastClickEvent(CxGridRendererClickEvent newLastClickEvent, NotificationChain msgs) {
+		CxGridRendererClickEvent oldLastClickEvent = lastClickEvent;
+		lastClickEvent = newLastClickEvent;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT, oldLastClickEvent, newLastClickEvent);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLastClickEvent
+	 *            the new cached value of the '{@link #getLastClickEvent()
+	 *            <em>Last Click Event</em>}' containment reference
+	 * @generated
+	 */
+	public void setLastClickEvent(CxGridRendererClickEvent newLastClickEvent) {
+		if (newLastClickEvent != lastClickEvent) {
+			NotificationChain msgs = null;
+			if (lastClickEvent != null)
+				msgs = ((InternalEObject)lastClickEvent).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT, null, msgs);
+			if (newLastClickEvent != null)
+				msgs = ((InternalEObject)newLastClickEvent).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT, null, msgs);
+			msgs = basicSetLastClickEvent(newLastClickEvent, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT, newLastClickEvent, newLastClickEvent));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEventTopic()
+	 *         <em>Event Topic</em>}' attribute
+	 * @generated
+	 */
+	public String getEventTopic() {
+		return eventTopic;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEventTopic
+	 *            the new cached value of the '{@link #getEventTopic()
+	 *            <em>Event Topic</em>}' attribute
+	 * @generated
+	 */
+	public void setEventTopic(String newEventTopic) {
+		String oldEventTopic = eventTopic;
+		eventTopic = newEventTopic;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__EVENT_TOPIC, oldEventTopic, eventTopic));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the YEC view model value binding endpoint
+	 */
+	public YECViewModelValueBindingEndpoint createLastClickEventEndpoint() {
+		YECViewModelValueBindingEndpoint endpoint = BindingFactory.eINSTANCE
+				.createYECViewModelValueBindingEndpoint();
+		endpoint.setElement(this);
+		endpoint.getFeatures()
+				.add((EStructuralFeature) CxGridRendererPackage.Literals.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT);
+		return endpoint;
+	
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT:
+				return basicSetLastClickEvent(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION:
+				return getNullRepresentation();
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT:
+				return getLastClickEvent();
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__EVENT_TOPIC:
+				return getEventTopic();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT:
+				setLastClickEvent((CxGridRendererClickEvent)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__EVENT_TOPIC:
+				setEventTopic((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation(NULL_REPRESENTATION_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT:
+				setLastClickEvent((CxGridRendererClickEvent)null);
+				return;
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__EVENT_TOPIC:
+				setEventTopic(EVENT_TOPIC_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION:
+				return NULL_REPRESENTATION_EDEFAULT == null ? nullRepresentation != null : !NULL_REPRESENTATION_EDEFAULT.equals(nullRepresentation);
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT:
+				return lastClickEvent != null;
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER__EVENT_TOPIC:
+				return EVENT_TOPIC_EDEFAULT == null ? eventTopic != null : !EVENT_TOPIC_EDEFAULT.equals(eventTopic);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (nullRepresentation: ");
+		result.append(nullRepresentation);
+		result.append(", eventTopic: ");
+		result.append(eventTopic);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridDateRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridDateRendererImpl.java
new file mode 100644
index 0000000..25738d6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridDateRendererImpl.java
@@ -0,0 +1,195 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Date Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDateRendererImpl#getDateFormat <em>Date Format</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridDateRendererImpl extends CxGridRendererImpl implements CxGridDateRenderer {
+	
+	/**
+	 * The default value of the '{@link #getDateFormat() <em>Date Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDateFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DATE_FORMAT_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDateFormat() <em>Date Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDateFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected String dateFormat = DATE_FORMAT_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridDateRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_DATE_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDateFormat()
+	 *         <em>Date Format</em>}' attribute
+	 * @generated
+	 */
+	public String getDateFormat() {
+		return dateFormat;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDateFormat
+	 *            the new cached value of the '{@link #getDateFormat()
+	 *            <em>Date Format</em>}' attribute
+	 * @generated
+	 */
+	public void setDateFormat(String newDateFormat) {
+		String oldDateFormat = dateFormat;
+		dateFormat = newDateFormat;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_DATE_RENDERER__DATE_FORMAT, oldDateFormat, dateFormat));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DATE_RENDERER__DATE_FORMAT:
+				return getDateFormat();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DATE_RENDERER__DATE_FORMAT:
+				setDateFormat((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DATE_RENDERER__DATE_FORMAT:
+				setDateFormat(DATE_FORMAT_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DATE_RENDERER__DATE_FORMAT:
+				return DATE_FORMAT_EDEFAULT == null ? dateFormat != null : !DATE_FORMAT_EDEFAULT.equals(dateFormat);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (dateFormat: ");
+		result.append(dateFormat);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridDelegateRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridDelegateRendererImpl.java
new file mode 100644
index 0000000..bcfc57f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridDelegateRendererImpl.java
@@ -0,0 +1,204 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+import org.eclipse.emf.common.notify.Notification;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Cx Grid Delegate Renderer</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridDelegateRendererImpl#getDelegateId <em>Delegate Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridDelegateRendererImpl extends CxGridRendererImpl implements
+		CxGridDelegateRenderer {
+	
+	/**
+	 * The default value of the '{@link #getDelegateId() <em>Delegate Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DELEGATE_ID_EDEFAULT = null;
+	/**
+	 * The cached value of the '{@link #getDelegateId() <em>Delegate Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String delegateId = DELEGATE_ID_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridDelegateRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_DELEGATE_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDelegateId()
+	 *         <em>Delegate Id</em>}' attribute
+	 * @generated
+	 */
+	public String getDelegateId() {
+		return delegateId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDelegateId
+	 *            the new cached value of the '{@link #getDelegateId()
+	 *            <em>Delegate Id</em>}' attribute
+	 * @generated
+	 */
+	public void setDelegateId(String newDelegateId) {
+		String oldDelegateId = delegateId;
+		delegateId = newDelegateId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER__DELEGATE_ID, oldDelegateId, delegateId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER__DELEGATE_ID:
+				return getDelegateId();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER__DELEGATE_ID:
+				setDelegateId((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER__DELEGATE_ID:
+				setDelegateId(DELEGATE_ID_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER__DELEGATE_ID:
+				return DELEGATE_ID_EDEFAULT == null ? delegateId != null : !DELEGATE_ID_EDEFAULT.equals(delegateId);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (delegateId: ");
+		result.append(delegateId);
+		result.append(')');
+		return result.toString();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridHtmlRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridHtmlRendererImpl.java
new file mode 100644
index 0000000..3d30d33
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridHtmlRendererImpl.java
@@ -0,0 +1,195 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Html Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridHtmlRendererImpl#getNullRepresentation <em>Null Representation</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridHtmlRendererImpl extends CxGridRendererImpl implements CxGridHtmlRenderer {
+	
+	/**
+	 * The default value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NULL_REPRESENTATION_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected String nullRepresentation = NULL_REPRESENTATION_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridHtmlRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_HTML_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNullRepresentation()
+	 *         <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public String getNullRepresentation() {
+		return nullRepresentation;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNullRepresentation
+	 *            the new cached value of the '{@link #getNullRepresentation()
+	 *            <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public void setNullRepresentation(String newNullRepresentation) {
+		String oldNullRepresentation = nullRepresentation;
+		nullRepresentation = newNullRepresentation;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_HTML_RENDERER__NULL_REPRESENTATION, oldNullRepresentation, nullRepresentation));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_HTML_RENDERER__NULL_REPRESENTATION:
+				return getNullRepresentation();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_HTML_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_HTML_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation(NULL_REPRESENTATION_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_HTML_RENDERER__NULL_REPRESENTATION:
+				return NULL_REPRESENTATION_EDEFAULT == null ? nullRepresentation != null : !NULL_REPRESENTATION_EDEFAULT.equals(nullRepresentation);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (nullRepresentation: ");
+		result.append(nullRepresentation);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridImageRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridImageRendererImpl.java
new file mode 100644
index 0000000..569725a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridImageRendererImpl.java
@@ -0,0 +1,308 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.binding.YECViewModelValueBindingEndpoint;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Cx Grid Image Renderer</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridImageRendererImpl#getLastClickEvent <em>Last Click Event</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridImageRendererImpl#getEventTopic <em>Event Topic</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridImageRendererImpl extends CxGridRendererImpl implements
+		CxGridImageRenderer {
+	
+	/**
+	 * The cached value of the '{@link #getLastClickEvent() <em>Last Click Event</em>}' containment reference.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @see #getLastClickEvent()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridRendererClickEvent lastClickEvent;
+
+	/**
+	 * The default value of the '{@link #getEventTopic() <em>Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEventTopic()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String EVENT_TOPIC_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getEventTopic() <em>Event Topic</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEventTopic()
+	 * @generated
+	 * @ordered
+	 */
+	protected String eventTopic = EVENT_TOPIC_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridImageRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_IMAGE_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLastClickEvent()
+	 *         <em>Last Click Event</em>}' containment reference
+	 * @generated
+	 */
+	public CxGridRendererClickEvent getLastClickEvent() {
+		return lastClickEvent;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLastClickEvent
+	 *            the new last click event
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetLastClickEvent(
+			CxGridRendererClickEvent newLastClickEvent, NotificationChain msgs) {
+		CxGridRendererClickEvent oldLastClickEvent = lastClickEvent;
+		lastClickEvent = newLastClickEvent;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT, oldLastClickEvent, newLastClickEvent);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLastClickEvent
+	 *            the new cached value of the '{@link #getLastClickEvent()
+	 *            <em>Last Click Event</em>}' containment reference
+	 * @generated
+	 */
+	public void setLastClickEvent(CxGridRendererClickEvent newLastClickEvent) {
+		if (newLastClickEvent != lastClickEvent) {
+			NotificationChain msgs = null;
+			if (lastClickEvent != null)
+				msgs = ((InternalEObject)lastClickEvent).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT, null, msgs);
+			if (newLastClickEvent != null)
+				msgs = ((InternalEObject)newLastClickEvent).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT, null, msgs);
+			msgs = basicSetLastClickEvent(newLastClickEvent, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT, newLastClickEvent, newLastClickEvent));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEventTopic()
+	 *         <em>Event Topic</em>}' attribute
+	 * @generated
+	 */
+	public String getEventTopic() {
+		return eventTopic;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEventTopic
+	 *            the new cached value of the '{@link #getEventTopic()
+	 *            <em>Event Topic</em>}' attribute
+	 * @generated
+	 */
+	public void setEventTopic(String newEventTopic) {
+		String oldEventTopic = eventTopic;
+		eventTopic = newEventTopic;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__EVENT_TOPIC, oldEventTopic, eventTopic));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the YEC view model value binding endpoint
+	 * @generated
+	 */
+	public YECViewModelValueBindingEndpoint createLastClickEventEndpoint() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT:
+				return basicSetLastClickEvent(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT:
+				return getLastClickEvent();
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__EVENT_TOPIC:
+				return getEventTopic();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT:
+				setLastClickEvent((CxGridRendererClickEvent)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__EVENT_TOPIC:
+				setEventTopic((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT:
+				setLastClickEvent((CxGridRendererClickEvent)null);
+				return;
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__EVENT_TOPIC:
+				setEventTopic(EVENT_TOPIC_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT:
+				return lastClickEvent != null;
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER__EVENT_TOPIC:
+				return EVENT_TOPIC_EDEFAULT == null ? eventTopic != null : !EVENT_TOPIC_EDEFAULT.equals(eventTopic);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (eventTopic: ");
+		result.append(eventTopic);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridIndicatorRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridIndicatorRendererImpl.java
new file mode 100644
index 0000000..92c9b51
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridIndicatorRendererImpl.java
@@ -0,0 +1,257 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Indicator Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridIndicatorRendererImpl#getRedEnds <em>Red Ends</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridIndicatorRendererImpl#getGreenStarts <em>Green Starts</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridIndicatorRendererImpl extends CxGridRendererImpl implements CxGridIndicatorRenderer {
+	
+	/**
+	 * The default value of the '{@link #getRedEnds() <em>Red Ends</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getRedEnds()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double RED_ENDS_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getRedEnds() <em>Red Ends</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getRedEnds()
+	 * @generated
+	 * @ordered
+	 */
+	protected double redEnds = RED_ENDS_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getGreenStarts() <em>Green Starts</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGreenStarts()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double GREEN_STARTS_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getGreenStarts() <em>Green Starts</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGreenStarts()
+	 * @generated
+	 * @ordered
+	 */
+	protected double greenStarts = GREEN_STARTS_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridIndicatorRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_INDICATOR_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getRedEnds() <em>Red Ends</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public double getRedEnds() {
+		return redEnds;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newRedEnds
+	 *            the new cached value of the '{@link #getRedEnds()
+	 *            <em>Red Ends</em>}' attribute
+	 * @generated
+	 */
+	public void setRedEnds(double newRedEnds) {
+		double oldRedEnds = redEnds;
+		redEnds = newRedEnds;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__RED_ENDS, oldRedEnds, redEnds));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getGreenStarts()
+	 *         <em>Green Starts</em>}' attribute
+	 * @generated
+	 */
+	public double getGreenStarts() {
+		return greenStarts;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newGreenStarts
+	 *            the new cached value of the '{@link #getGreenStarts()
+	 *            <em>Green Starts</em>}' attribute
+	 * @generated
+	 */
+	public void setGreenStarts(double newGreenStarts) {
+		double oldGreenStarts = greenStarts;
+		greenStarts = newGreenStarts;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__GREEN_STARTS, oldGreenStarts, greenStarts));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__RED_ENDS:
+				return getRedEnds();
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__GREEN_STARTS:
+				return getGreenStarts();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__RED_ENDS:
+				setRedEnds((Double)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__GREEN_STARTS:
+				setGreenStarts((Double)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__RED_ENDS:
+				setRedEnds(RED_ENDS_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__GREEN_STARTS:
+				setGreenStarts(GREEN_STARTS_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__RED_ENDS:
+				return redEnds != RED_ENDS_EDEFAULT;
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER__GREEN_STARTS:
+				return greenStarts != GREEN_STARTS_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (redEnds: ");
+		result.append(redEnds);
+		result.append(", greenStarts: ");
+		result.append(greenStarts);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridNumberRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridNumberRendererImpl.java
new file mode 100644
index 0000000..ab9e1c4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridNumberRendererImpl.java
@@ -0,0 +1,254 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Number Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridNumberRendererImpl#getNumberFormat <em>Number Format</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridNumberRendererImpl#getNullRepresentation <em>Null Representation</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridNumberRendererImpl extends CxGridRendererImpl implements CxGridNumberRenderer {
+	
+	/**
+	 * The default value of the '{@link #getNumberFormat() <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NUMBER_FORMAT_EDEFAULT = "#,##0.00";
+
+	/**
+	 * The cached value of the '{@link #getNumberFormat() <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected String numberFormat = NUMBER_FORMAT_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NULL_REPRESENTATION_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected String nullRepresentation = NULL_REPRESENTATION_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridNumberRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_NUMBER_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNumberFormat()
+	 *         <em>Number Format</em>}' attribute
+	 * @generated
+	 */
+	public String getNumberFormat() {
+		return numberFormat;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNumberFormat
+	 *            the new cached value of the '{@link #getNumberFormat()
+	 *            <em>Number Format</em>}' attribute
+	 * @generated
+	 */
+	public void setNumberFormat(String newNumberFormat) {
+		String oldNumberFormat = numberFormat;
+		numberFormat = newNumberFormat;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT, oldNumberFormat, numberFormat));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNullRepresentation()
+	 *         <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public String getNullRepresentation() {
+		return nullRepresentation;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNullRepresentation
+	 *            the new cached value of the '{@link #getNullRepresentation()
+	 *            <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public void setNullRepresentation(String newNullRepresentation) {
+		String oldNullRepresentation = nullRepresentation;
+		nullRepresentation = newNullRepresentation;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION, oldNullRepresentation, nullRepresentation));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT:
+				return getNumberFormat();
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION:
+				return getNullRepresentation();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT:
+				setNumberFormat((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT:
+				setNumberFormat(NUMBER_FORMAT_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation(NULL_REPRESENTATION_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT:
+				return NUMBER_FORMAT_EDEFAULT == null ? numberFormat != null : !NUMBER_FORMAT_EDEFAULT.equals(numberFormat);
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION:
+				return NULL_REPRESENTATION_EDEFAULT == null ? nullRepresentation != null : !NULL_REPRESENTATION_EDEFAULT.equals(nullRepresentation);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (numberFormat: ");
+		result.append(numberFormat);
+		result.append(", nullRepresentation: ");
+		result.append(nullRepresentation);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridPriceRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridPriceRendererImpl.java
new file mode 100644
index 0000000..c81a059
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridPriceRendererImpl.java
@@ -0,0 +1,435 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Price Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl#getValuePropertyPath <em>Value Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl#getCurrencyPropertyPath <em>Currency Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl#getNullRepresentation <em>Null Representation</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl#getHtmlPattern <em>Html Pattern</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridPriceRendererImpl#getNumberFormat <em>Number Format</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridPriceRendererImpl extends CxGridRendererImpl implements CxGridPriceRenderer {
+	
+	/**
+	 * The default value of the '{@link #getValuePropertyPath() <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValuePropertyPath() <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String valuePropertyPath = VALUE_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getCurrencyPropertyPath() <em>Currency Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCurrencyPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String CURRENCY_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getCurrencyPropertyPath() <em>Currency Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCurrencyPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String currencyPropertyPath = CURRENCY_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NULL_REPRESENTATION_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected String nullRepresentation = NULL_REPRESENTATION_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getHtmlPattern() <em>Html Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHtmlPattern()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String HTML_PATTERN_EDEFAULT = "<b>{@value}</b> <i>{@currency}</i>";
+
+	/**
+	 * The cached value of the '{@link #getHtmlPattern() <em>Html Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHtmlPattern()
+	 * @generated
+	 * @ordered
+	 */
+	protected String htmlPattern = HTML_PATTERN_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getNumberFormat() <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NUMBER_FORMAT_EDEFAULT = "#,##0.00";
+
+	/**
+	 * The cached value of the '{@link #getNumberFormat() <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected String numberFormat = NUMBER_FORMAT_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridPriceRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_PRICE_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValuePropertyPath()
+	 *         <em>Value Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getValuePropertyPath() {
+		return valuePropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValuePropertyPath
+	 *            the new cached value of the '{@link #getValuePropertyPath()
+	 *            <em>Value Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setValuePropertyPath(String newValuePropertyPath) {
+		String oldValuePropertyPath = valuePropertyPath;
+		valuePropertyPath = newValuePropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH, oldValuePropertyPath, valuePropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCurrencyPropertyPath()
+	 *         <em>Currency Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getCurrencyPropertyPath() {
+		return currencyPropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCurrencyPropertyPath
+	 *            the new cached value of the '
+	 *            {@link #getCurrencyPropertyPath()
+	 *            <em>Currency Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setCurrencyPropertyPath(String newCurrencyPropertyPath) {
+		String oldCurrencyPropertyPath = currencyPropertyPath;
+		currencyPropertyPath = newCurrencyPropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH, oldCurrencyPropertyPath, currencyPropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNullRepresentation()
+	 *         <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public String getNullRepresentation() {
+		return nullRepresentation;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNullRepresentation
+	 *            the new cached value of the '{@link #getNullRepresentation()
+	 *            <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public void setNullRepresentation(String newNullRepresentation) {
+		String oldNullRepresentation = nullRepresentation;
+		nullRepresentation = newNullRepresentation;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION, oldNullRepresentation, nullRepresentation));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getHtmlPattern()
+	 *         <em>Html Pattern</em>}' attribute
+	 * @generated
+	 */
+	public String getHtmlPattern() {
+		return htmlPattern;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHtmlPattern
+	 *            the new cached value of the '{@link #getHtmlPattern()
+	 *            <em>Html Pattern</em>}' attribute
+	 * @generated
+	 */
+	public void setHtmlPattern(String newHtmlPattern) {
+		String oldHtmlPattern = htmlPattern;
+		htmlPattern = newHtmlPattern;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_PRICE_RENDERER__HTML_PATTERN, oldHtmlPattern, htmlPattern));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNumberFormat()
+	 *         <em>Number Format</em>}' attribute
+	 * @generated
+	 */
+	public String getNumberFormat() {
+		return numberFormat;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNumberFormat
+	 *            the new cached value of the '{@link #getNumberFormat()
+	 *            <em>Number Format</em>}' attribute
+	 * @generated
+	 */
+	public void setNumberFormat(String newNumberFormat) {
+		String oldNumberFormat = numberFormat;
+		numberFormat = newNumberFormat;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NUMBER_FORMAT, oldNumberFormat, numberFormat));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH:
+				return getValuePropertyPath();
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH:
+				return getCurrencyPropertyPath();
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION:
+				return getNullRepresentation();
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__HTML_PATTERN:
+				return getHtmlPattern();
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NUMBER_FORMAT:
+				return getNumberFormat();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH:
+				setValuePropertyPath((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH:
+				setCurrencyPropertyPath((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__HTML_PATTERN:
+				setHtmlPattern((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NUMBER_FORMAT:
+				setNumberFormat((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH:
+				setValuePropertyPath(VALUE_PROPERTY_PATH_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH:
+				setCurrencyPropertyPath(CURRENCY_PROPERTY_PATH_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation(NULL_REPRESENTATION_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__HTML_PATTERN:
+				setHtmlPattern(HTML_PATTERN_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NUMBER_FORMAT:
+				setNumberFormat(NUMBER_FORMAT_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH:
+				return VALUE_PROPERTY_PATH_EDEFAULT == null ? valuePropertyPath != null : !VALUE_PROPERTY_PATH_EDEFAULT.equals(valuePropertyPath);
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH:
+				return CURRENCY_PROPERTY_PATH_EDEFAULT == null ? currencyPropertyPath != null : !CURRENCY_PROPERTY_PATH_EDEFAULT.equals(currencyPropertyPath);
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION:
+				return NULL_REPRESENTATION_EDEFAULT == null ? nullRepresentation != null : !NULL_REPRESENTATION_EDEFAULT.equals(nullRepresentation);
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__HTML_PATTERN:
+				return HTML_PATTERN_EDEFAULT == null ? htmlPattern != null : !HTML_PATTERN_EDEFAULT.equals(htmlPattern);
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER__NUMBER_FORMAT:
+				return NUMBER_FORMAT_EDEFAULT == null ? numberFormat != null : !NUMBER_FORMAT_EDEFAULT.equals(numberFormat);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (valuePropertyPath: ");
+		result.append(valuePropertyPath);
+		result.append(", currencyPropertyPath: ");
+		result.append(currencyPropertyPath);
+		result.append(", nullRepresentation: ");
+		result.append(nullRepresentation);
+		result.append(", htmlPattern: ");
+		result.append(htmlPattern);
+		result.append(", numberFormat: ");
+		result.append(numberFormat);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridProgressBarRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridProgressBarRendererImpl.java
new file mode 100644
index 0000000..1d0abed
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridProgressBarRendererImpl.java
@@ -0,0 +1,194 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Progress Bar Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridProgressBarRendererImpl#getMaxValue <em>Max Value</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridProgressBarRendererImpl extends CxGridRendererImpl implements CxGridProgressBarRenderer {
+	
+	/**
+	 * The default value of the '{@link #getMaxValue() <em>Max Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMaxValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double MAX_VALUE_EDEFAULT = 1.0;
+	/**
+	 * The cached value of the '{@link #getMaxValue() <em>Max Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMaxValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected double maxValue = MAX_VALUE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridProgressBarRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_PROGRESS_BAR_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getMaxValue()
+	 *         <em>Max Value</em>}' attribute
+	 * @generated
+	 */
+	public double getMaxValue() {
+		return maxValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newMaxValue
+	 *            the new cached value of the '{@link #getMaxValue()
+	 *            <em>Max Value</em>}' attribute
+	 * @generated
+	 */
+	public void setMaxValue(double newMaxValue) {
+		double oldMaxValue = maxValue;
+		maxValue = newMaxValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE, oldMaxValue, maxValue));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE:
+				return getMaxValue();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE:
+				setMaxValue((Double)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE:
+				setMaxValue(MAX_VALUE_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE:
+				return maxValue != MAX_VALUE_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (maxValue: ");
+		result.append(maxValue);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridQuantityRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridQuantityRendererImpl.java
new file mode 100644
index 0000000..f2d603d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridQuantityRendererImpl.java
@@ -0,0 +1,434 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Quantity Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl#getValuePropertyPath <em>Value Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl#getUomPropertyPath <em>Uom Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl#getNullRepresentation <em>Null Representation</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl#getHtmlPattern <em>Html Pattern</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridQuantityRendererImpl#getNumberFormat <em>Number Format</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridQuantityRendererImpl extends CxGridRendererImpl implements CxGridQuantityRenderer {
+	
+	/**
+	 * The default value of the '{@link #getValuePropertyPath() <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValuePropertyPath() <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String valuePropertyPath = VALUE_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getUomPropertyPath() <em>Uom Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUomPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String UOM_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getUomPropertyPath() <em>Uom Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUomPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String uomPropertyPath = UOM_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NULL_REPRESENTATION_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected String nullRepresentation = NULL_REPRESENTATION_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getHtmlPattern() <em>Html Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHtmlPattern()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String HTML_PATTERN_EDEFAULT = "<b>{@value}</b> <i>{@currency}</i>";
+
+	/**
+	 * The cached value of the '{@link #getHtmlPattern() <em>Html Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHtmlPattern()
+	 * @generated
+	 * @ordered
+	 */
+	protected String htmlPattern = HTML_PATTERN_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getNumberFormat() <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NUMBER_FORMAT_EDEFAULT = "#,##0.00";
+
+	/**
+	 * The cached value of the '{@link #getNumberFormat() <em>Number Format</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormat()
+	 * @generated
+	 * @ordered
+	 */
+	protected String numberFormat = NUMBER_FORMAT_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridQuantityRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_QUANTITY_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValuePropertyPath()
+	 *         <em>Value Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getValuePropertyPath() {
+		return valuePropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValuePropertyPath
+	 *            the new cached value of the '{@link #getValuePropertyPath()
+	 *            <em>Value Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setValuePropertyPath(String newValuePropertyPath) {
+		String oldValuePropertyPath = valuePropertyPath;
+		valuePropertyPath = newValuePropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH, oldValuePropertyPath, valuePropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getUomPropertyPath()
+	 *         <em>Uom Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getUomPropertyPath() {
+		return uomPropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newUomPropertyPath
+	 *            the new cached value of the '{@link #getUomPropertyPath()
+	 *            <em>Uom Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setUomPropertyPath(String newUomPropertyPath) {
+		String oldUomPropertyPath = uomPropertyPath;
+		uomPropertyPath = newUomPropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH, oldUomPropertyPath, uomPropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNullRepresentation()
+	 *         <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public String getNullRepresentation() {
+		return nullRepresentation;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNullRepresentation
+	 *            the new cached value of the '{@link #getNullRepresentation()
+	 *            <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public void setNullRepresentation(String newNullRepresentation) {
+		String oldNullRepresentation = nullRepresentation;
+		nullRepresentation = newNullRepresentation;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION, oldNullRepresentation, nullRepresentation));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getHtmlPattern()
+	 *         <em>Html Pattern</em>}' attribute
+	 * @generated
+	 */
+	public String getHtmlPattern() {
+		return htmlPattern;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newHtmlPattern
+	 *            the new cached value of the '{@link #getHtmlPattern()
+	 *            <em>Html Pattern</em>}' attribute
+	 * @generated
+	 */
+	public void setHtmlPattern(String newHtmlPattern) {
+		String oldHtmlPattern = htmlPattern;
+		htmlPattern = newHtmlPattern;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__HTML_PATTERN, oldHtmlPattern, htmlPattern));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNumberFormat()
+	 *         <em>Number Format</em>}' attribute
+	 * @generated
+	 */
+	public String getNumberFormat() {
+		return numberFormat;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNumberFormat
+	 *            the new cached value of the '{@link #getNumberFormat()
+	 *            <em>Number Format</em>}' attribute
+	 * @generated
+	 */
+	public void setNumberFormat(String newNumberFormat) {
+		String oldNumberFormat = numberFormat;
+		numberFormat = newNumberFormat;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT, oldNumberFormat, numberFormat));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH:
+				return getValuePropertyPath();
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH:
+				return getUomPropertyPath();
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION:
+				return getNullRepresentation();
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__HTML_PATTERN:
+				return getHtmlPattern();
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT:
+				return getNumberFormat();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH:
+				setValuePropertyPath((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH:
+				setUomPropertyPath((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__HTML_PATTERN:
+				setHtmlPattern((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT:
+				setNumberFormat((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH:
+				setValuePropertyPath(VALUE_PROPERTY_PATH_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH:
+				setUomPropertyPath(UOM_PROPERTY_PATH_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation(NULL_REPRESENTATION_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__HTML_PATTERN:
+				setHtmlPattern(HTML_PATTERN_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT:
+				setNumberFormat(NUMBER_FORMAT_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH:
+				return VALUE_PROPERTY_PATH_EDEFAULT == null ? valuePropertyPath != null : !VALUE_PROPERTY_PATH_EDEFAULT.equals(valuePropertyPath);
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH:
+				return UOM_PROPERTY_PATH_EDEFAULT == null ? uomPropertyPath != null : !UOM_PROPERTY_PATH_EDEFAULT.equals(uomPropertyPath);
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION:
+				return NULL_REPRESENTATION_EDEFAULT == null ? nullRepresentation != null : !NULL_REPRESENTATION_EDEFAULT.equals(nullRepresentation);
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__HTML_PATTERN:
+				return HTML_PATTERN_EDEFAULT == null ? htmlPattern != null : !HTML_PATTERN_EDEFAULT.equals(htmlPattern);
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT:
+				return NUMBER_FORMAT_EDEFAULT == null ? numberFormat != null : !NUMBER_FORMAT_EDEFAULT.equals(numberFormat);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (valuePropertyPath: ");
+		result.append(valuePropertyPath);
+		result.append(", uomPropertyPath: ");
+		result.append(uomPropertyPath);
+		result.append(", nullRepresentation: ");
+		result.append(nullRepresentation);
+		result.append(", htmlPattern: ");
+		result.append(htmlPattern);
+		result.append(", numberFormat: ");
+		result.append(numberFormat);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererClickEventImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererClickEventImpl.java
new file mode 100644
index 0000000..15fbcec
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererClickEventImpl.java
@@ -0,0 +1,267 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Click Event</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererClickEventImpl#getRenderer <em>Renderer</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererClickEventImpl#getLastClickTime <em>Last Click Time</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridRendererClickEventImpl extends MinimalEObjectImpl.Container implements CxGridRendererClickEvent {
+	
+	/**
+	 * The cached value of the '{@link #getRenderer() <em>Renderer</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getRenderer()
+	 * @generated
+	 * @ordered
+	 */
+	protected CxGridRenderer renderer;
+
+	/**
+	 * The default value of the '{@link #getLastClickTime() <em>Last Click Time</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLastClickTime()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final long LAST_CLICK_TIME_EDEFAULT = 0L;
+
+	/**
+	 * The cached value of the '{@link #getLastClickTime() <em>Last Click Time</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLastClickTime()
+	 * @generated
+	 * @ordered
+	 */
+	protected long lastClickTime = LAST_CLICK_TIME_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridRendererClickEventImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_RENDERER_CLICK_EVENT;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getRenderer() <em>Renderer</em>}
+	 *         ' reference
+	 * @generated
+	 */
+	public CxGridRenderer getRenderer() {
+		if (renderer != null && renderer.eIsProxy()) {
+			InternalEObject oldRenderer = (InternalEObject)renderer;
+			renderer = (CxGridRenderer)eResolveProxy(oldRenderer);
+			if (renderer != oldRenderer) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__RENDERER, oldRenderer, renderer));
+			}
+		}
+		return renderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer
+	 * @generated
+	 */
+	public CxGridRenderer basicGetRenderer() {
+		return renderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newRenderer
+	 *            the new cached value of the '{@link #getRenderer()
+	 *            <em>Renderer</em>}' reference
+	 * @generated
+	 */
+	public void setRenderer(CxGridRenderer newRenderer) {
+		CxGridRenderer oldRenderer = renderer;
+		renderer = newRenderer;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__RENDERER, oldRenderer, renderer));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLastClickTime()
+	 *         <em>Last Click Time</em>}' attribute
+	 * @generated
+	 */
+	public long getLastClickTime() {
+		return lastClickTime;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLastClickTime
+	 *            the new cached value of the '{@link #getLastClickTime()
+	 *            <em>Last Click Time</em>}' attribute
+	 * @generated
+	 */
+	public void setLastClickTime(long newLastClickTime) {
+		long oldLastClickTime = lastClickTime;
+		lastClickTime = newLastClickTime;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME, oldLastClickTime, lastClickTime));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__RENDERER:
+				if (resolve) return getRenderer();
+				return basicGetRenderer();
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME:
+				return getLastClickTime();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__RENDERER:
+				setRenderer((CxGridRenderer)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME:
+				setLastClickTime((Long)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__RENDERER:
+				setRenderer((CxGridRenderer)null);
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME:
+				setLastClickTime(LAST_CLICK_TIME_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__RENDERER:
+				return renderer != null;
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME:
+				return lastClickTime != LAST_CLICK_TIME_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (lastClickTime: ");
+		result.append(lastClickTime);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererFactoryImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererFactoryImpl.java
new file mode 100644
index 0000000..6e4c4b5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererFactoryImpl.java
@@ -0,0 +1,258 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.*;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridRendererFactoryImpl extends EFactoryImpl implements CxGridRendererFactory {
+	
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	public static CxGridRendererFactory init() {
+		try {
+			CxGridRendererFactory theCxGridRendererFactory = (CxGridRendererFactory)EPackage.Registry.INSTANCE.getEFactory(CxGridRendererPackage.eNS_URI);
+			if (theCxGridRendererFactory != null) {
+				return theCxGridRendererFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new CxGridRendererFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridRendererFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param eClass
+	 *            the e class
+	 * @return the e object
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER: return createCxGridDelegateRenderer();
+			case CxGridRendererPackage.CX_GRID_DATE_RENDERER: return createCxGridDateRenderer();
+			case CxGridRendererPackage.CX_GRID_HTML_RENDERER: return createCxGridHtmlRenderer();
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER: return createCxGridNumberRenderer();
+			case CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER: return createCxGridProgressBarRenderer();
+			case CxGridRendererPackage.CX_GRID_TEXT_RENDERER: return createCxGridTextRenderer();
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER: return createCxGridButtonRenderer();
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER: return createCxGridImageRenderer();
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT: return createCxGridRendererClickEvent();
+			case CxGridRendererPackage.CX_GRID_BOOLEAN_RENDERER: return createCxGridBooleanRenderer();
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER: return createCxGridQuantityRenderer();
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER: return createCxGridPriceRenderer();
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER: return createCxGridIndicatorRenderer();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid delegate renderer
+	 * @generated
+	 */
+	public CxGridDelegateRenderer createCxGridDelegateRenderer() {
+		CxGridDelegateRendererImpl cxGridDelegateRenderer = new CxGridDelegateRendererImpl();
+		return cxGridDelegateRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid date renderer
+	 * @generated
+	 */
+	public CxGridDateRenderer createCxGridDateRenderer() {
+		CxGridDateRendererImpl cxGridDateRenderer = new CxGridDateRendererImpl();
+		return cxGridDateRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid html renderer
+	 * @generated
+	 */
+	public CxGridHtmlRenderer createCxGridHtmlRenderer() {
+		CxGridHtmlRendererImpl cxGridHtmlRenderer = new CxGridHtmlRendererImpl();
+		return cxGridHtmlRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid number renderer
+	 * @generated
+	 */
+	public CxGridNumberRenderer createCxGridNumberRenderer() {
+		CxGridNumberRendererImpl cxGridNumberRenderer = new CxGridNumberRendererImpl();
+		return cxGridNumberRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid progress bar renderer
+	 * @generated
+	 */
+	public CxGridProgressBarRenderer createCxGridProgressBarRenderer() {
+		CxGridProgressBarRendererImpl cxGridProgressBarRenderer = new CxGridProgressBarRendererImpl();
+		return cxGridProgressBarRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid text renderer
+	 * @generated
+	 */
+	public CxGridTextRenderer createCxGridTextRenderer() {
+		CxGridTextRendererImpl cxGridTextRenderer = new CxGridTextRendererImpl();
+		return cxGridTextRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid button renderer
+	 * @generated
+	 */
+	public CxGridButtonRenderer createCxGridButtonRenderer() {
+		CxGridButtonRendererImpl cxGridButtonRenderer = new CxGridButtonRendererImpl();
+		return cxGridButtonRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid image renderer
+	 * @generated
+	 */
+	public CxGridImageRenderer createCxGridImageRenderer() {
+		CxGridImageRendererImpl cxGridImageRenderer = new CxGridImageRendererImpl();
+		return cxGridImageRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer click event
+	 * @generated
+	 */
+	public CxGridRendererClickEvent createCxGridRendererClickEvent() {
+		CxGridRendererClickEventImpl cxGridRendererClickEvent = new CxGridRendererClickEventImpl();
+		return cxGridRendererClickEvent;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid boolean renderer
+	 * @generated
+	 */
+	public CxGridBooleanRenderer createCxGridBooleanRenderer() {
+		CxGridBooleanRendererImpl cxGridBooleanRenderer = new CxGridBooleanRendererImpl();
+		return cxGridBooleanRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid quantity renderer
+	 * @generated
+	 */
+	public CxGridQuantityRenderer createCxGridQuantityRenderer() {
+		CxGridQuantityRendererImpl cxGridQuantityRenderer = new CxGridQuantityRendererImpl();
+		return cxGridQuantityRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid price renderer
+	 * @generated
+	 */
+	public CxGridPriceRenderer createCxGridPriceRenderer() {
+		CxGridPriceRendererImpl cxGridPriceRenderer = new CxGridPriceRendererImpl();
+		return cxGridPriceRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid indicator renderer
+	 * @generated
+	 */
+	public CxGridIndicatorRenderer createCxGridIndicatorRenderer() {
+		CxGridIndicatorRendererImpl cxGridIndicatorRenderer = new CxGridIndicatorRendererImpl();
+		return cxGridIndicatorRenderer;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer package
+	 * @generated
+	 */
+	public CxGridRendererPackage getCxGridRendererPackage() {
+		return (CxGridRendererPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the package
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static CxGridRendererPackage getPackage() {
+		return CxGridRendererPackage.eINSTANCE;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererImpl.java
new file mode 100644
index 0000000..036a70d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererImpl.java
@@ -0,0 +1,368 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.osbp.ecview.extension.grid.util.CxGridUtil;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>Cx Grid Renderer</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridRendererImpl#getProperties <em>Properties</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public abstract class CxGridRendererImpl extends MinimalEObjectImpl.Container
+		implements CxGridRenderer {
+	
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_RENDERER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_RENDERER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, CxGridRendererPackage.CX_GRID_RENDERER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, CxGridRendererPackage.CX_GRID_RENDERER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER__TAGS:
+				return getTags();
+			case CxGridRendererPackage.CX_GRID_RENDERER__ID:
+				return getId();
+			case CxGridRendererPackage.CX_GRID_RENDERER__NAME:
+				return getName();
+			case CxGridRendererPackage.CX_GRID_RENDERER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER__ID:
+				setId((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER__NAME:
+				setName((String)newValue);
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER__TAGS:
+				getTags().clear();
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case CxGridRendererPackage.CX_GRID_RENDERER__PROPERTIES:
+				getProperties().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case CxGridRendererPackage.CX_GRID_RENDERER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case CxGridRendererPackage.CX_GRID_RENDERER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case CxGridRendererPackage.CX_GRID_RENDERER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider#getGrid()
+	 */
+	@Override
+	public CxGrid getGrid() {
+		return CxGridUtil.getGrid(this);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererPackageImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererPackageImpl.java
new file mode 100644
index 0000000..425b6bd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridRendererPackageImpl.java
@@ -0,0 +1,828 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+import org.eclipse.osbp.ecview.extension.grid.impl.CxGridPackageImpl;
+
+import org.eclipse.osbp.ecview.extension.grid.memento.CxGridMementoPackage;
+import org.eclipse.osbp.ecview.extension.grid.memento.impl.CxGridMementoPackageImpl;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererFactory;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.BindingPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class CxGridRendererPackageImpl extends EPackageImpl implements CxGridRendererPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridDelegateRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridDateRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridHtmlRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridNumberRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridProgressBarRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridTextRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridButtonRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridImageRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridRendererClickEventEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridBooleanRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridQuantityRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridPriceRendererEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass cxGridIndicatorRendererEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private CxGridRendererPackageImpl() {
+		super(eNS_URI, CxGridRendererFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model,
+	 * and for any others upon which it depends.
+	 * 
+	 * <p>
+	 * This method is used to initialize {@link CxGridRendererPackage#eINSTANCE}
+	 * when that field is accessed. Clients should not invoke it directly.
+	 * Instead, they should simply access that field to obtain the package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the cx grid renderer package
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static CxGridRendererPackage init() {
+		if (isInited) return (CxGridRendererPackage)EPackage.Registry.INSTANCE.getEPackage(CxGridRendererPackage.eNS_URI);
+
+		// Obtain or create and register package
+		CxGridRendererPackageImpl theCxGridRendererPackage = (CxGridRendererPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof CxGridRendererPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new CxGridRendererPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		ExtDatatypesPackage.eINSTANCE.eClass();
+		ExtensionModelPackage.eINSTANCE.eClass();
+
+		// Obtain or create and register interdependencies
+		CxGridPackageImpl theCxGridPackage = (CxGridPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(CxGridPackage.eNS_URI) instanceof CxGridPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(CxGridPackage.eNS_URI) : CxGridPackage.eINSTANCE);
+		CxGridMementoPackageImpl theCxGridMementoPackage = (CxGridMementoPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(CxGridMementoPackage.eNS_URI) instanceof CxGridMementoPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(CxGridMementoPackage.eNS_URI) : CxGridMementoPackage.eINSTANCE);
+
+		// Create package meta-data objects
+		theCxGridRendererPackage.createPackageContents();
+		theCxGridPackage.createPackageContents();
+		theCxGridMementoPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theCxGridRendererPackage.initializePackageContents();
+		theCxGridPackage.initializePackageContents();
+		theCxGridMementoPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theCxGridRendererPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(CxGridRendererPackage.eNS_URI, theCxGridRendererPackage);
+		return theCxGridRendererPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer
+	 * @generated
+	 */
+	public EClass getCxGridRenderer() {
+		return cxGridRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid delegate renderer
+	 * @generated
+	 */
+	public EClass getCxGridDelegateRenderer() {
+		return cxGridDelegateRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid delegate renderer_ delegate id
+	 * @generated
+	 */
+	public EAttribute getCxGridDelegateRenderer_DelegateId() {
+		return (EAttribute)cxGridDelegateRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid date renderer
+	 * @generated
+	 */
+	public EClass getCxGridDateRenderer() {
+		return cxGridDateRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid date renderer_ date format
+	 * @generated
+	 */
+	public EAttribute getCxGridDateRenderer_DateFormat() {
+		return (EAttribute)cxGridDateRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid html renderer
+	 * @generated
+	 */
+	public EClass getCxGridHtmlRenderer() {
+		return cxGridHtmlRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid html renderer_ null representation
+	 * @generated
+	 */
+	public EAttribute getCxGridHtmlRenderer_NullRepresentation() {
+		return (EAttribute)cxGridHtmlRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid number renderer
+	 * @generated
+	 */
+	public EClass getCxGridNumberRenderer() {
+		return cxGridNumberRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid number renderer_ number format
+	 * @generated
+	 */
+	public EAttribute getCxGridNumberRenderer_NumberFormat() {
+		return (EAttribute)cxGridNumberRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid number renderer_ null representation
+	 * @generated
+	 */
+	public EAttribute getCxGridNumberRenderer_NullRepresentation() {
+		return (EAttribute)cxGridNumberRendererEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid progress bar renderer
+	 * @generated
+	 */
+	public EClass getCxGridProgressBarRenderer() {
+		return cxGridProgressBarRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid progress bar renderer_ max value
+	 * @generated
+	 */
+	public EAttribute getCxGridProgressBarRenderer_MaxValue() {
+		return (EAttribute)cxGridProgressBarRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid text renderer
+	 * @generated
+	 */
+	public EClass getCxGridTextRenderer() {
+		return cxGridTextRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid text renderer_ null representation
+	 * @generated
+	 */
+	public EAttribute getCxGridTextRenderer_NullRepresentation() {
+		return (EAttribute)cxGridTextRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid button renderer
+	 * @generated
+	 */
+	public EClass getCxGridButtonRenderer() {
+		return cxGridButtonRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid button renderer_ null representation
+	 * @generated
+	 */
+	public EAttribute getCxGridButtonRenderer_NullRepresentation() {
+		return (EAttribute)cxGridButtonRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid button renderer_ last click event
+	 * @generated
+	 */
+	public EReference getCxGridButtonRenderer_LastClickEvent() {
+		return (EReference)cxGridButtonRendererEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid button renderer_ event topic
+	 * @generated
+	 */
+	public EAttribute getCxGridButtonRenderer_EventTopic() {
+		return (EAttribute)cxGridButtonRendererEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid image renderer
+	 * @generated
+	 */
+	public EClass getCxGridImageRenderer() {
+		return cxGridImageRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid image renderer_ last click event
+	 * @generated
+	 */
+	public EReference getCxGridImageRenderer_LastClickEvent() {
+		return (EReference)cxGridImageRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid image renderer_ event topic
+	 * @generated
+	 */
+	public EAttribute getCxGridImageRenderer_EventTopic() {
+		return (EAttribute)cxGridImageRendererEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer click event
+	 * @generated
+	 */
+	public EClass getCxGridRendererClickEvent() {
+		return cxGridRendererClickEventEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer click event_ renderer
+	 * @generated
+	 */
+	public EReference getCxGridRendererClickEvent_Renderer() {
+		return (EReference)cxGridRendererClickEventEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer click event_ last click time
+	 * @generated
+	 */
+	public EAttribute getCxGridRendererClickEvent_LastClickTime() {
+		return (EAttribute)cxGridRendererClickEventEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid boolean renderer
+	 * @generated
+	 */
+	public EClass getCxGridBooleanRenderer() {
+		return cxGridBooleanRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid quantity renderer
+	 * @generated
+	 */
+	public EClass getCxGridQuantityRenderer() {
+		return cxGridQuantityRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid quantity renderer_ value property path
+	 * @generated
+	 */
+	public EAttribute getCxGridQuantityRenderer_ValuePropertyPath() {
+		return (EAttribute)cxGridQuantityRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid quantity renderer_ uom property path
+	 * @generated
+	 */
+	public EAttribute getCxGridQuantityRenderer_UomPropertyPath() {
+		return (EAttribute)cxGridQuantityRendererEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid quantity renderer_ null representation
+	 * @generated
+	 */
+	public EAttribute getCxGridQuantityRenderer_NullRepresentation() {
+		return (EAttribute)cxGridQuantityRendererEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid quantity renderer_ html pattern
+	 * @generated
+	 */
+	public EAttribute getCxGridQuantityRenderer_HtmlPattern() {
+		return (EAttribute)cxGridQuantityRendererEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid quantity renderer_ number format
+	 * @generated
+	 */
+	public EAttribute getCxGridQuantityRenderer_NumberFormat() {
+		return (EAttribute)cxGridQuantityRendererEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid price renderer
+	 * @generated
+	 */
+	public EClass getCxGridPriceRenderer() {
+		return cxGridPriceRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid price renderer_ value property path
+	 * @generated
+	 */
+	public EAttribute getCxGridPriceRenderer_ValuePropertyPath() {
+		return (EAttribute)cxGridPriceRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid price renderer_ currency property path
+	 * @generated
+	 */
+	public EAttribute getCxGridPriceRenderer_CurrencyPropertyPath() {
+		return (EAttribute)cxGridPriceRendererEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid price renderer_ null representation
+	 * @generated
+	 */
+	public EAttribute getCxGridPriceRenderer_NullRepresentation() {
+		return (EAttribute)cxGridPriceRendererEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid price renderer_ html pattern
+	 * @generated
+	 */
+	public EAttribute getCxGridPriceRenderer_HtmlPattern() {
+		return (EAttribute)cxGridPriceRendererEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid price renderer_ number format
+	 * @generated
+	 */
+	public EAttribute getCxGridPriceRenderer_NumberFormat() {
+		return (EAttribute)cxGridPriceRendererEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid indicator renderer
+	 * @generated
+	 */
+	public EClass getCxGridIndicatorRenderer() {
+		return cxGridIndicatorRendererEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid indicator renderer_ red ends
+	 * @generated
+	 */
+	public EAttribute getCxGridIndicatorRenderer_RedEnds() {
+		return (EAttribute)cxGridIndicatorRendererEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid indicator renderer_ green starts
+	 * @generated
+	 */
+	public EAttribute getCxGridIndicatorRenderer_GreenStarts() {
+		return (EAttribute)cxGridIndicatorRendererEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cx grid renderer factory
+	 * @generated
+	 */
+	public CxGridRendererFactory getCxGridRendererFactory() {
+		return (CxGridRendererFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		cxGridRendererEClass = createEClass(CX_GRID_RENDERER);
+
+		cxGridDelegateRendererEClass = createEClass(CX_GRID_DELEGATE_RENDERER);
+		createEAttribute(cxGridDelegateRendererEClass, CX_GRID_DELEGATE_RENDERER__DELEGATE_ID);
+
+		cxGridDateRendererEClass = createEClass(CX_GRID_DATE_RENDERER);
+		createEAttribute(cxGridDateRendererEClass, CX_GRID_DATE_RENDERER__DATE_FORMAT);
+
+		cxGridHtmlRendererEClass = createEClass(CX_GRID_HTML_RENDERER);
+		createEAttribute(cxGridHtmlRendererEClass, CX_GRID_HTML_RENDERER__NULL_REPRESENTATION);
+
+		cxGridNumberRendererEClass = createEClass(CX_GRID_NUMBER_RENDERER);
+		createEAttribute(cxGridNumberRendererEClass, CX_GRID_NUMBER_RENDERER__NUMBER_FORMAT);
+		createEAttribute(cxGridNumberRendererEClass, CX_GRID_NUMBER_RENDERER__NULL_REPRESENTATION);
+
+		cxGridProgressBarRendererEClass = createEClass(CX_GRID_PROGRESS_BAR_RENDERER);
+		createEAttribute(cxGridProgressBarRendererEClass, CX_GRID_PROGRESS_BAR_RENDERER__MAX_VALUE);
+
+		cxGridTextRendererEClass = createEClass(CX_GRID_TEXT_RENDERER);
+		createEAttribute(cxGridTextRendererEClass, CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION);
+
+		cxGridButtonRendererEClass = createEClass(CX_GRID_BUTTON_RENDERER);
+		createEAttribute(cxGridButtonRendererEClass, CX_GRID_BUTTON_RENDERER__NULL_REPRESENTATION);
+		createEReference(cxGridButtonRendererEClass, CX_GRID_BUTTON_RENDERER__LAST_CLICK_EVENT);
+		createEAttribute(cxGridButtonRendererEClass, CX_GRID_BUTTON_RENDERER__EVENT_TOPIC);
+
+		cxGridImageRendererEClass = createEClass(CX_GRID_IMAGE_RENDERER);
+		createEReference(cxGridImageRendererEClass, CX_GRID_IMAGE_RENDERER__LAST_CLICK_EVENT);
+		createEAttribute(cxGridImageRendererEClass, CX_GRID_IMAGE_RENDERER__EVENT_TOPIC);
+
+		cxGridRendererClickEventEClass = createEClass(CX_GRID_RENDERER_CLICK_EVENT);
+		createEReference(cxGridRendererClickEventEClass, CX_GRID_RENDERER_CLICK_EVENT__RENDERER);
+		createEAttribute(cxGridRendererClickEventEClass, CX_GRID_RENDERER_CLICK_EVENT__LAST_CLICK_TIME);
+
+		cxGridBooleanRendererEClass = createEClass(CX_GRID_BOOLEAN_RENDERER);
+
+		cxGridQuantityRendererEClass = createEClass(CX_GRID_QUANTITY_RENDERER);
+		createEAttribute(cxGridQuantityRendererEClass, CX_GRID_QUANTITY_RENDERER__VALUE_PROPERTY_PATH);
+		createEAttribute(cxGridQuantityRendererEClass, CX_GRID_QUANTITY_RENDERER__UOM_PROPERTY_PATH);
+		createEAttribute(cxGridQuantityRendererEClass, CX_GRID_QUANTITY_RENDERER__NULL_REPRESENTATION);
+		createEAttribute(cxGridQuantityRendererEClass, CX_GRID_QUANTITY_RENDERER__HTML_PATTERN);
+		createEAttribute(cxGridQuantityRendererEClass, CX_GRID_QUANTITY_RENDERER__NUMBER_FORMAT);
+
+		cxGridPriceRendererEClass = createEClass(CX_GRID_PRICE_RENDERER);
+		createEAttribute(cxGridPriceRendererEClass, CX_GRID_PRICE_RENDERER__VALUE_PROPERTY_PATH);
+		createEAttribute(cxGridPriceRendererEClass, CX_GRID_PRICE_RENDERER__CURRENCY_PROPERTY_PATH);
+		createEAttribute(cxGridPriceRendererEClass, CX_GRID_PRICE_RENDERER__NULL_REPRESENTATION);
+		createEAttribute(cxGridPriceRendererEClass, CX_GRID_PRICE_RENDERER__HTML_PATTERN);
+		createEAttribute(cxGridPriceRendererEClass, CX_GRID_PRICE_RENDERER__NUMBER_FORMAT);
+
+		cxGridIndicatorRendererEClass = createEClass(CX_GRID_INDICATOR_RENDERER);
+		createEAttribute(cxGridIndicatorRendererEClass, CX_GRID_INDICATOR_RENDERER__RED_ENDS);
+		createEAttribute(cxGridIndicatorRendererEClass, CX_GRID_INDICATOR_RENDERER__GREEN_STARTS);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		CoreModelPackage theCoreModelPackage = (CoreModelPackage)EPackage.Registry.INSTANCE.getEPackage(CoreModelPackage.eNS_URI);
+		CxGridPackage theCxGridPackage = (CxGridPackage)EPackage.Registry.INSTANCE.getEPackage(CxGridPackage.eNS_URI);
+		BindingPackage theBindingPackage = (BindingPackage)EPackage.Registry.INSTANCE.getEPackage(BindingPackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		cxGridRendererEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		cxGridRendererEClass.getESuperTypes().add(theCxGridPackage.getCxGridProvider());
+		cxGridDelegateRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridDateRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridHtmlRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridNumberRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridProgressBarRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridTextRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridButtonRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridImageRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridBooleanRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridQuantityRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridPriceRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+		cxGridIndicatorRendererEClass.getESuperTypes().add(this.getCxGridRenderer());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(cxGridRendererEClass, CxGridRenderer.class, "CxGridRenderer", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridDelegateRendererEClass, CxGridDelegateRenderer.class, "CxGridDelegateRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridDelegateRenderer_DelegateId(), ecorePackage.getEString(), "delegateId", null, 1, 1, CxGridDelegateRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridDateRendererEClass, CxGridDateRenderer.class, "CxGridDateRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridDateRenderer_DateFormat(), ecorePackage.getEString(), "dateFormat", null, 0, 1, CxGridDateRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridHtmlRendererEClass, CxGridHtmlRenderer.class, "CxGridHtmlRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridHtmlRenderer_NullRepresentation(), ecorePackage.getEString(), "nullRepresentation", "", 0, 1, CxGridHtmlRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridNumberRendererEClass, CxGridNumberRenderer.class, "CxGridNumberRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridNumberRenderer_NumberFormat(), ecorePackage.getEString(), "numberFormat", "#,##0.00", 0, 1, CxGridNumberRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridNumberRenderer_NullRepresentation(), ecorePackage.getEString(), "nullRepresentation", "", 0, 1, CxGridNumberRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridProgressBarRendererEClass, CxGridProgressBarRenderer.class, "CxGridProgressBarRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridProgressBarRenderer_MaxValue(), ecorePackage.getEDouble(), "maxValue", "1", 0, 1, CxGridProgressBarRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridTextRendererEClass, CxGridTextRenderer.class, "CxGridTextRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridTextRenderer_NullRepresentation(), ecorePackage.getEString(), "nullRepresentation", "", 0, 1, CxGridTextRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridButtonRendererEClass, CxGridButtonRenderer.class, "CxGridButtonRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridButtonRenderer_NullRepresentation(), ecorePackage.getEString(), "nullRepresentation", "", 0, 1, CxGridButtonRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getCxGridButtonRenderer_LastClickEvent(), this.getCxGridRendererClickEvent(), null, "lastClickEvent", null, 0, 1, CxGridButtonRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridButtonRenderer_EventTopic(), ecorePackage.getEString(), "eventTopic", "", 0, 1, CxGridButtonRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		addEOperation(cxGridButtonRendererEClass, theBindingPackage.getYECViewModelValueBindingEndpoint(), "createLastClickEventEndpoint", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(cxGridImageRendererEClass, CxGridImageRenderer.class, "CxGridImageRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getCxGridImageRenderer_LastClickEvent(), this.getCxGridRendererClickEvent(), null, "lastClickEvent", null, 0, 1, CxGridImageRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridImageRenderer_EventTopic(), ecorePackage.getEString(), "eventTopic", "", 0, 1, CxGridImageRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		addEOperation(cxGridImageRendererEClass, theBindingPackage.getYECViewModelValueBindingEndpoint(), "createLastClickEventEndpoint", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(cxGridRendererClickEventEClass, CxGridRendererClickEvent.class, "CxGridRendererClickEvent", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getCxGridRendererClickEvent_Renderer(), this.getCxGridRenderer(), null, "renderer", null, 1, 1, CxGridRendererClickEvent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridRendererClickEvent_LastClickTime(), ecorePackage.getELong(), "lastClickTime", null, 0, 1, CxGridRendererClickEvent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridBooleanRendererEClass, CxGridBooleanRenderer.class, "CxGridBooleanRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(cxGridQuantityRendererEClass, CxGridQuantityRenderer.class, "CxGridQuantityRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridQuantityRenderer_ValuePropertyPath(), ecorePackage.getEString(), "valuePropertyPath", null, 1, 1, CxGridQuantityRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridQuantityRenderer_UomPropertyPath(), ecorePackage.getEString(), "uomPropertyPath", null, 1, 1, CxGridQuantityRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridQuantityRenderer_NullRepresentation(), ecorePackage.getEString(), "nullRepresentation", "", 0, 1, CxGridQuantityRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridQuantityRenderer_HtmlPattern(), ecorePackage.getEString(), "htmlPattern", "<b>{@value}</b> <i>{@currency}</i>", 1, 1, CxGridQuantityRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridQuantityRenderer_NumberFormat(), ecorePackage.getEString(), "numberFormat", "#,##0.00", 1, 1, CxGridQuantityRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridPriceRendererEClass, CxGridPriceRenderer.class, "CxGridPriceRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridPriceRenderer_ValuePropertyPath(), ecorePackage.getEString(), "valuePropertyPath", null, 1, 1, CxGridPriceRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridPriceRenderer_CurrencyPropertyPath(), ecorePackage.getEString(), "currencyPropertyPath", null, 1, 1, CxGridPriceRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridPriceRenderer_NullRepresentation(), ecorePackage.getEString(), "nullRepresentation", "", 0, 1, CxGridPriceRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridPriceRenderer_HtmlPattern(), ecorePackage.getEString(), "htmlPattern", "<b>{@value}</b> <i>{@currency}</i>", 1, 1, CxGridPriceRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridPriceRenderer_NumberFormat(), ecorePackage.getEString(), "numberFormat", "#,##0.00", 1, 1, CxGridPriceRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(cxGridIndicatorRendererEClass, CxGridIndicatorRenderer.class, "CxGridIndicatorRenderer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCxGridIndicatorRenderer_RedEnds(), ecorePackage.getEDouble(), "redEnds", null, 0, 1, CxGridIndicatorRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getCxGridIndicatorRenderer_GreenStarts(), ecorePackage.getEDouble(), "greenStarts", null, 0, 1, CxGridIndicatorRenderer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridTextRendererImpl.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridTextRendererImpl.java
new file mode 100644
index 0000000..5172118
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/impl/CxGridTextRendererImpl.java
@@ -0,0 +1,193 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.impl;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage;
+import org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Cx Grid Text Renderer</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.grid.renderer.impl.CxGridTextRendererImpl#getNullRepresentation <em>Null Representation</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class CxGridTextRendererImpl extends CxGridRendererImpl implements CxGridTextRenderer {
+	
+	/**
+	 * The default value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NULL_REPRESENTATION_EDEFAULT = "";
+	/**
+	 * The cached value of the '{@link #getNullRepresentation() <em>Null Representation</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNullRepresentation()
+	 * @generated
+	 * @ordered
+	 */
+	protected String nullRepresentation = NULL_REPRESENTATION_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected CxGridTextRendererImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return CxGridRendererPackage.Literals.CX_GRID_TEXT_RENDERER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNullRepresentation()
+	 *         <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public String getNullRepresentation() {
+		return nullRepresentation;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNullRepresentation
+	 *            the new cached value of the '{@link #getNullRepresentation()
+	 *            <em>Null Representation</em>}' attribute
+	 * @generated
+	 */
+	public void setNullRepresentation(String newNullRepresentation) {
+		String oldNullRepresentation = nullRepresentation;
+		nullRepresentation = newNullRepresentation;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, CxGridRendererPackage.CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION, oldNullRepresentation, nullRepresentation));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION:
+				return getNullRepresentation();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION:
+				setNullRepresentation(NULL_REPRESENTATION_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case CxGridRendererPackage.CX_GRID_TEXT_RENDERER__NULL_REPRESENTATION:
+				return NULL_REPRESENTATION_EDEFAULT == null ? nullRepresentation != null : !NULL_REPRESENTATION_EDEFAULT.equals(nullRepresentation);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (nullRepresentation: ");
+		result.append(nullRepresentation);
+		result.append(')');
+		return result.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/util/CxGridRendererAdapterFactory.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/util/CxGridRendererAdapterFactory.java
new file mode 100644
index 0000000..797e5fc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/util/CxGridRendererAdapterFactory.java
@@ -0,0 +1,425 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.util;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridProvider;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.*;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage
+ * @generated
+ */
+public class CxGridRendererAdapterFactory extends AdapterFactoryImpl {
+	
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static CxGridRendererPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridRendererAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = CxGridRendererPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc --> This implementation returns <code>true</code> if
+	 * the object is either the model's package or is an instance object of the
+	 * model. <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridRendererSwitch<Adapter> modelSwitch =
+		new CxGridRendererSwitch<Adapter>() {
+			@Override
+			public Adapter caseCxGridRenderer(CxGridRenderer object) {
+				return createCxGridRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridDelegateRenderer(CxGridDelegateRenderer object) {
+				return createCxGridDelegateRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridDateRenderer(CxGridDateRenderer object) {
+				return createCxGridDateRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridHtmlRenderer(CxGridHtmlRenderer object) {
+				return createCxGridHtmlRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridNumberRenderer(CxGridNumberRenderer object) {
+				return createCxGridNumberRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridProgressBarRenderer(CxGridProgressBarRenderer object) {
+				return createCxGridProgressBarRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridTextRenderer(CxGridTextRenderer object) {
+				return createCxGridTextRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridButtonRenderer(CxGridButtonRenderer object) {
+				return createCxGridButtonRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridImageRenderer(CxGridImageRenderer object) {
+				return createCxGridImageRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridRendererClickEvent(CxGridRendererClickEvent object) {
+				return createCxGridRendererClickEventAdapter();
+			}
+			@Override
+			public Adapter caseCxGridBooleanRenderer(CxGridBooleanRenderer object) {
+				return createCxGridBooleanRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridQuantityRenderer(CxGridQuantityRenderer object) {
+				return createCxGridQuantityRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridPriceRenderer(CxGridPriceRenderer object) {
+				return createCxGridPriceRendererAdapter();
+			}
+			@Override
+			public Adapter caseCxGridIndicatorRenderer(CxGridIndicatorRenderer object) {
+				return createCxGridIndicatorRendererAdapter();
+			}
+			@Override
+			public Adapter caseYTaggable(YTaggable object) {
+				return createYTaggableAdapter();
+			}
+			@Override
+			public Adapter caseYElement(YElement object) {
+				return createYElementAdapter();
+			}
+			@Override
+			public Adapter caseCxGridProvider(CxGridProvider object) {
+				return createCxGridProviderAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer <em>Cx Grid Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer <em>Cx Grid Delegate Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDelegateRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridDelegateRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer <em>Cx Grid Date Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridDateRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridDateRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer <em>Cx Grid Html Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridHtmlRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridHtmlRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer <em>Cx Grid Number Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridNumberRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridNumberRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer <em>Cx Grid Progress Bar Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridProgressBarRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridProgressBarRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer <em>Cx Grid Text Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridTextRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridTextRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer <em>Cx Grid Button Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridButtonRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridButtonRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer <em>Cx Grid Image Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridImageRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridImageRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent <em>Click Event</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererClickEvent
+	 * @generated
+	 */
+	public Adapter createCxGridRendererClickEventAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer <em>Cx Grid Boolean Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridBooleanRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridBooleanRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer <em>Cx Grid Quantity Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridQuantityRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridQuantityRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer <em>Cx Grid Price Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridPriceRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridPriceRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer <em>Cx Grid Indicator Renderer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridIndicatorRenderer
+	 * @generated
+	 */
+	public Adapter createCxGridIndicatorRendererAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YTaggable <em>YTaggable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YTaggable
+	 * @generated
+	 */
+	public Adapter createYTaggableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YElement <em>YElement</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YElement
+	 * @generated
+	 */
+	public Adapter createYElementAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridProvider <em>Provider</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider
+	 * @generated
+	 */
+	public Adapter createCxGridProviderAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/util/CxGridRendererSwitch.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/util/CxGridRendererSwitch.java
new file mode 100644
index 0000000..f1bb3aa
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/renderer/util/CxGridRendererSwitch.java
@@ -0,0 +1,494 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.renderer.util;
+
+import org.eclipse.osbp.ecview.extension.grid.CxGridProvider;
+
+import org.eclipse.osbp.ecview.extension.grid.renderer.*;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+
+/**
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance
+ * hierarchy. It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the
+ * inheritance hierarchy until a non-null result is returned, which is the
+ * result of the switch. <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.renderer.CxGridRendererPackage
+ * @generated
+ */
+public class CxGridRendererSwitch<T> extends Switch<T> {
+	
+	/**
+	 * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected static CxGridRendererPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridRendererSwitch() {
+		if (modelPackage == null) {
+			modelPackage = CxGridRendererPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param ePackage
+	 *            the e package
+	 * @return whether this is a switch for the given package.
+	 * @parameter ePackage the package in question.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case CxGridRendererPackage.CX_GRID_RENDERER: {
+				CxGridRenderer cxGridRenderer = (CxGridRenderer)theEObject;
+				T result = caseCxGridRenderer(cxGridRenderer);
+				if (result == null) result = caseYElement(cxGridRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridRenderer);
+				if (result == null) result = caseYTaggable(cxGridRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_DELEGATE_RENDERER: {
+				CxGridDelegateRenderer cxGridDelegateRenderer = (CxGridDelegateRenderer)theEObject;
+				T result = caseCxGridDelegateRenderer(cxGridDelegateRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridDelegateRenderer);
+				if (result == null) result = caseYElement(cxGridDelegateRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridDelegateRenderer);
+				if (result == null) result = caseYTaggable(cxGridDelegateRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_DATE_RENDERER: {
+				CxGridDateRenderer cxGridDateRenderer = (CxGridDateRenderer)theEObject;
+				T result = caseCxGridDateRenderer(cxGridDateRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridDateRenderer);
+				if (result == null) result = caseYElement(cxGridDateRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridDateRenderer);
+				if (result == null) result = caseYTaggable(cxGridDateRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_HTML_RENDERER: {
+				CxGridHtmlRenderer cxGridHtmlRenderer = (CxGridHtmlRenderer)theEObject;
+				T result = caseCxGridHtmlRenderer(cxGridHtmlRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridHtmlRenderer);
+				if (result == null) result = caseYElement(cxGridHtmlRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridHtmlRenderer);
+				if (result == null) result = caseYTaggable(cxGridHtmlRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_NUMBER_RENDERER: {
+				CxGridNumberRenderer cxGridNumberRenderer = (CxGridNumberRenderer)theEObject;
+				T result = caseCxGridNumberRenderer(cxGridNumberRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridNumberRenderer);
+				if (result == null) result = caseYElement(cxGridNumberRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridNumberRenderer);
+				if (result == null) result = caseYTaggable(cxGridNumberRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_PROGRESS_BAR_RENDERER: {
+				CxGridProgressBarRenderer cxGridProgressBarRenderer = (CxGridProgressBarRenderer)theEObject;
+				T result = caseCxGridProgressBarRenderer(cxGridProgressBarRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridProgressBarRenderer);
+				if (result == null) result = caseYElement(cxGridProgressBarRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridProgressBarRenderer);
+				if (result == null) result = caseYTaggable(cxGridProgressBarRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_TEXT_RENDERER: {
+				CxGridTextRenderer cxGridTextRenderer = (CxGridTextRenderer)theEObject;
+				T result = caseCxGridTextRenderer(cxGridTextRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridTextRenderer);
+				if (result == null) result = caseYElement(cxGridTextRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridTextRenderer);
+				if (result == null) result = caseYTaggable(cxGridTextRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_BUTTON_RENDERER: {
+				CxGridButtonRenderer cxGridButtonRenderer = (CxGridButtonRenderer)theEObject;
+				T result = caseCxGridButtonRenderer(cxGridButtonRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridButtonRenderer);
+				if (result == null) result = caseYElement(cxGridButtonRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridButtonRenderer);
+				if (result == null) result = caseYTaggable(cxGridButtonRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_IMAGE_RENDERER: {
+				CxGridImageRenderer cxGridImageRenderer = (CxGridImageRenderer)theEObject;
+				T result = caseCxGridImageRenderer(cxGridImageRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridImageRenderer);
+				if (result == null) result = caseYElement(cxGridImageRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridImageRenderer);
+				if (result == null) result = caseYTaggable(cxGridImageRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_RENDERER_CLICK_EVENT: {
+				CxGridRendererClickEvent cxGridRendererClickEvent = (CxGridRendererClickEvent)theEObject;
+				T result = caseCxGridRendererClickEvent(cxGridRendererClickEvent);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_BOOLEAN_RENDERER: {
+				CxGridBooleanRenderer cxGridBooleanRenderer = (CxGridBooleanRenderer)theEObject;
+				T result = caseCxGridBooleanRenderer(cxGridBooleanRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridBooleanRenderer);
+				if (result == null) result = caseYElement(cxGridBooleanRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridBooleanRenderer);
+				if (result == null) result = caseYTaggable(cxGridBooleanRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_QUANTITY_RENDERER: {
+				CxGridQuantityRenderer cxGridQuantityRenderer = (CxGridQuantityRenderer)theEObject;
+				T result = caseCxGridQuantityRenderer(cxGridQuantityRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridQuantityRenderer);
+				if (result == null) result = caseYElement(cxGridQuantityRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridQuantityRenderer);
+				if (result == null) result = caseYTaggable(cxGridQuantityRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_PRICE_RENDERER: {
+				CxGridPriceRenderer cxGridPriceRenderer = (CxGridPriceRenderer)theEObject;
+				T result = caseCxGridPriceRenderer(cxGridPriceRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridPriceRenderer);
+				if (result == null) result = caseYElement(cxGridPriceRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridPriceRenderer);
+				if (result == null) result = caseYTaggable(cxGridPriceRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridRendererPackage.CX_GRID_INDICATOR_RENDERER: {
+				CxGridIndicatorRenderer cxGridIndicatorRenderer = (CxGridIndicatorRenderer)theEObject;
+				T result = caseCxGridIndicatorRenderer(cxGridIndicatorRenderer);
+				if (result == null) result = caseCxGridRenderer(cxGridIndicatorRenderer);
+				if (result == null) result = caseYElement(cxGridIndicatorRenderer);
+				if (result == null) result = caseCxGridProvider(cxGridIndicatorRenderer);
+				if (result == null) result = caseYTaggable(cxGridIndicatorRenderer);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridRenderer(CxGridRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Delegate Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Delegate Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridDelegateRenderer(CxGridDelegateRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Date Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Date Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridDateRenderer(CxGridDateRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Html Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Html Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridHtmlRenderer(CxGridHtmlRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Number Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Number Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridNumberRenderer(CxGridNumberRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Progress Bar Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Progress Bar Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridProgressBarRenderer(CxGridProgressBarRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Text Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Text Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridTextRenderer(CxGridTextRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Button Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Button Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridButtonRenderer(CxGridButtonRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Image Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Image Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridImageRenderer(CxGridImageRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Click Event</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Click Event</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridRendererClickEvent(CxGridRendererClickEvent object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Boolean Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Boolean Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridBooleanRenderer(CxGridBooleanRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Quantity Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Quantity Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridQuantityRenderer(CxGridQuantityRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Price Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Price Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridPriceRenderer(CxGridPriceRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid Indicator Renderer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid Indicator Renderer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridIndicatorRenderer(CxGridIndicatorRenderer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTaggable(YTaggable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYElement(YElement object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Provider</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Provider</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridProvider(CxGridProvider object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridAdapterFactory.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridAdapterFactory.java
new file mode 100644
index 0000000..345ceb1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridAdapterFactory.java
@@ -0,0 +1,678 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.util;
+
+import org.eclipse.osbp.ecview.extension.grid.*;
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCssAble;
+import org.eclipse.osbp.ecview.core.common.model.core.YEditable;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEnable;
+import org.eclipse.osbp.ecview.core.common.model.core.YField;
+import org.eclipse.osbp.ecview.core.common.model.core.YFocusable;
+import org.eclipse.osbp.ecview.core.common.model.core.YHelperLayoutProvider;
+import org.eclipse.osbp.ecview.core.common.model.core.YMultiSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.core.common.model.core.YVisibleable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupable;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage
+ * @generated
+ */
+public class CxGridAdapterFactory extends AdapterFactoryImpl {
+	
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static CxGridPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = CxGridPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc --> This implementation returns <code>true</code> if
+	 * the object is either the model's package or is an instance object of the
+	 * model. <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CxGridSwitch<Adapter> modelSwitch =
+		new CxGridSwitch<Adapter>() {
+			@Override
+			public Adapter caseCxGrid(CxGrid object) {
+				return createCxGridAdapter();
+			}
+			@Override
+			public Adapter caseCxGridProvider(CxGridProvider object) {
+				return createCxGridProviderAdapter();
+			}
+			@Override
+			public Adapter caseCxGridMetaRow(CxGridMetaRow object) {
+				return createCxGridMetaRowAdapter();
+			}
+			@Override
+			public Adapter caseCxGridHeaderRow(CxGridHeaderRow object) {
+				return createCxGridHeaderRowAdapter();
+			}
+			@Override
+			public Adapter caseCxGridFooterRow(CxGridFooterRow object) {
+				return createCxGridFooterRowAdapter();
+			}
+			@Override
+			public Adapter caseCxGridFilterRow(CxGridFilterRow object) {
+				return createCxGridFilterRowAdapter();
+			}
+			@Override
+			public Adapter caseCxGridGroupable(CxGridGroupable object) {
+				return createCxGridGroupableAdapter();
+			}
+			@Override
+			public Adapter caseCxGridMetaCell(CxGridMetaCell object) {
+				return createCxGridMetaCellAdapter();
+			}
+			@Override
+			public Adapter caseCxGridGroupedCell(CxGridGroupedCell object) {
+				return createCxGridGroupedCellAdapter();
+			}
+			@Override
+			public Adapter caseCxGridColumn(CxGridColumn object) {
+				return createCxGridColumnAdapter();
+			}
+			@Override
+			public Adapter caseCxGridCellStyleGenerator(CxGridCellStyleGenerator object) {
+				return createCxGridCellStyleGeneratorAdapter();
+			}
+			@Override
+			public Adapter caseCxGridDelegateCellStyleGenerator(CxGridDelegateCellStyleGenerator object) {
+				return createCxGridDelegateCellStyleGeneratorAdapter();
+			}
+			@Override
+			public Adapter caseCxGridSortable(CxGridSortable object) {
+				return createCxGridSortableAdapter();
+			}
+			@Override
+			public Adapter caseYTaggable(YTaggable object) {
+				return createYTaggableAdapter();
+			}
+			@Override
+			public Adapter caseYElement(YElement object) {
+				return createYElementAdapter();
+			}
+			@Override
+			public Adapter caseYCssAble(YCssAble object) {
+				return createYCssAbleAdapter();
+			}
+			@Override
+			public Adapter caseYVisibleable(YVisibleable object) {
+				return createYVisibleableAdapter();
+			}
+			@Override
+			public Adapter caseYAuthorizationable(YAuthorizationable object) {
+				return createYAuthorizationableAdapter();
+			}
+			@Override
+			public Adapter caseYEmbeddable(YEmbeddable object) {
+				return createYEmbeddableAdapter();
+			}
+			@Override
+			public Adapter caseYEditable(YEditable object) {
+				return createYEditableAdapter();
+			}
+			@Override
+			public Adapter caseYEnable(YEnable object) {
+				return createYEnableAdapter();
+			}
+			@Override
+			public Adapter caseYFocusable(YFocusable object) {
+				return createYFocusableAdapter();
+			}
+			@Override
+			public Adapter caseYField(YField object) {
+				return createYFieldAdapter();
+			}
+			@Override
+			public Adapter caseYInput(YInput object) {
+				return createYInputAdapter();
+			}
+			@Override
+			public Adapter caseYBindable(YBindable object) {
+				return createYBindableAdapter();
+			}
+			@Override
+			public Adapter caseYCollectionBindable(YCollectionBindable object) {
+				return createYCollectionBindableAdapter();
+			}
+			@Override
+			public Adapter caseYSelectionBindable(YSelectionBindable object) {
+				return createYSelectionBindableAdapter();
+			}
+			@Override
+			public Adapter caseYMultiSelectionBindable(YMultiSelectionBindable object) {
+				return createYMultiSelectionBindableAdapter();
+			}
+			@Override
+			public Adapter caseYBeanServiceConsumer(YBeanServiceConsumer object) {
+				return createYBeanServiceConsumerAdapter();
+			}
+			@Override
+			public Adapter caseYHelperLayoutProvider(YHelperLayoutProvider object) {
+				return createYHelperLayoutProviderAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGrid <em>Cx Grid</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGrid
+	 * @generated
+	 */
+	public Adapter createCxGridAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridProvider <em>Provider</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridProvider
+	 * @generated
+	 */
+	public Adapter createCxGridProviderAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow <em>Meta Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow
+	 * @generated
+	 */
+	public Adapter createCxGridMetaRowAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow <em>Header Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow
+	 * @generated
+	 */
+	public Adapter createCxGridHeaderRowAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow <em>Footer Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow
+	 * @generated
+	 */
+	public Adapter createCxGridFooterRowAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow <em>Filter Row</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridFilterRow
+	 * @generated
+	 */
+	public Adapter createCxGridFilterRowAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupable <em>Groupable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupable
+	 * @generated
+	 */
+	public Adapter createCxGridGroupableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell <em>Meta Cell</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridMetaCell
+	 * @generated
+	 */
+	public Adapter createCxGridMetaCellAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell <em>Grouped Cell</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell
+	 * @generated
+	 */
+	public Adapter createCxGridGroupedCellAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridColumn <em>Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridColumn
+	 * @generated
+	 */
+	public Adapter createCxGridColumnAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator <em>Cell Style Generator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator
+	 * @generated
+	 */
+	public Adapter createCxGridCellStyleGeneratorAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator <em>Delegate Cell Style Generator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator
+	 * @generated
+	 */
+	public Adapter createCxGridDelegateCellStyleGeneratorAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.grid.CxGridSortable <em>Sortable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.grid.CxGridSortable
+	 * @generated
+	 */
+	public Adapter createCxGridSortableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YTaggable <em>YTaggable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YTaggable
+	 * @generated
+	 */
+	public Adapter createYTaggableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YElement <em>YElement</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YElement
+	 * @generated
+	 */
+	public Adapter createYElementAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YCssAble <em>YCss Able</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCssAble
+	 * @generated
+	 */
+	public Adapter createYCssAbleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YVisibleable <em>YVisibleable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YVisibleable
+	 * @generated
+	 */
+	public Adapter createYVisibleableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable <em>YAuthorizationable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable
+	 * @generated
+	 */
+	public Adapter createYAuthorizationableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable <em>YEmbeddable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable
+	 * @generated
+	 */
+	public Adapter createYEmbeddableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YEditable <em>YEditable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YEditable
+	 * @generated
+	 */
+	public Adapter createYEditableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YEnable <em>YEnable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YEnable
+	 * @generated
+	 */
+	public Adapter createYEnableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YFocusable <em>YFocusable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YFocusable
+	 * @generated
+	 */
+	public Adapter createYFocusableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YField <em>YField</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YField
+	 * @generated
+	 */
+	public Adapter createYFieldAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.extension.model.extension.YInput <em>YInput</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.YInput
+	 * @generated
+	 */
+	public Adapter createYInputAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YBindable <em>YBindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YBindable
+	 * @generated
+	 */
+	public Adapter createYBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable <em>YCollection Bindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable
+	 * @generated
+	 */
+	public Adapter createYCollectionBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable <em>YSelection Bindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable
+	 * @generated
+	 */
+	public Adapter createYSelectionBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YMultiSelectionBindable <em>YMulti Selection Bindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YMultiSelectionBindable
+	 * @generated
+	 */
+	public Adapter createYMultiSelectionBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer <em>YBean Service Consumer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer
+	 * @generated
+	 */
+	public Adapter createYBeanServiceConsumerAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YHelperLayoutProvider <em>YHelper Layout Provider</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YHelperLayoutProvider
+	 * @generated
+	 */
+	public Adapter createYHelperLayoutProviderAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridSwitch.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridSwitch.java
new file mode 100644
index 0000000..3c2081a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridSwitch.java
@@ -0,0 +1,707 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.util;
+
+import org.eclipse.osbp.ecview.extension.grid.*;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCssAble;
+import org.eclipse.osbp.ecview.core.common.model.core.YEditable;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEnable;
+import org.eclipse.osbp.ecview.core.common.model.core.YField;
+import org.eclipse.osbp.ecview.core.common.model.core.YFocusable;
+import org.eclipse.osbp.ecview.core.common.model.core.YHelperLayoutProvider;
+import org.eclipse.osbp.ecview.core.common.model.core.YMultiSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.core.common.model.core.YVisibleable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ecview.extension.grid.CxGridDelegateCellStyleGenerator;
+import org.eclipse.osbp.ecview.extension.grid.CxGridFooterRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupable;
+import org.eclipse.osbp.ecview.extension.grid.CxGridGroupedCell;
+import org.eclipse.osbp.ecview.extension.grid.CxGridHeaderRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridMetaRow;
+import org.eclipse.osbp.ecview.extension.grid.CxGridPackage;
+
+/**
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance
+ * hierarchy. It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the
+ * inheritance hierarchy until a non-null result is returned, which is the
+ * result of the switch. <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.grid.CxGridPackage
+ * @generated
+ */
+public class CxGridSwitch<T> extends Switch<T> {
+	
+	/**
+	 * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected static CxGridPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public CxGridSwitch() {
+		if (modelPackage == null) {
+			modelPackage = CxGridPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param ePackage
+	 *            the e package
+	 * @return whether this is a switch for the given package.
+	 * @parameter ePackage the package in question.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case CxGridPackage.CX_GRID: {
+				CxGrid cxGrid = (CxGrid)theEObject;
+				T result = caseCxGrid(cxGrid);
+				if (result == null) result = caseYInput(cxGrid);
+				if (result == null) result = caseYCollectionBindable(cxGrid);
+				if (result == null) result = caseYSelectionBindable(cxGrid);
+				if (result == null) result = caseYMultiSelectionBindable(cxGrid);
+				if (result == null) result = caseYBeanServiceConsumer(cxGrid);
+				if (result == null) result = caseYField(cxGrid);
+				if (result == null) result = caseYBindable(cxGrid);
+				if (result == null) result = caseYEmbeddable(cxGrid);
+				if (result == null) result = caseYEditable(cxGrid);
+				if (result == null) result = caseYEnable(cxGrid);
+				if (result == null) result = caseYFocusable(cxGrid);
+				if (result == null) result = caseYElement(cxGrid);
+				if (result == null) result = caseYCssAble(cxGrid);
+				if (result == null) result = caseYVisibleable(cxGrid);
+				if (result == null) result = caseYAuthorizationable(cxGrid);
+				if (result == null) result = caseYTaggable(cxGrid);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_PROVIDER: {
+				CxGridProvider cxGridProvider = (CxGridProvider)theEObject;
+				T result = caseCxGridProvider(cxGridProvider);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_META_ROW: {
+				CxGridMetaRow cxGridMetaRow = (CxGridMetaRow)theEObject;
+				T result = caseCxGridMetaRow(cxGridMetaRow);
+				if (result == null) result = caseYElement(cxGridMetaRow);
+				if (result == null) result = caseCxGridProvider(cxGridMetaRow);
+				if (result == null) result = caseYTaggable(cxGridMetaRow);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_HEADER_ROW: {
+				CxGridHeaderRow cxGridHeaderRow = (CxGridHeaderRow)theEObject;
+				T result = caseCxGridHeaderRow(cxGridHeaderRow);
+				if (result == null) result = caseCxGridMetaRow(cxGridHeaderRow);
+				if (result == null) result = caseYElement(cxGridHeaderRow);
+				if (result == null) result = caseCxGridProvider(cxGridHeaderRow);
+				if (result == null) result = caseYTaggable(cxGridHeaderRow);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_FOOTER_ROW: {
+				CxGridFooterRow cxGridFooterRow = (CxGridFooterRow)theEObject;
+				T result = caseCxGridFooterRow(cxGridFooterRow);
+				if (result == null) result = caseCxGridMetaRow(cxGridFooterRow);
+				if (result == null) result = caseYElement(cxGridFooterRow);
+				if (result == null) result = caseCxGridProvider(cxGridFooterRow);
+				if (result == null) result = caseYTaggable(cxGridFooterRow);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_FILTER_ROW: {
+				CxGridFilterRow cxGridFilterRow = (CxGridFilterRow)theEObject;
+				T result = caseCxGridFilterRow(cxGridFilterRow);
+				if (result == null) result = caseCxGridMetaRow(cxGridFilterRow);
+				if (result == null) result = caseYElement(cxGridFilterRow);
+				if (result == null) result = caseCxGridProvider(cxGridFilterRow);
+				if (result == null) result = caseYTaggable(cxGridFilterRow);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_GROUPABLE: {
+				CxGridGroupable cxGridGroupable = (CxGridGroupable)theEObject;
+				T result = caseCxGridGroupable(cxGridGroupable);
+				if (result == null) result = caseYElement(cxGridGroupable);
+				if (result == null) result = caseCxGridProvider(cxGridGroupable);
+				if (result == null) result = caseYTaggable(cxGridGroupable);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_META_CELL: {
+				CxGridMetaCell cxGridMetaCell = (CxGridMetaCell)theEObject;
+				T result = caseCxGridMetaCell(cxGridMetaCell);
+				if (result == null) result = caseYElement(cxGridMetaCell);
+				if (result == null) result = caseCxGridProvider(cxGridMetaCell);
+				if (result == null) result = caseYTaggable(cxGridMetaCell);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_GROUPED_CELL: {
+				CxGridGroupedCell cxGridGroupedCell = (CxGridGroupedCell)theEObject;
+				T result = caseCxGridGroupedCell(cxGridGroupedCell);
+				if (result == null) result = caseCxGridGroupable(cxGridGroupedCell);
+				if (result == null) result = caseYElement(cxGridGroupedCell);
+				if (result == null) result = caseCxGridProvider(cxGridGroupedCell);
+				if (result == null) result = caseYTaggable(cxGridGroupedCell);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_COLUMN: {
+				CxGridColumn cxGridColumn = (CxGridColumn)theEObject;
+				T result = caseCxGridColumn(cxGridColumn);
+				if (result == null) result = caseCxGridGroupable(cxGridColumn);
+				if (result == null) result = caseYHelperLayoutProvider(cxGridColumn);
+				if (result == null) result = caseYElement(cxGridColumn);
+				if (result == null) result = caseCxGridProvider(cxGridColumn);
+				if (result == null) result = caseYTaggable(cxGridColumn);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_CELL_STYLE_GENERATOR: {
+				CxGridCellStyleGenerator cxGridCellStyleGenerator = (CxGridCellStyleGenerator)theEObject;
+				T result = caseCxGridCellStyleGenerator(cxGridCellStyleGenerator);
+				if (result == null) result = caseYElement(cxGridCellStyleGenerator);
+				if (result == null) result = caseCxGridProvider(cxGridCellStyleGenerator);
+				if (result == null) result = caseYTaggable(cxGridCellStyleGenerator);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_DELEGATE_CELL_STYLE_GENERATOR: {
+				CxGridDelegateCellStyleGenerator cxGridDelegateCellStyleGenerator = (CxGridDelegateCellStyleGenerator)theEObject;
+				T result = caseCxGridDelegateCellStyleGenerator(cxGridDelegateCellStyleGenerator);
+				if (result == null) result = caseCxGridCellStyleGenerator(cxGridDelegateCellStyleGenerator);
+				if (result == null) result = caseYElement(cxGridDelegateCellStyleGenerator);
+				if (result == null) result = caseCxGridProvider(cxGridDelegateCellStyleGenerator);
+				if (result == null) result = caseYTaggable(cxGridDelegateCellStyleGenerator);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case CxGridPackage.CX_GRID_SORTABLE: {
+				CxGridSortable cxGridSortable = (CxGridSortable)theEObject;
+				T result = caseCxGridSortable(cxGridSortable);
+				if (result == null) result = caseYElement(cxGridSortable);
+				if (result == null) result = caseYTaggable(cxGridSortable);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cx Grid</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cx Grid</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGrid(CxGrid object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Provider</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Provider</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridProvider(CxGridProvider object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Meta Row</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Meta Row</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridMetaRow(CxGridMetaRow object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Header Row</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Header Row</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridHeaderRow(CxGridHeaderRow object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Footer Row</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Footer Row</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridFooterRow(CxGridFooterRow object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Filter Row</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Filter Row</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridFilterRow(CxGridFilterRow object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Groupable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Groupable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridGroupable(CxGridGroupable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Meta Cell</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Meta Cell</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridMetaCell(CxGridMetaCell object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Grouped Cell</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Grouped Cell</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridGroupedCell(CxGridGroupedCell object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Column</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Column</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridColumn(CxGridColumn object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Cell Style Generator</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Cell Style Generator</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridCellStyleGenerator(CxGridCellStyleGenerator object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Delegate Cell Style Generator</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Delegate Cell Style Generator</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridDelegateCellStyleGenerator(CxGridDelegateCellStyleGenerator object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Sortable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Sortable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCxGridSortable(CxGridSortable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTaggable(YTaggable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYElement(YElement object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YCss Able</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YCss Able</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYCssAble(YCssAble object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YVisibleable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YVisibleable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYVisibleable(YVisibleable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YAuthorizationable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YAuthorizationable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYAuthorizationable(YAuthorizationable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YEmbeddable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YEmbeddable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYEmbeddable(YEmbeddable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YEditable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YEditable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYEditable(YEditable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YEnable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YEnable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYEnable(YEnable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YFocusable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YFocusable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYFocusable(YFocusable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YField</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YField</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYField(YField object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YInput</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YInput</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYInput(YInput object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YBindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YBindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYBindable(YBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YCollection Bindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YCollection Bindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYCollectionBindable(YCollectionBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSelection Bindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSelection Bindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSelectionBindable(YSelectionBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YMulti Selection Bindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YMulti Selection Bindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYMultiSelectionBindable(YMultiSelectionBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YBean Service Consumer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YBean Service Consumer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYBeanServiceConsumer(YBeanServiceConsumer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YHelper Layout Provider</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YHelper Layout Provider</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYHelperLayoutProvider(YHelperLayoutProvider object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridUtil.java b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridUtil.java
new file mode 100644
index 0000000..6d614c0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.grid.model/src/org/eclipse/osbp/ecview/extension/grid/util/CxGridUtil.java
@@ -0,0 +1,92 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.grid.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.extension.grid.CxGrid;
+import org.eclipse.osbp.ecview.extension.grid.CxGridColumn;
+import org.eclipse.osbp.ui.api.useraccess.AbstractAuthorization.Action;
+import org.eclipse.osbp.ui.api.useraccess.AbstractAuthorization.Permission;
+import org.eclipse.osbp.ui.api.useraccess.IUserAccessService;
+
+/**
+ * The Class CxGridUtil.
+ */
+public class CxGridUtil {
+
+	/**
+	 * Returns the grid.
+	 *
+	 * @param eObject
+	 *            the e object
+	 * @return the grid
+	 */
+	public static CxGrid getGrid(EObject eObject) {
+		if (eObject == null) {
+			return null;
+		}
+
+		if (eObject instanceof CxGrid) {
+			return (CxGrid) eObject;
+		} else {
+			return getGrid(eObject.eContainer());
+		}
+	}
+	
+	
+	/**
+	 * Modifies the columns of the grid due to the existing user permissions
+	 *  
+	 * @param userAccessService
+	 * @param grid
+	 * @return
+	 */
+	public static CxGrid setPermissions(IUserAccessService userAccessService, CxGrid grid) {
+		if (userAccessService == null) {
+			grid.setVisible(true);
+		} else {
+			String dtoName = grid.getTypeQualifiedName();
+			for (CxGridColumn column : grid.getColumns()) {
+//				String dtoProperty = column.getName();
+				String dtoProperty = column.getPropertyId();
+				if (userAccessService.isPermitted(
+						Permission.forDto(dtoName, Action.readable))
+						.isPermitted()) {
+					column.setHidden(false);
+					column.setEditable(true);
+					boolean columnHidden = userAccessService.isPermitted(
+							Permission.forDtoProperty(dtoName, dtoProperty,
+									Action.invisible)).isPermitted();
+					if (!columnHidden) {
+						boolean columnEditable = !userAccessService
+								.isPermitted(
+										Permission
+												.forDtoProperty(dtoName,
+														dtoProperty,
+														Action.noneditable))
+								.isPermitted();
+						boolean columnEnabled = !userAccessService.isPermitted(
+								Permission.forDtoProperty(dtoName, dtoProperty,
+										Action.disabled)).isPermitted();
+						column.setEditable(columnEditable && columnEnabled);
+					} else {
+						column.setHidden(columnHidden);
+					}
+				}
+			}
+		}
+		return grid;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/.project b/org.eclipse.osbp.ecview.extension.model.edit/.project
new file mode 100644
index 0000000..0a3c9a1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/.project
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.model.edit</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/LICENSE.txt b/org.eclipse.osbp.ecview.extension.model.edit/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/META-INF/MANIFEST.MF b/org.eclipse.osbp.ecview.extension.model.edit/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..73637e0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/META-INF/MANIFEST.MF
@@ -0,0 +1,24 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.ecview.extension.model.edit
+Bundle-SymbolicName: org.eclipse.osbp.ecview.extension.model.edit;singleton:=true
+Bundle-Version: 0.9.0.qualifier
+Bundle-ClassPath: .
+Bundle-Activator: org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin$Implementation
+Bundle-Vendor: Eclipse OSBP
+ Germany)
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Export-Package: org.eclipse.osbp.ecview.extension.model.converter.provider;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.model.provider;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.model.visibility.provider;version="0.9.0"
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.osbp.ecview.extension.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.emf.edit;visibility:=reexport,
+ org.eclipse.osbp.ecview.core.common.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.common.model.edit;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.extension.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.extension.model.edit;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.xtext.common.types;bundle-version="[2.7.3,2.8.0)";visibility:=reexport,
+ org.eclipse.xtext.common.types.edit;bundle-version="[2.7.3,2.8.0)";visibility:=reexport
+Bundle-ActivationPolicy: lazy
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/about.html b/org.eclipse.osbp.ecview.extension.model.edit/about.html
new file mode 100644
index 0000000..64c0598
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/about.html
@@ -0,0 +1,28 @@
+<!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>June 1, 2016</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &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>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/about.ini b/org.eclipse.osbp.ecview.extension.model.edit/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/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.ecview.extension.model.edit/about.mappings b/org.eclipse.osbp.ecview.extension.model.edit/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/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.ecview.extension.model.edit/about.properties b/org.eclipse.osbp.ecview.extension.model.edit/about.properties
new file mode 100644
index 0000000..31bce70
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/about.properties
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.ecview.extension.model.edit
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - implementation\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/build.properties b/org.eclipse.osbp.ecview.extension.model.edit/build.properties
new file mode 100644
index 0000000..100da73
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/build.properties
@@ -0,0 +1,17 @@
+# All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+# 
+# Contributors:
+#       Florian Pirchner - initial API and implementation
+
+bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  .,\
+               icons/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               LICENSE.txt,\
+               license.html
+jars.compile.order = .
+source.. = src/
+output.. = bin/
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
+               LICENSE.txt
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/epl-v10.html b/org.eclipse.osbp.ecview.extension.model.edit/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYAuthorizationVisibilityProcessor_details_YAuthVPDetail.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYAuthorizationVisibilityProcessor_details_YAuthVPDetail.gif
new file mode 100644
index 0000000..9bacb28
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYAuthorizationVisibilityProcessor_details_YAuthVPDetail.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYCollectionSuspect_columns_YColumnInfo.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYCollectionSuspect_columns_YColumnInfo.gif
new file mode 100644
index 0000000..40e5eed
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYCollectionSuspect_columns_YColumnInfo.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYColumnInfo_properties_YStringToStringMap.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYColumnInfo_properties_YStringToStringMap.gif
new file mode 100644
index 0000000..e2bf8c1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYColumnInfo_properties_YStringToStringMap.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YBlobUploadComponent.gif
new file mode 100644
index 0000000..68ad5bd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YContentSensitiveLayout.gif
new file mode 100644
index 0000000..efc256e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YCustomDecimalField.gif
new file mode 100644
index 0000000..55d7be5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YIconComboBox.gif
new file mode 100644
index 0000000..2e9fe7e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedDecimalField.gif
new file mode 100644
index 0000000..efc256e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedNumericField.gif
new file mode 100644
index 0000000..73b29f9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedTextField.gif
new file mode 100644
index 0000000..5e6c9c1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YPairComboBox.gif
new file mode 100644
index 0000000..40ef08b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..2b447c2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YQuantityTextField.gif
new file mode 100644
index 0000000..8e6a767
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YRichTextArea.gif
new file mode 100644
index 0000000..981b787
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YStrategyLayout.gif
new file mode 100644
index 0000000..8e6a767
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYDialog_content_YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYFocusingStrategy_keyStrokeDefinition_YKeyStrokeDefinition.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYFocusingStrategy_keyStrokeDefinition_YKeyStrokeDefinition.gif
new file mode 100644
index 0000000..26e5b3f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYFocusingStrategy_keyStrokeDefinition_YKeyStrokeDefinition.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYFocusingStrategy_tempStrokeDefinition_YKeyStrokeDefinition.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYFocusingStrategy_tempStrokeDefinition_YKeyStrokeDefinition.gif
new file mode 100644
index 0000000..26e5b3f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYFocusingStrategy_tempStrokeDefinition_YKeyStrokeDefinition.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YBlobUploadComponent.gif
new file mode 100644
index 0000000..6fa04d1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YContentSensitiveLayout.gif
new file mode 100644
index 0000000..2e8ec2d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YCustomDecimalField.gif
new file mode 100644
index 0000000..02ca8c0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YIconComboBox.gif
new file mode 100644
index 0000000..fa6a5ee
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedDecimalField.gif
new file mode 100644
index 0000000..2e8ec2d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedNumericField.gif
new file mode 100644
index 0000000..cd91b67
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedTextField.gif
new file mode 100644
index 0000000..80dd10a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YPairComboBox.gif
new file mode 100644
index 0000000..9f1e0b8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..b3c6924
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YQuantityTextField.gif
new file mode 100644
index 0000000..3fa9c54
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YRichTextArea.gif
new file mode 100644
index 0000000..bdfb88b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YStrategyLayout.gif
new file mode 100644
index 0000000..3fa9c54
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayout_elements_YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_activeSuspectInfos_YSuspectInfo.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_activeSuspectInfos_YSuspectInfo.gif
new file mode 100644
index 0000000..324a64d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_activeSuspectInfos_YSuspectInfo.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YAbsoluteLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YAbsoluteLayout.gif
new file mode 100644
index 0000000..633da34
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YAbsoluteLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YAction.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YAction.gif
new file mode 100644
index 0000000..e6b48d9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YAction.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBeanReferenceField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBeanReferenceField.gif
new file mode 100644
index 0000000..94b1be2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBeanReferenceField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBlobUploadComponent.gif
new file mode 100644
index 0000000..dadbe43
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBooleanSearchField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBooleanSearchField.gif
new file mode 100644
index 0000000..cfb2d6e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBooleanSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBrowser.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBrowser.gif
new file mode 100644
index 0000000..83d2501
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YBrowser.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YButton.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YButton.gif
new file mode 100644
index 0000000..5a20caa
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YButton.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCheckBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCheckBox.gif
new file mode 100644
index 0000000..ba67912
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCheckBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YComboBox.gif
new file mode 100644
index 0000000..f69592c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YContentSensitiveLayout.gif
new file mode 100644
index 0000000..a03a30e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCssLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCssLayout.gif
new file mode 100644
index 0000000..b415959
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCssLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCustomDecimalField.gif
new file mode 100644
index 0000000..0062ded
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YDateTime.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YDateTime.gif
new file mode 100644
index 0000000..b415959
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YDateTime.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YDecimalField.gif
new file mode 100644
index 0000000..324a64d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumComboBox.gif
new file mode 100644
index 0000000..a47b32b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumList.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumList.gif
new file mode 100644
index 0000000..a7ddbdb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumList.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumOptionsGroup.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumOptionsGroup.gif
new file mode 100644
index 0000000..3bfcf11
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YEnumOptionsGroup.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YField.gif
new file mode 100644
index 0000000..f7a9c9f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YFormLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YFormLayout.gif
new file mode 100644
index 0000000..cfb2d6e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YFormLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YGridLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YGridLayout.gif
new file mode 100644
index 0000000..b415959
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YGridLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YHelperLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YHelperLayout.gif
new file mode 100644
index 0000000..f00d453
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YHelperLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YHorizontalLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YHorizontalLayout.gif
new file mode 100644
index 0000000..a03a30e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YHorizontalLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YIconComboBox.gif
new file mode 100644
index 0000000..16dbb0e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YImage.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YImage.gif
new file mode 100644
index 0000000..6010ac9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YImage.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YLabel.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YLabel.gif
new file mode 100644
index 0000000..970be05
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YLabel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YLayout.gif
new file mode 100644
index 0000000..f7a9c9f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YList.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YList.gif
new file mode 100644
index 0000000..e9b333d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YList.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedDecimalField.gif
new file mode 100644
index 0000000..a03a30e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedNumericField.gif
new file mode 100644
index 0000000..f00d453
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedTextField.gif
new file mode 100644
index 0000000..a0ba127
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMasterDetail.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMasterDetail.gif
new file mode 100644
index 0000000..0b0adae
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YMasterDetail.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YNumericField.gif
new file mode 100644
index 0000000..43a8eef
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YNumericSearchField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YNumericSearchField.gif
new file mode 100644
index 0000000..16dbb0e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YNumericSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YOptionsGroup.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YOptionsGroup.gif
new file mode 100644
index 0000000..08ad00b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YOptionsGroup.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPairComboBox.gif
new file mode 100644
index 0000000..a7ddbdb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPanel.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPanel.gif
new file mode 100644
index 0000000..ba67912
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPanel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPasswordField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPasswordField.gif
new file mode 100644
index 0000000..d66ff4a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPasswordField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..ecce8cb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YProgressBar.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YProgressBar.gif
new file mode 100644
index 0000000..a0ba127
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YProgressBar.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YQuantityTextField.gif
new file mode 100644
index 0000000..d66ff4a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YReferenceSearchField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YReferenceSearchField.gif
new file mode 100644
index 0000000..3473a1f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YReferenceSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YRichTextArea.gif
new file mode 100644
index 0000000..3473a1f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSearchPanel.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSearchPanel.gif
new file mode 100644
index 0000000..0062ded
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSearchPanel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSlider.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSlider.gif
new file mode 100644
index 0000000..9a7f5b8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSlider.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSplitPanel.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSplitPanel.gif
new file mode 100644
index 0000000..04a6748
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSplitPanel.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YStrategyLayout.gif
new file mode 100644
index 0000000..d66ff4a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSuggestTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSuggestTextField.gif
new file mode 100644
index 0000000..a03a30e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YSuggestTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTabSheet.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTabSheet.gif
new file mode 100644
index 0000000..e9b333d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTabSheet.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTable.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTable.gif
new file mode 100644
index 0000000..4cc4140
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTable.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextArea.gif
new file mode 100644
index 0000000..dadbe43
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextField.gif
new file mode 100644
index 0000000..3bfcf11
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextSearchField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextSearchField.gif
new file mode 100644
index 0000000..70597ff
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTextSearchField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YToggleButton.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YToggleButton.gif
new file mode 100644
index 0000000..f00d453
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YToggleButton.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTree.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTree.gif
new file mode 100644
index 0000000..83d2501
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YTree.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YVerticalLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YVerticalLayout.gif
new file mode 100644
index 0000000..e9b333d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYLayoutingInfo_content_YVerticalLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YBlobUploadComponent.gif
new file mode 100644
index 0000000..0dccd27
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YContentSensitiveLayout.gif
new file mode 100644
index 0000000..3826602
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YCustomDecimalField.gif
new file mode 100644
index 0000000..b24124a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YIconComboBox.gif
new file mode 100644
index 0000000..0056d63
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedDecimalField.gif
new file mode 100644
index 0000000..3826602
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedNumericField.gif
new file mode 100644
index 0000000..01293d8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedTextField.gif
new file mode 100644
index 0000000..ef7a76e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YPairComboBox.gif
new file mode 100644
index 0000000..2f2f535
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..745594b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YQuantityTextField.gif
new file mode 100644
index 0000000..a35176a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YRichTextArea.gif
new file mode 100644
index 0000000..4f65777
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YStrategyLayout.gif
new file mode 100644
index 0000000..a35176a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_detailElement_YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YBlobUploadComponent.gif
new file mode 100644
index 0000000..0dccd27
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YContentSensitiveLayout.gif
new file mode 100644
index 0000000..3826602
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YCustomDecimalField.gif
new file mode 100644
index 0000000..b24124a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YIconComboBox.gif
new file mode 100644
index 0000000..0056d63
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedDecimalField.gif
new file mode 100644
index 0000000..3826602
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedNumericField.gif
new file mode 100644
index 0000000..01293d8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedTextField.gif
new file mode 100644
index 0000000..ef7a76e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YPairComboBox.gif
new file mode 100644
index 0000000..2f2f535
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..745594b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YQuantityTextField.gif
new file mode 100644
index 0000000..a35176a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YRichTextArea.gif
new file mode 100644
index 0000000..4f65777
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YStrategyLayout.gif
new file mode 100644
index 0000000..a35176a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYMasterDetail_masterElement_YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYNumericToResourceConverter_configs_YNumericToResourceConfig.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYNumericToResourceConverter_configs_YNumericToResourceConfig.gif
new file mode 100644
index 0000000..0064b04
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYNumericToResourceConverter_configs_YNumericToResourceConfig.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYPrefixedMaskedTextField_prefixes_YStringToStringMap.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYPrefixedMaskedTextField_prefixes_YStringToStringMap.gif
new file mode 100644
index 0000000..a2ea8fe
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYPrefixedMaskedTextField_prefixes_YStringToStringMap.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_focusingStrategies_YDelegatingFocusingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_focusingStrategies_YDelegatingFocusingStrategy.gif
new file mode 100644
index 0000000..1bcf3da
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_focusingStrategies_YDelegatingFocusingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_focusingStrategies_YFocusingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_focusingStrategies_YFocusingStrategy.gif
new file mode 100644
index 0000000..ab320ca
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_focusingStrategies_YFocusingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingInfo_YLayoutingInfo.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingInfo_YLayoutingInfo.gif
new file mode 100644
index 0000000..3df71fc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingInfo_YLayoutingInfo.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YDefaultLayoutingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YDefaultLayoutingStrategy.gif
new file mode 100644
index 0000000..8653454
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YDefaultLayoutingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YDelegatingLayoutingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YDelegatingLayoutingStrategy.gif
new file mode 100644
index 0000000..b79c105
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YDelegatingLayoutingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YLayoutingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YLayoutingStrategy.gif
new file mode 100644
index 0000000..3cafe5d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_layoutingStrategy_YLayoutingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YCollectionSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YCollectionSuspect.gif
new file mode 100644
index 0000000..d166c3d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YCollectionSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSubTypeBaseSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSubTypeBaseSuspect.gif
new file mode 100644
index 0000000..d7c5af7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSubTypeBaseSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSubTypeSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSubTypeSuspect.gif
new file mode 100644
index 0000000..1a59694
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSubTypeSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSuspect.gif
new file mode 100644
index 0000000..1bcf3da
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YTypedCompoundSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YTypedCompoundSuspect.gif
new file mode 100644
index 0000000..a0d9f76
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YTypedCompoundSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YTypedSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YTypedSuspect.gif
new file mode 100644
index 0000000..a17c76f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStrategyLayout_suspects_YTypedSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStringToResourceConverter_configs_YStringToResourceConfig.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStringToResourceConverter_configs_YStringToResourceConfig.gif
new file mode 100644
index 0000000..b447e9a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYStringToResourceConverter_configs_YStringToResourceConfig.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_bindings_YListBinding.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_bindings_YListBinding.gif
new file mode 100644
index 0000000..9c04b67
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_bindings_YListBinding.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_bindings_YValueBinding.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_bindings_YValueBinding.gif
new file mode 100644
index 0000000..fcf062a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_bindings_YValueBinding.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YAuthorizationVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YAuthorizationVisibilityProcessor.gif
new file mode 100644
index 0000000..8dafe0e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YAuthorizationVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YSubTypeVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YSubTypeVisibilityProcessor.gif
new file mode 100644
index 0000000..fdabbc2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YSubTypeVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YVisibilityProcessor.gif
new file mode 100644
index 0000000..c5dab99
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspectInfo_visibilityProcessors_YVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_associatedBindings_YListBinding.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_associatedBindings_YListBinding.gif
new file mode 100644
index 0000000..32f857f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_associatedBindings_YListBinding.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_associatedBindings_YValueBinding.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_associatedBindings_YValueBinding.gif
new file mode 100644
index 0000000..e22c7e4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_associatedBindings_YValueBinding.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YAddToTableCommand.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YAddToTableCommand.gif
new file mode 100644
index 0000000..73486a0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YAddToTableCommand.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YOpenDialogCommand.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YOpenDialogCommand.gif
new file mode 100644
index 0000000..8af56bd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YOpenDialogCommand.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YRemoveFromTableCommand.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YRemoveFromTableCommand.gif
new file mode 100644
index 0000000..7601130
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YRemoveFromTableCommand.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YSendEventCommand.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YSendEventCommand.gif
new file mode 100644
index 0000000..247671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YSendEventCommand.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YSetNewBeanInstanceCommand.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YSetNewBeanInstanceCommand.gif
new file mode 100644
index 0000000..7601130
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_commands_YSetNewBeanInstanceCommand.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YActivatedEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YActivatedEndpoint.gif
new file mode 100644
index 0000000..40ce635
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YActivatedEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanSlotListBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanSlotListBindingEndpoint.gif
new file mode 100644
index 0000000..56becf8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanSlotListBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanSlotValueBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanSlotValueBindingEndpoint.gif
new file mode 100644
index 0000000..776368e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanSlotValueBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanValueBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanValueBindingEndpoint.gif
new file mode 100644
index 0000000..1a18575
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YBeanValueBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YContextValueBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YContextValueBindingEndpoint.gif
new file mode 100644
index 0000000..32f857f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YContextValueBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YDetailValueBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YDetailValueBindingEndpoint.gif
new file mode 100644
index 0000000..1a30bfd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YDetailValueBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YECViewModelListBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YECViewModelListBindingEndpoint.gif
new file mode 100644
index 0000000..9d7874d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YECViewModelListBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YECViewModelValueBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YECViewModelValueBindingEndpoint.gif
new file mode 100644
index 0000000..b82fff7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YECViewModelValueBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableCollectionEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableCollectionEndpoint.gif
new file mode 100644
index 0000000..f69c801
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableCollectionEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableMultiSelectionEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableMultiSelectionEndpoint.gif
new file mode 100644
index 0000000..c750823
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableMultiSelectionEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableSelectionEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableSelectionEndpoint.gif
new file mode 100644
index 0000000..ae214b9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableSelectionEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableValueEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableValueEndpoint.gif
new file mode 100644
index 0000000..247671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEmbeddableValueEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEnumListBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEnumListBindingEndpoint.gif
new file mode 100644
index 0000000..32f857f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YEnumListBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YNoOpListBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YNoOpListBindingEndpoint.gif
new file mode 100644
index 0000000..f69c801
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YNoOpListBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YNoOpValueBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YNoOpValueBindingEndpoint.gif
new file mode 100644
index 0000000..d7b26a7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YNoOpValueBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YVisibilityProcessorValueBindingEndpoint.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YVisibilityProcessorValueBindingEndpoint.gif
new file mode 100644
index 0000000..72eb6e6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_valueBindingEndpoints_YVisibilityProcessorValueBindingEndpoint.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YAuthVPDetail.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YAuthVPDetail.gif
new file mode 100644
index 0000000..40ce635
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YAuthVPDetail.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YAuthorizationVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YAuthorizationVisibilityProcessor.gif
new file mode 100644
index 0000000..0403fbd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YAuthorizationVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YSubTypeVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YSubTypeVisibilityProcessor.gif
new file mode 100644
index 0000000..5a593b6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YSubTypeVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YVisibilityProcessor.gif
new file mode 100644
index 0000000..290d467
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYSuspect_visibilityProcessors_YVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YBlobUploadComponent.gif
new file mode 100644
index 0000000..f37ce87
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YContentSensitiveLayout.gif
new file mode 100644
index 0000000..f6ec10a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YCustomDecimalField.gif
new file mode 100644
index 0000000..e0e45bd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YIconComboBox.gif
new file mode 100644
index 0000000..03c1266
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedDecimalField.gif
new file mode 100644
index 0000000..f6ec10a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedNumericField.gif
new file mode 100644
index 0000000..9c71118
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedTextField.gif
new file mode 100644
index 0000000..1b80aea
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YPairComboBox.gif
new file mode 100644
index 0000000..748e96d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..67dbac2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YQuantityTextField.gif
new file mode 100644
index 0000000..8f218cb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YRichTextArea.gif
new file mode 100644
index 0000000..43d93ae
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YStrategyLayout.gif
new file mode 100644
index 0000000..8f218cb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTab_embeddable_YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YCollectionSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YCollectionSuspect.gif
new file mode 100644
index 0000000..58e344b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YCollectionSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSubTypeBaseSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSubTypeBaseSuspect.gif
new file mode 100644
index 0000000..5f45cab
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSubTypeBaseSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSubTypeSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSubTypeSuspect.gif
new file mode 100644
index 0000000..14d7832
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSubTypeSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSuspect.gif
new file mode 100644
index 0000000..fcf062a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YTypedCompoundSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YTypedCompoundSuspect.gif
new file mode 100644
index 0000000..f213cc3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YTypedCompoundSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YTypedSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YTypedSuspect.gif
new file mode 100644
index 0000000..4d2fdfd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYTypedCompoundSuspect_children_YTypedSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YBlobUploadComponent.gif
new file mode 100644
index 0000000..6baa8a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YContentSensitiveLayout.gif
new file mode 100644
index 0000000..5381067
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YCustomDecimalField.gif
new file mode 100644
index 0000000..de6e628
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YIconComboBox.gif
new file mode 100644
index 0000000..a36743b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedDecimalField.gif
new file mode 100644
index 0000000..5381067
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedNumericField.gif
new file mode 100644
index 0000000..dd977db
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedTextField.gif
new file mode 100644
index 0000000..b9cd878
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YPairComboBox.gif
new file mode 100644
index 0000000..e0a4541
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..28de654
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YQuantityTextField.gif
new file mode 100644
index 0000000..3353cf6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YRichTextArea.gif
new file mode 100644
index 0000000..4f7ee52
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YStrategyLayout.gif
new file mode 100644
index 0000000..3353cf6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/ctool16/CreateYView_content_YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YAuthVPDetail.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YAuthVPDetail.gif
new file mode 100644
index 0000000..48e3cf2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YAuthVPDetail.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YAuthorizationVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YAuthorizationVisibilityProcessor.gif
new file mode 100644
index 0000000..afb82ea
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YAuthorizationVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YBlobUploadComponent.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YBlobUploadComponent.gif
new file mode 100644
index 0000000..7b7c428
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YBlobUploadComponent.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCollectionSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCollectionSuspect.gif
new file mode 100644
index 0000000..498364f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCollectionSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YColumnInfo.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YColumnInfo.gif
new file mode 100644
index 0000000..c3370c7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YColumnInfo.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YContentSensitiveLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YContentSensitiveLayout.gif
new file mode 100644
index 0000000..badaab0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YContentSensitiveLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalConverter.gif
new file mode 100644
index 0000000..ed87474
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalField.gif
new file mode 100644
index 0000000..106881e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalFloatConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalFloatConverter.gif
new file mode 100644
index 0000000..33854e9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YCustomDecimalFloatConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDecimalToUomoConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDecimalToUomoConverter.gif
new file mode 100644
index 0000000..33854e9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDecimalToUomoConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDefaultLayoutingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDefaultLayoutingStrategy.gif
new file mode 100644
index 0000000..cdd3b76
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDefaultLayoutingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDelegatingFocusingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDelegatingFocusingStrategy.gif
new file mode 100644
index 0000000..1e5345f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDelegatingFocusingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDelegatingLayoutingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDelegatingLayoutingStrategy.gif
new file mode 100644
index 0000000..90d10f9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YDelegatingLayoutingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YFocusingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YFocusingStrategy.gif
new file mode 100644
index 0000000..106881e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YFocusingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YIconComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YIconComboBox.gif
new file mode 100644
index 0000000..d3dc5a9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YIconComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YLayoutingInfo.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YLayoutingInfo.gif
new file mode 100644
index 0000000..33854e9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YLayoutingInfo.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YLayoutingStrategy.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YLayoutingStrategy.gif
new file mode 100644
index 0000000..7c2aaac
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YLayoutingStrategy.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedDecimalField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedDecimalField.gif
new file mode 100644
index 0000000..badaab0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedDecimalField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedNumericField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedNumericField.gif
new file mode 100644
index 0000000..b3643da
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedNumericField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedTextField.gif
new file mode 100644
index 0000000..c4a8af4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToResourceConfig.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToResourceConfig.gif
new file mode 100644
index 0000000..be22463
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToResourceConfig.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToResourceConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToResourceConverter.gif
new file mode 100644
index 0000000..45731fe
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToResourceConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToUomoConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToUomoConverter.gif
new file mode 100644
index 0000000..c4fb30e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YNumericToUomoConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YObjectToStringConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YObjectToStringConverter.gif
new file mode 100644
index 0000000..134551b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YObjectToStringConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPairComboBox.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPairComboBox.gif
new file mode 100644
index 0000000..d92f34c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPairComboBox.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPrefixedMaskedTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPrefixedMaskedTextField.gif
new file mode 100644
index 0000000..90d10f9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPrefixedMaskedTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPriceToStringConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPriceToStringConverter.gif
new file mode 100644
index 0000000..45731fe
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YPriceToStringConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YQuantityTextField.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YQuantityTextField.gif
new file mode 100644
index 0000000..9250fec
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YQuantityTextField.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YQuantityToStringConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YQuantityToStringConverter.gif
new file mode 100644
index 0000000..c673a52
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YQuantityToStringConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YRichTextArea.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YRichTextArea.gif
new file mode 100644
index 0000000..c673a52
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YRichTextArea.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSimpleDecimalConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSimpleDecimalConverter.gif
new file mode 100644
index 0000000..94c953e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSimpleDecimalConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStrategyLayout.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStrategyLayout.gif
new file mode 100644
index 0000000..9250fec
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStrategyLayout.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStringToResourceConfig.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStringToResourceConfig.gif
new file mode 100644
index 0000000..a3908bc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStringToResourceConfig.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStringToResourceConverter.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStringToResourceConverter.gif
new file mode 100644
index 0000000..10d2229
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YStringToResourceConverter.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeBaseSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeBaseSuspect.gif
new file mode 100644
index 0000000..a17dc7d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeBaseSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeSuspect.gif
new file mode 100644
index 0000000..a3908bc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeVisibilityProcessor.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeVisibilityProcessor.gif
new file mode 100644
index 0000000..739ebbf
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSubTypeVisibilityProcessor.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSuspect.gif
new file mode 100644
index 0000000..1e5345f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSuspectInfo.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSuspectInfo.gif
new file mode 100644
index 0000000..134551b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YSuspectInfo.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YTypedCompoundSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YTypedCompoundSuspect.gif
new file mode 100644
index 0000000..134551b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YTypedCompoundSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YTypedSuspect.gif b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YTypedSuspect.gif
new file mode 100644
index 0000000..8a5c70c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/icons/full/obj16/YTypedSuspect.gif
Binary files differ
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/license.html b/org.eclipse.osbp.ecview.extension.model.edit/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/notice.html b/org.eclipse.osbp.ecview.extension.model.edit/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.model.edit/plugin.properties b/org.eclipse.osbp.ecview.extension.model.edit/plugin.properties
new file mode 100644
index 0000000..a732b75
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/plugin.properties
@@ -0,0 +1,187 @@
+# All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+# 
+# Contributors:
+#       Florian Pirchner - initial API and implementation
+
+pluginName = ecview Edit Support
+providerName = www.example.org
+
+_UI_CreateChild_text = {0}
+_UI_CreateChild_text2 = {1} {0}
+_UI_CreateChild_text3 = {1}
+_UI_CreateChild_tooltip = Create New {0} Under {1} Feature
+_UI_CreateChild_description = Create a new child of type {0} for the {1} feature of the selected {2}.
+_UI_CreateSibling_description = Create a new sibling of type {0} for the selected {2}, under the {1} feature of their parent.
+
+_UI_PropertyDescriptor_description = The {0} of the {1}
+
+_UI_YStrategyLayout_type = YStrategy Layout
+_UI_YLayoutingStrategy_type = YLayouting Strategy
+_UI_YDefaultLayoutingStrategy_type = YDefault Layouting Strategy
+_UI_YFocusingStrategy_type = YFocusing Strategy
+_UI_YDelegatingLayoutingStrategy_type = YDelegating Layouting Strategy
+_UI_YDelegatingFocusingStrategy_type = YDelegating Focusing Strategy
+_UI_YSuspect_type = YSuspect
+_UI_YTypedSuspect_type = YTyped Suspect
+_UI_YTypedCompoundSuspect_type = YTyped Compound Suspect
+_UI_YLayoutingInfo_type = YLayouting Info
+_UI_YSuspectInfo_type = YSuspect Info
+_UI_YBlobUploadComponent_type = YBlob Upload Component
+_UI_YCustomDecimalField_type = YCustom Decimal Field
+_UI_YQuantityTextField_type = YQuantity Text Field
+_UI_YCollectionSuspect_type = YCollection Suspect
+_UI_YColumnInfo_type = YColumn Info
+_UI_YObjectToStringConverter_type = YObject To String Converter
+_UI_YCustomDecimalConverter_type = YCustom Decimal Converter
+_UI_YCustomDecimalFloatConverter_type = YCustom Decimal Float Converter
+_UI_YNumericToResourceConverter_type = YNumeric To Resource Converter
+_UI_YStringToResourceConverter_type = YString To Resource Converter
+_UI_YNumericToResourceConfig_type = YNumeric To Resource Config
+_UI_YStringToResourceConfig_type = YString To Resource Config
+_UI_YPriceToStringConverter_type = YPrice To String Converter
+_UI_YQuantityToStringConverter_type = YQuantity To String Converter
+_UI_YNumericToUomoConverter_type = YNumeric To Uomo Converter
+_UI_YDecimalToUomoConverter_type = YDecimal To Uomo Converter
+_UI_YAuthorizationVisibilityProcessor_type = YAuthorization Visibility Processor
+_UI_YAuthVPDetail_type = YAuth VP Detail
+_UI_Unknown_type = Object
+
+_UI_Unknown_datatype= Value
+
+_UI_YStrategyLayout_layoutingStrategy_feature = Layouting Strategy
+_UI_YStrategyLayout_focusingStrategies_feature = Focusing Strategies
+_UI_YStrategyLayout_suspects_feature = Suspects
+_UI_YStrategyLayout_layoutingInfo_feature = Layouting Info
+_UI_YStrategyLayout_defaultFocusingEnhancerId_feature = Default Focusing Enhancer Id
+_UI_YLayoutingStrategy_trigger_feature = Trigger
+_UI_YFocusingStrategy_keyStrokeDefinition_feature = Key Stroke Definition
+_UI_YFocusingStrategy_tempStrokeDefinition_feature = Temp Stroke Definition
+_UI_YDelegatingLayoutingStrategy_delegateStrategyId_feature = Delegate Strategy Id
+_UI_YDelegatingFocusingStrategy_delegateStrategyId_feature = Delegate Strategy Id
+_UI_YSuspect_labelI18nKey_feature = Label I1 8n Key
+_UI_YSuspect_imageI18nKey_feature = Image I1 8n Key
+_UI_YSuspect_valueBindingEndpoints_feature = Value Binding Endpoints
+_UI_YSuspect_visibilityProcessors_feature = Visibility Processors
+_UI_YSuspect_commands_feature = Commands
+_UI_YSuspect_assocNewiatedElements_feature = Assoc Newiated Elements
+_UI_YSuspect_associatedBindings_feature = Associated Bindings
+_UI_YSuspect_label_feature = Label
+_UI_YTypedSuspect_typeQualifiedName_feature = Type Qualified Name
+_UI_YTypedSuspect_type_feature = Type
+_UI_YTypedCompoundSuspect_children_feature = Children
+_UI_YLayoutingInfo_layout_feature = Layout
+_UI_YLayoutingInfo_content_feature = Content
+_UI_YLayoutingInfo_activeSuspectInfos_feature = Active Suspect Infos
+_UI_YLayoutingInfo_firstFocus_feature = First Focus
+_UI_YSuspectInfo_suspect_feature = Suspect
+_UI_YSuspectInfo_bindings_feature = Bindings
+_UI_YSuspectInfo_nextFocus_feature = Next Focus
+_UI_YSuspectInfo_previousFocus_feature = Previous Focus
+_UI_YSuspectInfo_target_feature = Target
+_UI_YBlobUploadComponent_value_feature = Value
+_UI_YBlobUploadComponent_label_feature = Label
+_UI_YBlobUploadComponent_labelI18nKey_feature = Label I1 8n Key
+_UI_YBlobUploadComponent_displayResolutionId_feature = Display Resolution Id
+_UI_YCustomDecimalField_datatype_feature = Datatype
+_UI_YCustomDecimalField_datadescription_feature = Datadescription
+_UI_YCustomDecimalField_value_feature = Value
+_UI_YQuantityTextField_datadescription_feature = Datadescription
+_UI_YQuantityTextField_value_feature = Value
+_UI_YCollectionSuspect_columns_feature = Columns
+_UI_YColumnInfo_name_feature = Name
+_UI_YColumnInfo_type_feature = Type
+_UI_YColumnInfo_typeQualifiedName_feature = Type Qualified Name
+_UI_YColumnInfo_properties_feature = Properties
+_UI_YCustomDecimalConverter_baseUnit_feature = Base Unit
+_UI_YCustomDecimalFloatConverter_baseUnit_feature = Base Unit
+_UI_YNumericToResourceConverter_configs_feature = Configs
+_UI_YStringToResourceConverter_configs_feature = Configs
+_UI_YNumericToResourceConfig_value_feature = Value
+_UI_YNumericToResourceConfig_compare_feature = Compare
+_UI_YNumericToResourceConfig_resourceThemePath_feature = Resource Theme Path
+_UI_YStringToResourceConfig_value_feature = Value
+_UI_YStringToResourceConfig_compare_feature = Compare
+_UI_YStringToResourceConfig_resourceThemePath_feature = Resource Theme Path
+_UI_YPriceToStringConverter_valuePropertyPath_feature = Value Property Path
+_UI_YPriceToStringConverter_currencyPropertyPath_feature = Currency Property Path
+_UI_YPriceToStringConverter_typeQualifiedName_feature = Type Qualified Name
+_UI_YPriceToStringConverter_type_feature = Type
+_UI_YQuantityToStringConverter_amountPropertyPath_feature = Amount Property Path
+_UI_YQuantityToStringConverter_uomPropertyPath_feature = Uom Property Path
+_UI_YQuantityToStringConverter_uomCodeRelativePropertyPath_feature = Uom Code Relative Property Path
+_UI_YQuantityToStringConverter_quantityTypeQualifiedName_feature = Quantity Type Qualified Name
+_UI_YAuthorizationVisibilityProcessor_details_feature = Details
+_UI_YAuthVPDetail_targetFieldId_feature = Target Field Id
+_UI_YAuthVPDetail_entityName_feature = Entity Name
+_UI_YAuthVPDetail_entityProperty_feature = Entity Property
+_UI_Unknown_feature = Unspecified
+
+_UI_YSimpleDecimalConverter_type = YSimple Decimal Converter
+_UI_YSimpleDecimalConverter_numberFormatPattern_feature = Number Format Pattern
+_UI_YColumnInfo_labelI18nKey_feature = Label I1 8n Key
+_UI_YIconComboBox_type = YIcon Combo Box
+_UI_YIconComboBox_datadescription_feature = Datadescription
+_UI_YIconComboBox_datatype_feature = Datatype
+_UI_YIconComboBox_selection_feature = Selection
+_UI_YIconComboBox_collection_feature = Collection
+_UI_YIconComboBox_type_feature = Type
+_UI_YIconComboBox_emfNsURI_feature = Emf Ns URI
+_UI_YIconComboBox_typeQualifiedName_feature = Type Qualified Name
+_UI_YIconComboBox_captionProperty_feature = Caption Property
+_UI_YIconComboBox_imageProperty_feature = Image Property
+_UI_YIconComboBox_descriptionProperty_feature = Description Property
+_UI_YIconComboBox_description_feature = Description
+_UI_YContentSensitiveLayout_type = YContent Sensitive Layout
+_UI_YSubTypeBaseSuspect_type = YSub Type Base Suspect
+_UI_YSubTypeSuspect_type = YSub Type Suspect
+_UI_YSubTypeSuspect_beanSlot_feature = Bean Slot
+_UI_YSubTypeVisibilityProcessor_type = YSub Type Visibility Processor
+_UI_YSubTypeVisibilityProcessor_typeQualifiedName_feature = Type Qualified Name
+_UI_YSubTypeVisibilityProcessor_type_feature = Type
+_UI_YSubTypeVisibilityProcessor_target_feature = Target
+_UI_YSuspectInfo_visibilityProcessors_feature = Visibility Processors
+_UI_YRichTextArea_type = YRich Text Area
+<<<<<<< HEAD
+_UI_YMaskedTextField_type = YMasked Text Field
+_UI_YPrefixedMaskedTextField_type = YPrefixed Masked Text Field
+_UI_YMaskedNumericField_type = YMasked Numeric Field
+_UI_YMaskedDecimalField_type = YMasked Decimal Field
+_UI_YRichTextArea_datadescription_feature = Datadescription
+_UI_YRichTextArea_blobValue_feature = Blob Value
+_UI_YRichTextArea_value_feature = Value
+_UI_YRichTextArea_useBlob_feature = Use Blob
+_UI_YMaskedTextField_datadescription_feature = Datadescription
+_UI_YMaskedTextField_value_feature = Value
+_UI_YMaskedTextField_mask_feature = Mask
+_UI_YPrefixedMaskedTextField_datadescription_feature = Datadescription
+_UI_YPrefixedMaskedTextField_value_feature = Value
+_UI_YPrefixedMaskedTextField_mask_feature = Mask
+_UI_YPrefixedMaskedTextField_prefixes_feature = Prefixes
+_UI_YMaskedNumericField_datadescription_feature = Datadescription
+_UI_YMaskedNumericField_value_feature = Value
+_UI_YMaskedNumericField_mask_feature = Mask
+_UI_YMaskedDecimalField_datadescription_feature = Datadescription
+_UI_YMaskedDecimalField_value_feature = Value
+_UI_YMaskedDecimalField_mask_feature = Mask
+_UI_YMaskedDecimalField_decimalSeparator_feature = Decimal Separator
+_UI_YMaskedDecimalField_groupingSeparator_feature = Grouping Separator
+=======
+_UI_YPairComboBox_type = YPair Combo Box
+_UI_YBlobUploadComponent_firmlyLinked_feature = Firmly Linked
+_UI_YBlobUploadComponent_uniqueNameEnabled_feature = Unique Name Enabled
+_UI_YRichTextArea_datadescription_feature = Datadescription
+_UI_YRichTextArea_blobValue_feature = Blob Value
+_UI_YRichTextArea_value_feature = Value
+_UI_YRichTextArea_useBlob_feature = Use Blob
+_UI_YPairComboBox_datadescription_feature = Datadescription
+_UI_YPairComboBox_datatype_feature = Datatype
+_UI_YPairComboBox_selection_feature = Selection
+_UI_YPairComboBox_collection_feature = Collection
+_UI_YPairComboBox_type_feature = Type
+_UI_YPairComboBox_emfNsURI_feature = Emf Ns URI
+_UI_YPairComboBox_typeQualifiedName_feature = Type Qualified Name
+_UI_YPairComboBox_captionProperty_feature = Caption Property
+_UI_YPairComboBox_imageProperty_feature = Image Property
+_UI_YPairComboBox_descriptionProperty_feature = Description Property
+_UI_YPairComboBox_description_feature = Description
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/plugin.xml b/org.eclipse.osbp.ecview.extension.model.edit/plugin.xml
new file mode 100644
index 0000000..5f04930
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/plugin.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+ All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+ 
+ Contributors:
+       Florian Pirchner - initial API and implementation
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated ecview -->
+      <factory
+            uri="http://osbp.de/ecview/v1/extension"
+            class="org.eclipse.osbp.ecview.extension.model.provider.YECviewItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.edit.childCreationExtenders">
+      <!-- @generated ecview -->
+      <extender
+            uri="http://osbp.eclipse.org/ecview/v1/core/view"
+            class="org.eclipse.osbp.ecview.extension.model.provider.YECviewItemProviderAdapterFactory$CoreModelChildCreationExtender"/>
+      <extender
+            uri="http://osbp.eclipse.org/ecview/v1/extension/view"
+            class="org.eclipse.osbp.ecview.extension.model.provider.YECviewItemProviderAdapterFactory$ExtensionModelChildCreationExtender"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated ecview -->
+      <factory
+            uri="http://osbp.de/ecview/v1/extension/converter"
+            class="org.eclipse.osbp.ecview.extension.model.converter.provider.YConverterItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated ecview -->
+      <factory
+            uri="http://osbp.de/ecview/v1/extension/visibility"
+            class="org.eclipse.osbp.ecview.extension.model.visibility.provider.YVisibilityItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+</plugin>
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/pom.xml b/org.eclipse.osbp.ecview.extension.model.edit/pom.xml
new file mode 100644
index 0000000..1a87296
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/pom.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial 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.ecview.extension.api</groupId>
+		<artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.ecview.extension.model.edit</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+	</build>
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YConverterItemProviderAdapterFactory.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YConverterItemProviderAdapterFactory.java
new file mode 100644
index 0000000..29587af
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YConverterItemProviderAdapterFactory.java
@@ -0,0 +1,460 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+import org.eclipse.osbp.ecview.extension.model.converter.util.YConverterAdapterFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support Viewers.
+ * The adapters generated by this factory convert EMF adapter notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}.
+ * The adapters also support Eclipse property sheets.
+ * Note that most of the adapters are shared among multiple instances.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YConverterItemProviderAdapterFactory extends YConverterAdapterFactory implements ComposeableAdapterFactory, IChangeNotifier, IDisposable {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This keeps track of the root adapter factory that delegates to this adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement {@link org.eclipse.emf.edit.provider.IChangeNotifier}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This keeps track of all the supported types checked by {@link #isFactoryForType isFactoryForType}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YConverterItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YObjectToStringConverterItemProvider yObjectToStringConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYObjectToStringConverterAdapter() {
+		if (yObjectToStringConverterItemProvider == null) {
+			yObjectToStringConverterItemProvider = new YObjectToStringConverterItemProvider(this);
+		}
+
+		return yObjectToStringConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YCustomDecimalConverterItemProvider yCustomDecimalConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYCustomDecimalConverterAdapter() {
+		if (yCustomDecimalConverterItemProvider == null) {
+			yCustomDecimalConverterItemProvider = new YCustomDecimalConverterItemProvider(this);
+		}
+
+		return yCustomDecimalConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YNumericToResourceConverterItemProvider yNumericToResourceConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYNumericToResourceConverterAdapter() {
+		if (yNumericToResourceConverterItemProvider == null) {
+			yNumericToResourceConverterItemProvider = new YNumericToResourceConverterItemProvider(this);
+		}
+
+		return yNumericToResourceConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YStringToResourceConverterItemProvider yStringToResourceConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYStringToResourceConverterAdapter() {
+		if (yStringToResourceConverterItemProvider == null) {
+			yStringToResourceConverterItemProvider = new YStringToResourceConverterItemProvider(this);
+		}
+
+		return yStringToResourceConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YNumericToResourceConfigItemProvider yNumericToResourceConfigItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYNumericToResourceConfigAdapter() {
+		if (yNumericToResourceConfigItemProvider == null) {
+			yNumericToResourceConfigItemProvider = new YNumericToResourceConfigItemProvider(this);
+		}
+
+		return yNumericToResourceConfigItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YStringToResourceConfigItemProvider yStringToResourceConfigItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYStringToResourceConfigAdapter() {
+		if (yStringToResourceConfigItemProvider == null) {
+			yStringToResourceConfigItemProvider = new YStringToResourceConfigItemProvider(this);
+		}
+
+		return yStringToResourceConfigItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YPriceToStringConverterItemProvider yPriceToStringConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYPriceToStringConverterAdapter() {
+		if (yPriceToStringConverterItemProvider == null) {
+			yPriceToStringConverterItemProvider = new YPriceToStringConverterItemProvider(this);
+		}
+
+		return yPriceToStringConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YQuantityToStringConverterItemProvider yQuantityToStringConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYQuantityToStringConverterAdapter() {
+		if (yQuantityToStringConverterItemProvider == null) {
+			yQuantityToStringConverterItemProvider = new YQuantityToStringConverterItemProvider(this);
+		}
+
+		return yQuantityToStringConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YNumericToUomoConverterItemProvider yNumericToUomoConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYNumericToUomoConverterAdapter() {
+		if (yNumericToUomoConverterItemProvider == null) {
+			yNumericToUomoConverterItemProvider = new YNumericToUomoConverterItemProvider(this);
+		}
+
+		return yNumericToUomoConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YDecimalToUomoConverterItemProvider yDecimalToUomoConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYDecimalToUomoConverterAdapter() {
+		if (yDecimalToUomoConverterItemProvider == null) {
+			yDecimalToUomoConverterItemProvider = new YDecimalToUomoConverterItemProvider(this);
+		}
+
+		return yDecimalToUomoConverterItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSimpleDecimalConverterItemProvider ySimpleDecimalConverterItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYSimpleDecimalConverterAdapter() {
+		if (ySimpleDecimalConverterItemProvider == null) {
+			ySimpleDecimalConverterItemProvider = new YSimpleDecimalConverterItemProvider(this);
+		}
+
+		return ySimpleDecimalConverterItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the root adapter factory
+	 * @generated
+	 */
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param parentAdapterFactory
+	 *            the new this keeps track of the root adapter factory that
+	 *            delegates to this adapter factory
+	 * @generated
+	 */
+	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param type
+	 *            the type
+	 * @return true, if is factory for type
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the adapter.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param type
+	 *            the type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>) || (((Class<?>)type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * This adds a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to
+	 * {@link #parentAdapterFactory}. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param notification
+	 *            the notification
+	 * @generated
+	 */
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory. 
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void dispose() {
+		if (yObjectToStringConverterItemProvider != null) yObjectToStringConverterItemProvider.dispose();
+		if (yCustomDecimalConverterItemProvider != null) yCustomDecimalConverterItemProvider.dispose();
+		if (yNumericToResourceConverterItemProvider != null) yNumericToResourceConverterItemProvider.dispose();
+		if (yStringToResourceConverterItemProvider != null) yStringToResourceConverterItemProvider.dispose();
+		if (yNumericToResourceConfigItemProvider != null) yNumericToResourceConfigItemProvider.dispose();
+		if (yStringToResourceConfigItemProvider != null) yStringToResourceConfigItemProvider.dispose();
+		if (yPriceToStringConverterItemProvider != null) yPriceToStringConverterItemProvider.dispose();
+		if (yQuantityToStringConverterItemProvider != null) yQuantityToStringConverterItemProvider.dispose();
+		if (yNumericToUomoConverterItemProvider != null) yNumericToUomoConverterItemProvider.dispose();
+		if (yDecimalToUomoConverterItemProvider != null) yDecimalToUomoConverterItemProvider.dispose();
+		if (ySimpleDecimalConverterItemProvider != null) ySimpleDecimalConverterItemProvider.dispose();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YCustomDecimalConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YCustomDecimalConverterItemProvider.java
new file mode 100644
index 0000000..b06c3c0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YCustomDecimalConverterItemProvider.java
@@ -0,0 +1,313 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YCustomDecimalConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YCustomDecimalConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addBaseUnitPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Base Unit feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addBaseUnitPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YCustomDecimalConverter_baseUnit_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YCustomDecimalConverter_baseUnit_feature", "_UI_YCustomDecimalConverter_type"),
+				 YConverterPackage.Literals.YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YCustomDecimalConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YCustomDecimalConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YCustomDecimalConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YCustomDecimalConverter_type") :
+			getString("_UI_YCustomDecimalConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YCustomDecimalConverter.class)) {
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__TAGS:
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__ID:
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__NAME:
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YDecimalToUomoConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YDecimalToUomoConverterItemProvider.java
new file mode 100644
index 0000000..1bbe156
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YDecimalToUomoConverterItemProvider.java
@@ -0,0 +1,287 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YDecimalToUomoConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YDecimalToUomoConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YDecimalToUomoConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YDecimalToUomoConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YDecimalToUomoConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YDecimalToUomoConverter_type") :
+			getString("_UI_YDecimalToUomoConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YDecimalToUomoConverter.class)) {
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__TAGS:
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__ID:
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToResourceConfigItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToResourceConfigItemProvider.java
new file mode 100644
index 0000000..8020225
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToResourceConfigItemProvider.java
@@ -0,0 +1,244 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YNumericToResourceConfigItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YNumericToResourceConfigItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValuePropertyDescriptor(object);
+			addComparePropertyDescriptor(object);
+			addResourceThemePathPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YNumericToResourceConfig_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YNumericToResourceConfig_value_feature", "_UI_YNumericToResourceConfig_type"),
+				 YConverterPackage.Literals.YNUMERIC_TO_RESOURCE_CONFIG__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.REAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Compare feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addComparePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YNumericToResourceConfig_compare_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YNumericToResourceConfig_compare_feature", "_UI_YNumericToResourceConfig_type"),
+				 YConverterPackage.Literals.YNUMERIC_TO_RESOURCE_CONFIG__COMPARE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Resource Theme Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addResourceThemePathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YNumericToResourceConfig_resourceThemePath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YNumericToResourceConfig_resourceThemePath_feature", "_UI_YNumericToResourceConfig_type"),
+				 YConverterPackage.Literals.YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YNumericToResourceConfig.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YNumericToResourceConfig"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		YNumericToResourceConfig yNumericToResourceConfig = (YNumericToResourceConfig)object;
+		return getString("_UI_YNumericToResourceConfig_type") + " " + yNumericToResourceConfig.getValue();
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YNumericToResourceConfig.class)) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__VALUE:
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__COMPARE:
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToResourceConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToResourceConverterItemProvider.java
new file mode 100644
index 0000000..ad2b95b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToResourceConverterItemProvider.java
@@ -0,0 +1,295 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YNumericToResourceConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YNumericToResourceConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(YConverterPackage.Literals.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YNumericToResourceConverter.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YNumericToResourceConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YNumericToResourceConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YNumericToResourceConverter_type") :
+			getString("_UI_YNumericToResourceConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YNumericToResourceConverter.class)) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__TAGS:
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__ID:
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES:
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YConverterPackage.Literals.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConfig()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToUomoConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToUomoConverterItemProvider.java
new file mode 100644
index 0000000..06bb47d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YNumericToUomoConverterItemProvider.java
@@ -0,0 +1,287 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YNumericToUomoConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YNumericToUomoConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YNumericToUomoConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YNumericToUomoConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YNumericToUomoConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YNumericToUomoConverter_type") :
+			getString("_UI_YNumericToUomoConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YNumericToUomoConverter.class)) {
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__TAGS:
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__ID:
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YObjectToStringConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YObjectToStringConverterItemProvider.java
new file mode 100644
index 0000000..5b4ffe4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YObjectToStringConverterItemProvider.java
@@ -0,0 +1,287 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YObjectToStringConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YObjectToStringConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YObjectToStringConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YObjectToStringConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YObjectToStringConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YObjectToStringConverter_type") :
+			getString("_UI_YObjectToStringConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YObjectToStringConverter.class)) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__TAGS:
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__ID:
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YPriceToStringConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YPriceToStringConverterItemProvider.java
new file mode 100644
index 0000000..26965e0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YPriceToStringConverterItemProvider.java
@@ -0,0 +1,386 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YPriceToStringConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YPriceToStringConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addValuePropertyPathPropertyDescriptor(object);
+			addCurrencyPropertyPathPropertyDescriptor(object);
+			addTypeQualifiedNamePropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Property Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPriceToStringConverter_valuePropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPriceToStringConverter_valuePropertyPath_feature", "_UI_YPriceToStringConverter_type"),
+				 YConverterPackage.Literals.YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Currency Property Path feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addCurrencyPropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPriceToStringConverter_currencyPropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPriceToStringConverter_currencyPropertyPath_feature", "_UI_YPriceToStringConverter_type"),
+				 YConverterPackage.Literals.YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPriceToStringConverter_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPriceToStringConverter_typeQualifiedName_feature", "_UI_YPriceToStringConverter_type"),
+				 YConverterPackage.Literals.YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPriceToStringConverter_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPriceToStringConverter_type_feature", "_UI_YPriceToStringConverter_type"),
+				 YConverterPackage.Literals.YPRICE_TO_STRING_CONVERTER__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YPriceToStringConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YPriceToStringConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YPriceToStringConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YPriceToStringConverter_type") :
+			getString("_UI_YPriceToStringConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YPriceToStringConverter.class)) {
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TAGS:
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__ID:
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__NAME:
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH:
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH:
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME:
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YQuantityToStringConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YQuantityToStringConverterItemProvider.java
new file mode 100644
index 0000000..88d650e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YQuantityToStringConverterItemProvider.java
@@ -0,0 +1,382 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YQuantityToStringConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YQuantityToStringConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addAmountPropertyPathPropertyDescriptor(object);
+			addUomPropertyPathPropertyDescriptor(object);
+			addUomCodeRelativePropertyPathPropertyDescriptor(object);
+			addQuantityTypeQualifiedNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Amount Property Path feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addAmountPropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YQuantityToStringConverter_amountPropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YQuantityToStringConverter_amountPropertyPath_feature", "_UI_YQuantityToStringConverter_type"),
+				 YConverterPackage.Literals.YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Uom Property Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addUomPropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YQuantityToStringConverter_uomPropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YQuantityToStringConverter_uomPropertyPath_feature", "_UI_YQuantityToStringConverter_type"),
+				 YConverterPackage.Literals.YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Uom Code Relative Property Path feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addUomCodeRelativePropertyPathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YQuantityToStringConverter_uomCodeRelativePropertyPath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YQuantityToStringConverter_uomCodeRelativePropertyPath_feature", "_UI_YQuantityToStringConverter_type"),
+				 YConverterPackage.Literals.YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Quantity Type Qualified Name feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addQuantityTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YQuantityToStringConverter_quantityTypeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YQuantityToStringConverter_quantityTypeQualifiedName_feature", "_UI_YQuantityToStringConverter_type"),
+				 YConverterPackage.Literals.YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YQuantityToStringConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YQuantityToStringConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YQuantityToStringConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YQuantityToStringConverter_type") :
+			getString("_UI_YQuantityToStringConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YQuantityToStringConverter.class)) {
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__TAGS:
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__ID:
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__NAME:
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH:
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH:
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH:
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YSimpleDecimalConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YSimpleDecimalConverterItemProvider.java
new file mode 100644
index 0000000..7b812a0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YSimpleDecimalConverterItemProvider.java
@@ -0,0 +1,310 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YSimpleDecimalConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YSimpleDecimalConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addNumberFormatPatternPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Number Format Pattern feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNumberFormatPatternPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSimpleDecimalConverter_numberFormatPattern_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSimpleDecimalConverter_numberFormatPattern_feature", "_UI_YSimpleDecimalConverter_type"),
+				 YConverterPackage.Literals.YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YSimpleDecimalConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YSimpleDecimalConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YSimpleDecimalConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YSimpleDecimalConverter_type") :
+			getString("_UI_YSimpleDecimalConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YSimpleDecimalConverter.class)) {
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__TAGS:
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__ID:
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NAME:
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YStringToResourceConfigItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YStringToResourceConfigItemProvider.java
new file mode 100644
index 0000000..10a21c0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YStringToResourceConfigItemProvider.java
@@ -0,0 +1,246 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YStringToResourceConfigItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YStringToResourceConfigItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValuePropertyDescriptor(object);
+			addComparePropertyDescriptor(object);
+			addResourceThemePathPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YStringToResourceConfig_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YStringToResourceConfig_value_feature", "_UI_YStringToResourceConfig_type"),
+				 YConverterPackage.Literals.YSTRING_TO_RESOURCE_CONFIG__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Compare feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addComparePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YStringToResourceConfig_compare_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YStringToResourceConfig_compare_feature", "_UI_YStringToResourceConfig_type"),
+				 YConverterPackage.Literals.YSTRING_TO_RESOURCE_CONFIG__COMPARE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Resource Theme Path feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addResourceThemePathPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YStringToResourceConfig_resourceThemePath_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YStringToResourceConfig_resourceThemePath_feature", "_UI_YStringToResourceConfig_type"),
+				 YConverterPackage.Literals.YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YStringToResourceConfig.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YStringToResourceConfig"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YStringToResourceConfig)object).getValue();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YStringToResourceConfig_type") :
+			getString("_UI_YStringToResourceConfig_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YStringToResourceConfig.class)) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__VALUE:
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__COMPARE:
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YStringToResourceConverterItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YStringToResourceConverterItemProvider.java
new file mode 100644
index 0000000..cb6df35
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/converter/provider/YStringToResourceConverterItemProvider.java
@@ -0,0 +1,295 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YStringToResourceConverterItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YStringToResourceConverterItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(YConverterPackage.Literals.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YStringToResourceConverter.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YStringToResourceConverter"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YStringToResourceConverter)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YStringToResourceConverter_type") :
+			getString("_UI_YStringToResourceConverter_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YStringToResourceConverter.class)) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__TAGS:
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__ID:
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES:
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YConverterPackage.Literals.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConfig()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YBlobUploadComponentItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YBlobUploadComponentItemProvider.java
new file mode 100644
index 0000000..e6b8405
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YBlobUploadComponentItemProvider.java
@@ -0,0 +1,336 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+import java.util.Collection;
+import java.util.List;
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YBlobUploadComponentItemProvider extends YInputItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YBlobUploadComponentItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+			addDisplayResolutionIdPropertyDescriptor(object);
+			addFirmlyLinkedPropertyDescriptor(object);
+			addUniqueNameEnabledPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YBlobUploadComponent_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YBlobUploadComponent_value_feature", "_UI_YBlobUploadComponent_type"),
+				 YECviewPackage.Literals.YBLOB_UPLOAD_COMPONENT__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Display Resolution Id feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDisplayResolutionIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YBlobUploadComponent_displayResolutionId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YBlobUploadComponent_displayResolutionId_feature", "_UI_YBlobUploadComponent_type"),
+				 YECviewPackage.Literals.YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Firmly Linked feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addFirmlyLinkedPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YBlobUploadComponent_firmlyLinked_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YBlobUploadComponent_firmlyLinked_feature", "_UI_YBlobUploadComponent_type"),
+				 YECviewPackage.Literals.YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Unique Name Enabled feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addUniqueNameEnabledPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YBlobUploadComponent_uniqueNameEnabled_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YBlobUploadComponent_uniqueNameEnabled_feature", "_UI_YBlobUploadComponent_type"),
+				 YECviewPackage.Literals.YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YBlobUploadComponent.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YBlobUploadComponent"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YBlobUploadComponent)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YBlobUploadComponent_type") :
+			getString("_UI_YBlobUploadComponent_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YBlobUploadComponent.class)) {
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE:
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID:
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED:
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YCollectionSuspectItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YCollectionSuspectItemProvider.java
new file mode 100644
index 0000000..335c8e0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YCollectionSuspectItemProvider.java
@@ -0,0 +1,180 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YCollectionSuspect;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YCollectionSuspect} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YCollectionSuspectItemProvider extends YTypedSuspectItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YCollectionSuspectItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(YECviewPackage.Literals.YCOLLECTION_SUSPECT__COLUMNS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YCollectionSuspect.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YCollectionSuspect"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YCollectionSuspect)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YCollectionSuspect_type") :
+			getString("_UI_YCollectionSuspect_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YCollectionSuspect.class)) {
+			case YECviewPackage.YCOLLECTION_SUSPECT__COLUMNS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YCOLLECTION_SUSPECT__COLUMNS,
+				 YECviewFactory.eINSTANCE.createYColumnInfo()));
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YColumnInfoItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YColumnInfoItemProvider.java
new file mode 100644
index 0000000..94549c0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YColumnInfoItemProvider.java
@@ -0,0 +1,317 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YColumnInfo;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YColumnInfo} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YColumnInfoItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YColumnInfoItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+			addTypeQualifiedNamePropertyDescriptor(object);
+			addLabelI18nKeyPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YColumnInfo_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YColumnInfo_name_feature", "_UI_YColumnInfo_type"),
+				 YECviewPackage.Literals.YCOLUMN_INFO__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YColumnInfo_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YColumnInfo_type_feature", "_UI_YColumnInfo_type"),
+				 YECviewPackage.Literals.YCOLUMN_INFO__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YColumnInfo_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YColumnInfo_typeQualifiedName_feature", "_UI_YColumnInfo_type"),
+				 YECviewPackage.Literals.YCOLUMN_INFO__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label I1 8n Key feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelI18nKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YColumnInfo_labelI18nKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YColumnInfo_labelI18nKey_feature", "_UI_YColumnInfo_type"),
+				 YECviewPackage.Literals.YCOLUMN_INFO__LABEL_I1_8N_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(YECviewPackage.Literals.YCOLUMN_INFO__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YColumnInfo.gif. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the image
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YColumnInfo"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YColumnInfo)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YColumnInfo_type") :
+			getString("_UI_YColumnInfo_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YColumnInfo.class)) {
+			case YECviewPackage.YCOLUMN_INFO__NAME:
+			case YECviewPackage.YCOLUMN_INFO__TYPE:
+			case YECviewPackage.YCOLUMN_INFO__TYPE_QUALIFIED_NAME:
+			case YECviewPackage.YCOLUMN_INFO__LABEL_I1_8N_KEY:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YCOLUMN_INFO__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YCOLUMN_INFO__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YContentSensitiveLayoutItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YContentSensitiveLayoutItemProvider.java
new file mode 100644
index 0000000..5c65f21
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YContentSensitiveLayoutItemProvider.java
@@ -0,0 +1,504 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.provider.YLayoutItemProvider;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory;
+import org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout} object.
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ * @generated
+ */
+public class YContentSensitiveLayoutItemProvider extends YLayoutItemProvider {
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YContentSensitiveLayoutItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addSpacingPropertyDescriptor(object);
+			addMarginPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Spacing feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected void addSpacingPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSpacingable_spacing_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSpacingable_spacing_feature", "_UI_YSpacingable_type"),
+				 CoreModelPackage.Literals.YSPACINGABLE__SPACING,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Margin feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected void addMarginPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMarginable_margin_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMarginable_margin_feature", "_UI_YMarginable_type"),
+				 CoreModelPackage.Literals.YMARGINABLE__MARGIN,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YContentSensitiveLayout.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YContentSensitiveLayout"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YContentSensitiveLayout)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YContentSensitiveLayout_type") :
+			getString("_UI_YContentSensitiveLayout_type") + " " + label;
+	}
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YContentSensitiveLayout.class)) {
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING:
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(
+			Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTextDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTextAreaDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYNumericDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYDecimalDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTableDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYCheckBoxDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYComboBoxDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYListDataType()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYOptionsGroupDataType()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYBrowserDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYDateTimeDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTreeDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYProgressBarDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTabSheetDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYMasterDetailDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYGridLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYHorizontalLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYVerticalLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYTable()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYTree()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYOptionsGroup()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYList()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYLabel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYImage()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYBeanReferenceField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYTextArea()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYCheckBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYBrowser()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYDateTime()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYDecimalField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYNumericField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYButton()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYSlider()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYToggleButton()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYProgressBar()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYTabSheet()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYMasterDetail()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYFormLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYTextSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYBooleanSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYNumericSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYReferenceSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYSplitPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYSearchPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYEnumOptionsGroup()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYEnumList()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYEnumComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYCssLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYAbsoluteLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYSuggestTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+				 ExtensionModelFactory.eINSTANCE.createYPasswordField()));
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YCustomDecimalFieldItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YCustomDecimalFieldItemProvider.java
new file mode 100644
index 0000000..34f1a56
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YCustomDecimalFieldItemProvider.java
@@ -0,0 +1,315 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YCustomDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+import java.util.Collection;
+import java.util.List;
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YCustomDecimalFieldItemProvider extends YInputItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YCustomDecimalFieldItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addDatatypePropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datatype feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDatatypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YCustomDecimalField_datatype_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YCustomDecimalField_datatype_feature", "_UI_YCustomDecimalField_type"),
+				 YECviewPackage.Literals.YCUSTOM_DECIMAL_FIELD__DATATYPE,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YCustomDecimalField_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YCustomDecimalField_datadescription_feature", "_UI_YCustomDecimalField_type"),
+				 YECviewPackage.Literals.YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YCustomDecimalField_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YCustomDecimalField_value_feature", "_UI_YCustomDecimalField_type"),
+				 YECviewPackage.Literals.YCUSTOM_DECIMAL_FIELD__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.REAL_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YCustomDecimalField.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YCustomDecimalField"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YCustomDecimalField)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YCustomDecimalField_type") :
+			getString("_UI_YCustomDecimalField_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YCustomDecimalField.class)) {
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDefaultLayoutingStrategyItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDefaultLayoutingStrategyItemProvider.java
new file mode 100644
index 0000000..b7c3369
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDefaultLayoutingStrategyItemProvider.java
@@ -0,0 +1,130 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YDefaultLayoutingStrategyItemProvider extends YLayoutingStrategyItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YDefaultLayoutingStrategyItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns YDefaultLayoutingStrategy.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YDefaultLayoutingStrategy"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YDefaultLayoutingStrategy)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YDefaultLayoutingStrategy_type") :
+			getString("_UI_YDefaultLayoutingStrategy_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDelegatingFocusingStrategyItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDelegatingFocusingStrategyItemProvider.java
new file mode 100644
index 0000000..95a5547
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDelegatingFocusingStrategyItemProvider.java
@@ -0,0 +1,195 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YDelegatingFocusingStrategyItemProvider extends YFocusingStrategyItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YDelegatingFocusingStrategyItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addDelegateStrategyIdPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Delegate Strategy Id feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDelegateStrategyIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YDelegatingFocusingStrategy_delegateStrategyId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YDelegatingFocusingStrategy_delegateStrategyId_feature", "_UI_YDelegatingFocusingStrategy_type"),
+				 YECviewPackage.Literals.YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YDelegatingFocusingStrategy.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YDelegatingFocusingStrategy"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YDelegatingFocusingStrategy)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YDelegatingFocusingStrategy_type") :
+			getString("_UI_YDelegatingFocusingStrategy_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YDelegatingFocusingStrategy.class)) {
+			case YECviewPackage.YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == YECviewPackage.Literals.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION ||
+			childFeature == YECviewPackage.Literals.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDelegatingLayoutingStrategyItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDelegatingLayoutingStrategyItemProvider.java
new file mode 100644
index 0000000..f73867c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YDelegatingLayoutingStrategyItemProvider.java
@@ -0,0 +1,162 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YDelegatingLayoutingStrategyItemProvider extends YLayoutingStrategyItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YDelegatingLayoutingStrategyItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addDelegateStrategyIdPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Delegate Strategy Id feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDelegateStrategyIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YDelegatingLayoutingStrategy_delegateStrategyId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YDelegatingLayoutingStrategy_delegateStrategyId_feature", "_UI_YDelegatingLayoutingStrategy_type"),
+				 YECviewPackage.Literals.YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YDelegatingLayoutingStrategy.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YDelegatingLayoutingStrategy"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YDelegatingLayoutingStrategy)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YDelegatingLayoutingStrategy_type") :
+			getString("_UI_YDelegatingLayoutingStrategy_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YDelegatingLayoutingStrategy.class)) {
+			case YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YECviewItemProviderAdapterFactory.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YECviewItemProviderAdapterFactory.java
new file mode 100644
index 0000000..9cc61be
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YECviewItemProviderAdapterFactory.java
@@ -0,0 +1,1490 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.ResourceLocator;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.edit.command.CommandParameter;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ChildCreationExtenderManager;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YDialog;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.core.util.CoreModelSwitch;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YMasterDetail;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTab;
+import org.eclipse.osbp.ecview.core.extension.model.extension.util.ExtensionModelSwitch;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.util.YECviewAdapterFactory;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support Viewers.
+ * The adapters generated by this factory convert EMF adapter notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}.
+ * The adapters also support Eclipse property sheets.
+ * Note that most of the adapters are shared among multiple instances.
+ * <!-- begin-user-doc --> <!--
+ * end-user-doc -->
+ * @generated
+ */
+public class YECviewItemProviderAdapterFactory extends YECviewAdapterFactory
+		implements ComposeableAdapterFactory, IChangeNotifier, IDisposable,
+		IChildCreationExtender {
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This keeps track of the root adapter factory that delegates to this adapter factory.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement
+	 * {@link org.eclipse.emf.edit.provider.IChangeNotifier}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This helps manage the child creation extenders.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ChildCreationExtenderManager childCreationExtenderManager = new ChildCreationExtenderManager(ecviewEditPlugin.INSTANCE, YECviewPackage.eNS_URI);
+
+	/**
+	 * This keeps track of all the supported types checked by {@link #isFactoryForType isFactoryForType}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 * 
+	 * @generated
+	 */
+	public YECviewItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YStrategyLayoutItemProvider yStrategyLayoutItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYStrategyLayoutAdapter() {
+		if (yStrategyLayoutItemProvider == null) {
+			yStrategyLayoutItemProvider = new YStrategyLayoutItemProvider(this);
+		}
+
+		return yStrategyLayoutItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YLayoutingStrategyItemProvider yLayoutingStrategyItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYLayoutingStrategyAdapter() {
+		if (yLayoutingStrategyItemProvider == null) {
+			yLayoutingStrategyItemProvider = new YLayoutingStrategyItemProvider(this);
+		}
+
+		return yLayoutingStrategyItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YDefaultLayoutingStrategyItemProvider yDefaultLayoutingStrategyItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYDefaultLayoutingStrategyAdapter() {
+		if (yDefaultLayoutingStrategyItemProvider == null) {
+			yDefaultLayoutingStrategyItemProvider = new YDefaultLayoutingStrategyItemProvider(this);
+		}
+
+		return yDefaultLayoutingStrategyItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YFocusingStrategyItemProvider yFocusingStrategyItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYFocusingStrategyAdapter() {
+		if (yFocusingStrategyItemProvider == null) {
+			yFocusingStrategyItemProvider = new YFocusingStrategyItemProvider(this);
+		}
+
+		return yFocusingStrategyItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YDelegatingLayoutingStrategyItemProvider yDelegatingLayoutingStrategyItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYDelegatingLayoutingStrategyAdapter() {
+		if (yDelegatingLayoutingStrategyItemProvider == null) {
+			yDelegatingLayoutingStrategyItemProvider = new YDelegatingLayoutingStrategyItemProvider(this);
+		}
+
+		return yDelegatingLayoutingStrategyItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YDelegatingFocusingStrategyItemProvider yDelegatingFocusingStrategyItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYDelegatingFocusingStrategyAdapter() {
+		if (yDelegatingFocusingStrategyItemProvider == null) {
+			yDelegatingFocusingStrategyItemProvider = new YDelegatingFocusingStrategyItemProvider(this);
+		}
+
+		return yDelegatingFocusingStrategyItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all
+	 * {@link org.eclipse.osbp.ecview.extension.model.YSuspect} instances. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected YSuspectItemProvider ySuspectItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YSuspect}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYSuspectAdapter() {
+		if (ySuspectItemProvider == null) {
+			ySuspectItemProvider = new YSuspectItemProvider(this);
+		}
+
+		return ySuspectItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YTypedSuspectItemProvider yTypedSuspectItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYTypedSuspectAdapter() {
+		if (yTypedSuspectItemProvider == null) {
+			yTypedSuspectItemProvider = new YTypedSuspectItemProvider(this);
+		}
+
+		return yTypedSuspectItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YTypedCompoundSuspectItemProvider yTypedCompoundSuspectItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYTypedCompoundSuspectAdapter() {
+		if (yTypedCompoundSuspectItemProvider == null) {
+			yTypedCompoundSuspectItemProvider = new YTypedCompoundSuspectItemProvider(this);
+		}
+
+		return yTypedCompoundSuspectItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSubTypeBaseSuspectItemProvider ySubTypeBaseSuspectItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createYSubTypeBaseSuspectAdapter() {
+		if (ySubTypeBaseSuspectItemProvider == null) {
+			ySubTypeBaseSuspectItemProvider = new YSubTypeBaseSuspectItemProvider(this);
+		}
+
+		return ySubTypeBaseSuspectItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSubTypeSuspectItemProvider ySubTypeSuspectItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createYSubTypeSuspectAdapter() {
+		if (ySubTypeSuspectItemProvider == null) {
+			ySubTypeSuspectItemProvider = new YSubTypeSuspectItemProvider(this);
+		}
+
+		return ySubTypeSuspectItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YLayoutingInfoItemProvider yLayoutingInfoItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYLayoutingInfoAdapter() {
+		if (yLayoutingInfoItemProvider == null) {
+			yLayoutingInfoItemProvider = new YLayoutingInfoItemProvider(this);
+		}
+
+		return yLayoutingInfoItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSuspectInfoItemProvider ySuspectInfoItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYSuspectInfoAdapter() {
+		if (ySuspectInfoItemProvider == null) {
+			ySuspectInfoItemProvider = new YSuspectInfoItemProvider(this);
+		}
+
+		return ySuspectInfoItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YBlobUploadComponentItemProvider yBlobUploadComponentItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYBlobUploadComponentAdapter() {
+		if (yBlobUploadComponentItemProvider == null) {
+			yBlobUploadComponentItemProvider = new YBlobUploadComponentItemProvider(this);
+		}
+
+		return yBlobUploadComponentItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YCustomDecimalFieldItemProvider yCustomDecimalFieldItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYCustomDecimalFieldAdapter() {
+		if (yCustomDecimalFieldItemProvider == null) {
+			yCustomDecimalFieldItemProvider = new YCustomDecimalFieldItemProvider(this);
+		}
+
+		return yCustomDecimalFieldItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YIconComboBox} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YIconComboBoxItemProvider yIconComboBoxItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YIconComboBox}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYIconComboBoxAdapter() {
+		if (yIconComboBoxItemProvider == null) {
+			yIconComboBoxItemProvider = new YIconComboBoxItemProvider(this);
+		}
+
+		return yIconComboBoxItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YQuantityTextFieldItemProvider yQuantityTextFieldItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYQuantityTextFieldAdapter() {
+		if (yQuantityTextFieldItemProvider == null) {
+			yQuantityTextFieldItemProvider = new YQuantityTextFieldItemProvider(this);
+		}
+
+		return yQuantityTextFieldItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YCollectionSuspect} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YCollectionSuspectItemProvider yCollectionSuspectItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YCollectionSuspect}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYCollectionSuspectAdapter() {
+		if (yCollectionSuspectItemProvider == null) {
+			yCollectionSuspectItemProvider = new YCollectionSuspectItemProvider(this);
+		}
+
+		return yCollectionSuspectItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YColumnInfo} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YColumnInfoItemProvider yColumnInfoItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YColumnInfo}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the adapter
+	 * @generated
+	 */
+	@Override
+	public Adapter createYColumnInfoAdapter() {
+		if (yColumnInfoItemProvider == null) {
+			yColumnInfoItemProvider = new YColumnInfoItemProvider(this);
+		}
+
+		return yColumnInfoItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YContentSensitiveLayoutItemProvider yContentSensitiveLayoutItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYContentSensitiveLayoutAdapter() {
+		if (yContentSensitiveLayoutItemProvider == null) {
+			yContentSensitiveLayoutItemProvider = new YContentSensitiveLayoutItemProvider(this);
+		}
+
+		return yContentSensitiveLayoutItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YRichTextArea} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YRichTextAreaItemProvider yRichTextAreaItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YRichTextArea}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createYRichTextAreaAdapter() {
+		if (yRichTextAreaItemProvider == null) {
+			yRichTextAreaItemProvider = new YRichTextAreaItemProvider(this);
+		}
+
+		return yRichTextAreaItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YMaskedTextFieldItemProvider yMaskedTextFieldItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createYMaskedTextFieldAdapter() {
+		if (yMaskedTextFieldItemProvider == null) {
+			yMaskedTextFieldItemProvider = new YMaskedTextFieldItemProvider(this);
+		}
+
+		return yMaskedTextFieldItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YPrefixedMaskedTextFieldItemProvider yPrefixedMaskedTextFieldItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYPrefixedMaskedTextFieldAdapter() {
+		if (yPrefixedMaskedTextFieldItemProvider == null) {
+			yPrefixedMaskedTextFieldItemProvider = new YPrefixedMaskedTextFieldItemProvider(this);
+		}
+
+		return yPrefixedMaskedTextFieldItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YMaskedNumericFieldItemProvider yMaskedNumericFieldItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createYMaskedNumericFieldAdapter() {
+		if (yMaskedNumericFieldItemProvider == null) {
+			yMaskedNumericFieldItemProvider = new YMaskedNumericFieldItemProvider(this);
+		}
+
+		return yMaskedNumericFieldItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YMaskedDecimalFieldItemProvider yMaskedDecimalFieldItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createYMaskedDecimalFieldAdapter() {
+		if (yMaskedDecimalFieldItemProvider == null) {
+			yMaskedDecimalFieldItemProvider = new YMaskedDecimalFieldItemProvider(this);
+		}
+
+		return yMaskedDecimalFieldItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.YPairComboBox} instances.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YPairComboBoxItemProvider yPairComboBoxItemProvider;
+
+	/**
+	 * This creates an adapter for a
+	 * {@link org.eclipse.osbp.ecview.extension.model.YPairComboBox}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Adapter createYPairComboBoxAdapter() {
+		if (yPairComboBoxItemProvider == null) {
+			yPairComboBoxItemProvider = new YPairComboBoxItemProvider(this);
+		}
+
+		return yPairComboBoxItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the root adapter factory
+	 * @generated
+	 */
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param parentAdapterFactory
+	 *            the new this keeps track of the root adapter factory that
+	 *            delegates to this adapter factory
+	 * @generated
+	 */
+	public void setParentAdapterFactory(
+			ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param type
+	 *            the type
+	 * @return true, if is factory for type
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the adapter.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param type
+	 *            the type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>) || (((Class<?>)type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the child creation extenders
+	 * @generated
+	 */
+	public List<IChildCreationExtender> getChildCreationExtenders() {
+		return childCreationExtenderManager.getChildCreationExtenders();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param editingDomain
+	 *            the editing domain
+	 * @return the new child descriptors
+	 * @generated
+	 */
+	public Collection<?> getNewChildDescriptors(Object object,
+			EditingDomain editingDomain) {
+		return childCreationExtenderManager.getNewChildDescriptors(object, editingDomain);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	public ResourceLocator getResourceLocator() {
+		return childCreationExtenderManager;
+	}
+
+	/**
+	 * This adds a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to
+	 * {@link #parentAdapterFactory}. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param notification
+	 *            the notification
+	 * @generated
+	 */
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void dispose() {
+		if (yStrategyLayoutItemProvider != null) yStrategyLayoutItemProvider.dispose();
+		if (yLayoutingStrategyItemProvider != null) yLayoutingStrategyItemProvider.dispose();
+		if (yDefaultLayoutingStrategyItemProvider != null) yDefaultLayoutingStrategyItemProvider.dispose();
+		if (yFocusingStrategyItemProvider != null) yFocusingStrategyItemProvider.dispose();
+		if (yDelegatingLayoutingStrategyItemProvider != null) yDelegatingLayoutingStrategyItemProvider.dispose();
+		if (yDelegatingFocusingStrategyItemProvider != null) yDelegatingFocusingStrategyItemProvider.dispose();
+		if (ySuspectItemProvider != null) ySuspectItemProvider.dispose();
+		if (yTypedSuspectItemProvider != null) yTypedSuspectItemProvider.dispose();
+		if (yTypedCompoundSuspectItemProvider != null) yTypedCompoundSuspectItemProvider.dispose();
+		if (ySubTypeBaseSuspectItemProvider != null) ySubTypeBaseSuspectItemProvider.dispose();
+		if (ySubTypeSuspectItemProvider != null) ySubTypeSuspectItemProvider.dispose();
+		if (yLayoutingInfoItemProvider != null) yLayoutingInfoItemProvider.dispose();
+		if (ySuspectInfoItemProvider != null) ySuspectInfoItemProvider.dispose();
+		if (yBlobUploadComponentItemProvider != null) yBlobUploadComponentItemProvider.dispose();
+		if (yCustomDecimalFieldItemProvider != null) yCustomDecimalFieldItemProvider.dispose();
+		if (yIconComboBoxItemProvider != null) yIconComboBoxItemProvider.dispose();
+		if (yQuantityTextFieldItemProvider != null) yQuantityTextFieldItemProvider.dispose();
+		if (yCollectionSuspectItemProvider != null) yCollectionSuspectItemProvider.dispose();
+		if (yColumnInfoItemProvider != null) yColumnInfoItemProvider.dispose();
+		if (yContentSensitiveLayoutItemProvider != null) yContentSensitiveLayoutItemProvider.dispose();
+		if (yRichTextAreaItemProvider != null) yRichTextAreaItemProvider.dispose();
+		if (yMaskedTextFieldItemProvider != null) yMaskedTextFieldItemProvider.dispose();
+		if (yPrefixedMaskedTextFieldItemProvider != null) yPrefixedMaskedTextFieldItemProvider.dispose();
+		if (yMaskedNumericFieldItemProvider != null) yMaskedNumericFieldItemProvider.dispose();
+		if (yMaskedDecimalFieldItemProvider != null) yMaskedDecimalFieldItemProvider.dispose();
+		if (yPairComboBoxItemProvider != null) yPairComboBoxItemProvider.dispose();
+	}
+
+	/**
+	 * A child creation extender for the {@link CoreModelPackage}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public static class CoreModelChildCreationExtender implements
+			IChildCreationExtender {
+		/**
+		 * The switch for creating child descriptors specific to each extended class.
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected static class CreationSwitch extends CoreModelSwitch<Object> {
+			/**
+			 * The child descriptors being populated.
+			 * <!-- begin-user-doc -->
+			 * <!-- end-user-doc -->
+			 * @generated
+			 */
+			protected List<Object> newChildDescriptors;
+
+			/**
+			 * The domain in which to create the children.
+			 * <!-- begin-user-doc
+			 * --> <!-- end-user-doc -->
+			 * @generated
+			 */
+			protected EditingDomain editingDomain;
+
+			/**
+			 * Creates the a switch for populating child descriptors in the given domain.
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->
+			 * @generated
+			 */
+			CreationSwitch(List<Object> newChildDescriptors,
+					EditingDomain editingDomain) {
+				this.newChildDescriptors = newChildDescriptors;
+				this.editingDomain = editingDomain;
+			}
+
+			/**
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYLayout(YLayout object) {
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YLAYOUT__ELEMENTS,
+						 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+				return null;
+			}
+
+			/**
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYView(YView object) {
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YVIEW__CONTENT,
+						 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+				return null;
+			}
+
+			/**
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYDialog(YDialog object) {
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(CoreModelPackage.Literals.YDIALOG__CONTENT,
+						 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+				return null;
+			}
+
+			/**
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+			 *
+			 * @param feature
+			 *            the feature
+			 * @param child
+			 *            the child
+			 * @return the command parameter
+			 * @generated
+			 */
+			protected CommandParameter createChildParameter(Object feature,
+					Object child) {
+				return new CommandParameter(null, feature, child);
+			}
+
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @param object
+		 *            the object
+		 * @param editingDomain
+		 *            the editing domain
+		 * @return the new child descriptors
+		 * @generated
+		 */
+		public Collection<Object> getNewChildDescriptors(Object object,
+				EditingDomain editingDomain) {
+			ArrayList<Object> result = new ArrayList<Object>();
+			new CreationSwitch(result, editingDomain).doSwitch((EObject)object);
+			return result;
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @return the resource locator
+		 * @generated
+		 */
+		public ResourceLocator getResourceLocator() {
+			return ecviewEditPlugin.INSTANCE;
+		}
+	}
+
+	/**
+	 * A child creation extender for the {@link ExtensionModelPackage}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public static class ExtensionModelChildCreationExtender implements
+			IChildCreationExtender {
+		/**
+		 * The switch for creating child descriptors specific to each extended class.
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * @generated
+		 */
+		protected static class CreationSwitch extends
+				ExtensionModelSwitch<Object> {
+			/**
+			 * The child descriptors being populated.
+			 * <!-- begin-user-doc -->
+			 * <!-- end-user-doc -->
+			 * @generated
+			 */
+			protected List<Object> newChildDescriptors;
+
+			/**
+			 * The domain in which to create the children.
+			 * <!-- begin-user-doc
+			 * --> <!-- end-user-doc -->
+			 * @generated
+			 */
+			protected EditingDomain editingDomain;
+
+			/**
+			 * Creates the a switch for populating child descriptors in the given domain.
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->
+			 * @generated
+			 */
+			CreationSwitch(List<Object> newChildDescriptors,
+					EditingDomain editingDomain) {
+				this.newChildDescriptors = newChildDescriptors;
+				this.editingDomain = editingDomain;
+			}
+
+			/**
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYTab(YTab object) {
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YTAB__EMBEDDABLE,
+						 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+				return null;
+			}
+
+			/**
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+			 *
+			 * @param object
+			 *            the object
+			 * @return the object
+			 * @generated
+			 */
+			@Override
+			public Object caseYMasterDetail(YMasterDetail object) {
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__MASTER_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+				newChildDescriptors.add
+					(createChildParameter
+						(ExtensionModelPackage.Literals.YMASTER_DETAIL__DETAIL_ELEMENT,
+						 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+				return null;
+			}
+
+			/**
+			 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+			 *
+			 * @param feature
+			 *            the feature
+			 * @param child
+			 *            the child
+			 * @return the command parameter
+			 * @generated
+			 */
+			protected CommandParameter createChildParameter(Object feature,
+					Object child) {
+				return new CommandParameter(null, feature, child);
+			}
+
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @param object
+		 *            the object
+		 * @param editingDomain
+		 *            the editing domain
+		 * @return the new child descriptors
+		 * @generated
+		 */
+		public Collection<Object> getNewChildDescriptors(Object object,
+				EditingDomain editingDomain) {
+			ArrayList<Object> result = new ArrayList<Object>();
+			new CreationSwitch(result, editingDomain).doSwitch((EObject)object);
+			return result;
+		}
+
+		/**
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+		 *
+		 * @return the resource locator
+		 * @generated
+		 */
+		public ResourceLocator getResourceLocator() {
+			return ecviewEditPlugin.INSTANCE;
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YFocusingStrategyItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YFocusingStrategyItemProvider.java
new file mode 100644
index 0000000..56ddea2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YFocusingStrategyItemProvider.java
@@ -0,0 +1,333 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YFocusingStrategyItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YFocusingStrategyItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(YECviewPackage.Literals.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION);
+			childrenFeatures.add(YECviewPackage.Literals.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YFocusingStrategy.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YFocusingStrategy"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YFocusingStrategy)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YFocusingStrategy_type") :
+			getString("_UI_YFocusingStrategy_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YFocusingStrategy.class)) {
+			case YECviewPackage.YFOCUSING_STRATEGY__TAGS:
+			case YECviewPackage.YFOCUSING_STRATEGY__ID:
+			case YECviewPackage.YFOCUSING_STRATEGY__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__PROPERTIES:
+			case YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION:
+			case YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION,
+				 CoreModelFactory.eINSTANCE.createYKeyStrokeDefinition()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION,
+				 CoreModelFactory.eINSTANCE.createYKeyStrokeDefinition()));
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == YECviewPackage.Literals.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION ||
+			childFeature == YECviewPackage.Literals.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YIconComboBoxItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YIconComboBoxItemProvider.java
new file mode 100644
index 0000000..8d0c295
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YIconComboBoxItemProvider.java
@@ -0,0 +1,551 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YIconComboBox;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YIconComboBox} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YIconComboBoxItemProvider extends YInputItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YIconComboBoxItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addCollectionBindingEndpointPropertyDescriptor(object);
+			addSelectionBindingEndpointPropertyDescriptor(object);
+			addUseBeanServicePropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addDatatypePropertyDescriptor(object);
+			addSelectionPropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+			addEmfNsURIPropertyDescriptor(object);
+			addTypeQualifiedNamePropertyDescriptor(object);
+			addCaptionPropertyPropertyDescriptor(object);
+			addImagePropertyPropertyDescriptor(object);
+			addDescriptionPropertyPropertyDescriptor(object);
+			addDescriptionPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Collection Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addCollectionBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YCollectionBindable_collectionBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YCollectionBindable_collectionBindingEndpoint_feature", "_UI_YCollectionBindable_type"),
+				 CoreModelPackage.Literals.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addSelectionBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSelectionBindable_selectionBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSelectionBindable_selectionBindingEndpoint_feature", "_UI_YSelectionBindable_type"),
+				 CoreModelPackage.Literals.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Use Bean Service feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addUseBeanServicePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YBeanServiceConsumer_useBeanService_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YBeanServiceConsumer_useBeanService_feature", "_UI_YBeanServiceConsumer_type"),
+				 ExtensionModelPackage.Literals.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_datadescription_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datatype feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDatatypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_datatype_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_datatype_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__DATATYPE,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addSelectionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_selection_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_selection_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__SELECTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_type_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Emf Ns URI feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addEmfNsURIPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_emfNsURI_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_emfNsURI_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__EMF_NS_URI,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_typeQualifiedName_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Caption Property feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addCaptionPropertyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_captionProperty_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_captionProperty_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__CAPTION_PROPERTY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Image Property feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addImagePropertyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_imageProperty_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_imageProperty_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__IMAGE_PROPERTY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Description Property feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDescriptionPropertyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_descriptionProperty_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_descriptionProperty_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__DESCRIPTION_PROPERTY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Description feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YIconComboBox_description_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YIconComboBox_description_feature", "_UI_YIconComboBox_type"),
+				 YECviewPackage.Literals.YICON_COMBO_BOX__DESCRIPTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YIconComboBox.gif. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the image
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YIconComboBox"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YIconComboBox)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YIconComboBox_type") :
+			getString("_UI_YIconComboBox_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YIconComboBox.class)) {
+			case YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE:
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION:
+			case YECviewPackage.YICON_COMBO_BOX__TYPE:
+			case YECviewPackage.YICON_COMBO_BOX__EMF_NS_URI:
+			case YECviewPackage.YICON_COMBO_BOX__TYPE_QUALIFIED_NAME:
+			case YECviewPackage.YICON_COMBO_BOX__CAPTION_PROPERTY:
+			case YECviewPackage.YICON_COMBO_BOX__IMAGE_PROPERTY:
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION_PROPERTY:
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YLayoutingInfoItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YLayoutingInfoItemProvider.java
new file mode 100644
index 0000000..08b9564
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YLayoutingInfoItemProvider.java
@@ -0,0 +1,610 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.util.ResourceLocator;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+
+/**
+ * This is the item provider adapter for a
+ * {@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo} object. <!--
+ * begin-user-doc --> <!-- end-user-doc -->
+ * 
+ * @generated
+ */
+public class YLayoutingInfoItemProvider extends ItemProviderAdapter implements
+		IEditingDomainItemProvider, IStructuredItemContentProvider,
+		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YLayoutingInfoItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addLayoutPropertyDescriptor(object);
+			addFirstFocusPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Layout feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLayoutPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YLayoutingInfo_layout_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YLayoutingInfo_layout_feature", "_UI_YLayoutingInfo_type"),
+				 YECviewPackage.Literals.YLAYOUTING_INFO__LAYOUT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the First Focus feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addFirstFocusPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YLayoutingInfo_firstFocus_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YLayoutingInfo_firstFocus_feature", "_UI_YLayoutingInfo_type"),
+				 YECviewPackage.Literals.YLAYOUTING_INFO__FIRST_FOCUS,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(
+			Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT);
+			childrenFeatures.add(YECviewPackage.Literals.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YLayoutingInfo.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YLayoutingInfo"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YLayoutingInfo)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YLayoutingInfo_type") :
+			getString("_UI_YLayoutingInfo_type") + " " + label;
+	}
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YLayoutingInfo.class)) {
+			case YECviewPackage.YLAYOUTING_INFO__TAGS:
+			case YECviewPackage.YLAYOUTING_INFO__ID:
+			case YECviewPackage.YLAYOUTING_INFO__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__PROPERTIES:
+			case YECviewPackage.YLAYOUTING_INFO__CONTENT:
+			case YECviewPackage.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(
+			Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYStrategyLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYBlobUploadComponent()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYCustomDecimalField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYIconComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYQuantityTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYContentSensitiveLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYRichTextArea()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYMaskedTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYPrefixedMaskedTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYMaskedNumericField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYMaskedDecimalField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 YECviewFactory.eINSTANCE.createYPairComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 CoreModelFactory.eINSTANCE.createYLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 CoreModelFactory.eINSTANCE.createYHelperLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 CoreModelFactory.eINSTANCE.createYField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 CoreModelFactory.eINSTANCE.createYAction()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYGridLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYHorizontalLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYVerticalLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYTable()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYTree()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYOptionsGroup()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYList()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYLabel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYImage()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYBeanReferenceField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYTextArea()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYCheckBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYBrowser()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYDateTime()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYDecimalField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYNumericField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYButton()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYSlider()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYToggleButton()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYProgressBar()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYTabSheet()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYMasterDetail()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYFormLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYTextSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYBooleanSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYNumericSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYReferenceSearchField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYSplitPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYSearchPanel()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYEnumOptionsGroup()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYEnumList()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYEnumComboBox()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYCssLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYAbsoluteLayout()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYSuggestTextField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__CONTENT,
+				 ExtensionModelFactory.eINSTANCE.createYPasswordField()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS,
+				 YECviewFactory.eINSTANCE.createYSuspectInfo()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YLayoutingStrategyItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YLayoutingStrategyItemProvider.java
new file mode 100644
index 0000000..8213bb7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YLayoutingStrategyItemProvider.java
@@ -0,0 +1,312 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YLayoutingStrategyItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YLayoutingStrategyItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addTriggerPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Trigger feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTriggerPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YLayoutingStrategy_trigger_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YLayoutingStrategy_trigger_feature", "_UI_YLayoutingStrategy_type"),
+				 YECviewPackage.Literals.YLAYOUTING_STRATEGY__TRIGGER,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YLayoutingStrategy.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YLayoutingStrategy"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YLayoutingStrategy)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YLayoutingStrategy_type") :
+			getString("_UI_YLayoutingStrategy_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YLayoutingStrategy.class)) {
+			case YECviewPackage.YLAYOUTING_STRATEGY__TAGS:
+			case YECviewPackage.YLAYOUTING_STRATEGY__ID:
+			case YECviewPackage.YLAYOUTING_STRATEGY__NAME:
+			case YECviewPackage.YLAYOUTING_STRATEGY__TRIGGER:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__PROPERTIES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedDecimalFieldItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedDecimalFieldItemProvider.java
new file mode 100644
index 0000000..a14281d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedDecimalFieldItemProvider.java
@@ -0,0 +1,335 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YMaskedDecimalFieldItemProvider extends YInputItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YMaskedDecimalFieldItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+			addMaskPropertyDescriptor(object);
+			addDecimalSeparatorPropertyDescriptor(object);
+			addGroupingSeparatorPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedDecimalField_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedDecimalField_datadescription_feature", "_UI_YMaskedDecimalField_type"),
+				 YECviewPackage.Literals.YMASKED_DECIMAL_FIELD__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedDecimalField_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedDecimalField_value_feature", "_UI_YMaskedDecimalField_type"),
+				 YECviewPackage.Literals.YMASKED_DECIMAL_FIELD__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Mask feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addMaskPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedDecimalField_mask_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedDecimalField_mask_feature", "_UI_YMaskedDecimalField_type"),
+				 YECviewPackage.Literals.YMASKED_DECIMAL_FIELD__MASK,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Decimal Separator feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDecimalSeparatorPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedDecimalField_decimalSeparator_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedDecimalField_decimalSeparator_feature", "_UI_YMaskedDecimalField_type"),
+				 YECviewPackage.Literals.YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Grouping Separator feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addGroupingSeparatorPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedDecimalField_groupingSeparator_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedDecimalField_groupingSeparator_feature", "_UI_YMaskedDecimalField_type"),
+				 YECviewPackage.Literals.YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YMaskedDecimalField.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YMaskedDecimalField"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YMaskedDecimalField)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YMaskedDecimalField_type") :
+			getString("_UI_YMaskedDecimalField_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YMaskedDecimalField.class)) {
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE:
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__MASK:
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR:
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedNumericFieldItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedNumericFieldItemProvider.java
new file mode 100644
index 0000000..8af9ba7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedNumericFieldItemProvider.java
@@ -0,0 +1,287 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YMaskedNumericField;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YMaskedNumericFieldItemProvider extends YInputItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YMaskedNumericFieldItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+			addMaskPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedNumericField_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedNumericField_datadescription_feature", "_UI_YMaskedNumericField_type"),
+				 YECviewPackage.Literals.YMASKED_NUMERIC_FIELD__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedNumericField_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedNumericField_value_feature", "_UI_YMaskedNumericField_type"),
+				 YECviewPackage.Literals.YMASKED_NUMERIC_FIELD__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Mask feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addMaskPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedNumericField_mask_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedNumericField_mask_feature", "_UI_YMaskedNumericField_type"),
+				 YECviewPackage.Literals.YMASKED_NUMERIC_FIELD__MASK,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YMaskedNumericField.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YMaskedNumericField"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YMaskedNumericField)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YMaskedNumericField_type") :
+			getString("_UI_YMaskedNumericField_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YMaskedNumericField.class)) {
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE:
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__MASK:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedTextFieldItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedTextFieldItemProvider.java
new file mode 100644
index 0000000..ea8d25e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YMaskedTextFieldItemProvider.java
@@ -0,0 +1,287 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YMaskedTextField;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YMaskedTextFieldItemProvider extends YInputItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YMaskedTextFieldItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+			addMaskPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedTextField_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedTextField_datadescription_feature", "_UI_YMaskedTextField_type"),
+				 YECviewPackage.Literals.YMASKED_TEXT_FIELD__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedTextField_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedTextField_value_feature", "_UI_YMaskedTextField_type"),
+				 YECviewPackage.Literals.YMASKED_TEXT_FIELD__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Mask feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addMaskPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YMaskedTextField_mask_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YMaskedTextField_mask_feature", "_UI_YMaskedTextField_type"),
+				 YECviewPackage.Literals.YMASKED_TEXT_FIELD__MASK,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YMaskedTextField.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YMaskedTextField"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YMaskedTextField)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YMaskedTextField_type") :
+			getString("_UI_YMaskedTextField_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YMaskedTextField.class)) {
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE:
+			case YECviewPackage.YMASKED_TEXT_FIELD__MASK:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YPairComboBoxItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YPairComboBoxItemProvider.java
new file mode 100644
index 0000000..0eb699c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YPairComboBoxItemProvider.java
@@ -0,0 +1,527 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YPairComboBox;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YPairComboBox} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YPairComboBoxItemProvider extends YInputItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YPairComboBoxItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addCollectionBindingEndpointPropertyDescriptor(object);
+			addSelectionBindingEndpointPropertyDescriptor(object);
+			addUseBeanServicePropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addDatatypePropertyDescriptor(object);
+			addSelectionPropertyDescriptor(object);
+			addCollectionPropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+			addEmfNsURIPropertyDescriptor(object);
+			addTypeQualifiedNamePropertyDescriptor(object);
+			addCaptionPropertyPropertyDescriptor(object);
+			addImagePropertyPropertyDescriptor(object);
+			addDescriptionPropertyPropertyDescriptor(object);
+			addDescriptionPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Collection Binding Endpoint feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addCollectionBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YCollectionBindable_collectionBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YCollectionBindable_collectionBindingEndpoint_feature", "_UI_YCollectionBindable_type"),
+				 CoreModelPackage.Literals.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection Binding Endpoint feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addSelectionBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSelectionBindable_selectionBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSelectionBindable_selectionBindingEndpoint_feature", "_UI_YSelectionBindable_type"),
+				 CoreModelPackage.Literals.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Use Bean Service feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addUseBeanServicePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YBeanServiceConsumer_useBeanService_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YBeanServiceConsumer_useBeanService_feature", "_UI_YBeanServiceConsumer_type"),
+				 ExtensionModelPackage.Literals.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_datadescription_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datatype feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDatatypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_datatype_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_datatype_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__DATATYPE,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Selection feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addSelectionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_selection_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_selection_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__SELECTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Collection feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addCollectionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_collection_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_collection_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__COLLECTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_type_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Emf Ns URI feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addEmfNsURIPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_emfNsURI_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_emfNsURI_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__EMF_NS_URI,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_typeQualifiedName_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Caption Property feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addCaptionPropertyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_captionProperty_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_captionProperty_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__CAPTION_PROPERTY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Image Property feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addImagePropertyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_imageProperty_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_imageProperty_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__IMAGE_PROPERTY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Description Property feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDescriptionPropertyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_descriptionProperty_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_descriptionProperty_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Description feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPairComboBox_description_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPairComboBox_description_feature", "_UI_YPairComboBox_type"),
+				 YECviewPackage.Literals.YPAIR_COMBO_BOX__DESCRIPTION,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YPairComboBox.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YPairComboBox"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YPairComboBox)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YPairComboBox_type") :
+			getString("_UI_YPairComboBox_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YPairComboBox.class)) {
+			case YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE:
+			case YECviewPackage.YPAIR_COMBO_BOX__SELECTION:
+			case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION:
+			case YECviewPackage.YPAIR_COMBO_BOX__TYPE:
+			case YECviewPackage.YPAIR_COMBO_BOX__EMF_NS_URI:
+			case YECviewPackage.YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME:
+			case YECviewPackage.YPAIR_COMBO_BOX__CAPTION_PROPERTY:
+			case YECviewPackage.YPAIR_COMBO_BOX__IMAGE_PROPERTY:
+			case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY:
+			case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YPrefixedMaskedTextFieldItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YPrefixedMaskedTextFieldItemProvider.java
new file mode 100644
index 0000000..4c73052
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YPrefixedMaskedTextFieldItemProvider.java
@@ -0,0 +1,330 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YPrefixedMaskedTextFieldItemProvider extends YInputItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YPrefixedMaskedTextFieldItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+			addMaskPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPrefixedMaskedTextField_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPrefixedMaskedTextField_datadescription_feature", "_UI_YPrefixedMaskedTextField_type"),
+				 YECviewPackage.Literals.YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPrefixedMaskedTextField_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPrefixedMaskedTextField_value_feature", "_UI_YPrefixedMaskedTextField_type"),
+				 YECviewPackage.Literals.YPREFIXED_MASKED_TEXT_FIELD__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Mask feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addMaskPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YPrefixedMaskedTextField_mask_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YPrefixedMaskedTextField_mask_feature", "_UI_YPrefixedMaskedTextField_type"),
+				 YECviewPackage.Literals.YPREFIXED_MASKED_TEXT_FIELD__MASK,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(YECviewPackage.Literals.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YPrefixedMaskedTextField.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YPrefixedMaskedTextField"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YPrefixedMaskedTextField)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YPrefixedMaskedTextField_type") :
+			getString("_UI_YPrefixedMaskedTextField_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YPrefixedMaskedTextField.class)) {
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE:
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__MASK:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+	}
+
+	/**
+	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YELEMENT__PROPERTIES ||
+			childFeature == YECviewPackage.Literals.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES ||
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YQuantityTextFieldItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YQuantityTextFieldItemProvider.java
new file mode 100644
index 0000000..07eba88
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YQuantityTextFieldItemProvider.java
@@ -0,0 +1,290 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YQuantityTextField;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+import java.util.Collection;
+import java.util.List;
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YQuantityTextFieldItemProvider extends YInputItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YQuantityTextFieldItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YQuantityTextField_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YQuantityTextField_datadescription_feature", "_UI_YQuantityTextField_type"),
+				 YECviewPackage.Literals.YQUANTITY_TEXT_FIELD__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YQuantityTextField_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YQuantityTextField_value_feature", "_UI_YQuantityTextField_type"),
+				 YECviewPackage.Literals.YQUANTITY_TEXT_FIELD__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YQuantityTextField.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YQuantityTextField"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YQuantityTextField)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YQuantityTextField_type") :
+			getString("_UI_YQuantityTextField_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YQuantityTextField.class)) {
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YRichTextAreaItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YRichTextAreaItemProvider.java
new file mode 100644
index 0000000..e8a58e0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YRichTextAreaItemProvider.java
@@ -0,0 +1,311 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.provider.YInputItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YRichTextArea;
+
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YRichTextArea} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YRichTextAreaItemProvider extends YInputItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YRichTextAreaItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValueBindingEndpointPropertyDescriptor(object);
+			addDatadescriptionPropertyDescriptor(object);
+			addBlobValuePropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+			addUseBlobPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value Binding Endpoint feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValueBindingEndpointPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YValueBindable_valueBindingEndpoint_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YValueBindable_valueBindingEndpoint_feature", "_UI_YValueBindable_type"),
+				 CoreModelPackage.Literals.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Datadescription feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDatadescriptionPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YRichTextArea_datadescription_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YRichTextArea_datadescription_feature", "_UI_YRichTextArea_type"),
+				 YECviewPackage.Literals.YRICH_TEXT_AREA__DATADESCRIPTION,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Blob Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addBlobValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YRichTextArea_blobValue_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YRichTextArea_blobValue_feature", "_UI_YRichTextArea_type"),
+				 YECviewPackage.Literals.YRICH_TEXT_AREA__BLOB_VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YRichTextArea_value_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YRichTextArea_value_feature", "_UI_YRichTextArea_type"),
+				 YECviewPackage.Literals.YRICH_TEXT_AREA__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Use Blob feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addUseBlobPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YRichTextArea_useBlob_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YRichTextArea_useBlob_feature", "_UI_YRichTextArea_type"),
+				 YECviewPackage.Literals.YRICH_TEXT_AREA__USE_BLOB,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YRichTextArea.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YRichTextArea"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YRichTextArea)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YRichTextArea_type") :
+			getString("_UI_YRichTextArea_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YRichTextArea.class)) {
+			case YECviewPackage.YRICH_TEXT_AREA__BLOB_VALUE:
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE:
+			case YECviewPackage.YRICH_TEXT_AREA__USE_BLOB:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYObjectToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYCustomDecimalConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYStringToResourceConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYPriceToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYQuantityToStringConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYNumericToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYDecimalToUomoConverter()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YFIELD__CONVERTER,
+				 YConverterFactory.eINSTANCE.createYSimpleDecimalConverter()));
+	}
+
+	/**
+	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == CoreModelPackage.Literals.YFIELD__VALIDATORS ||
+			childFeature == CoreModelPackage.Literals.YFIELD__INTERNAL_VALIDATORS;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YStrategyLayoutItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YStrategyLayoutItemProvider.java
new file mode 100644
index 0000000..cdc8194
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YStrategyLayoutItemProvider.java
@@ -0,0 +1,342 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+import java.util.Collection;
+import java.util.List;
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.provider.YEmbeddableItemProvider;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YStrategyLayoutItemProvider extends YEmbeddableItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YStrategyLayoutItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addDefaultFocusingEnhancerIdPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Default Focusing Enhancer Id feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addDefaultFocusingEnhancerIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YStrategyLayout_defaultFocusingEnhancerId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YStrategyLayout_defaultFocusingEnhancerId_feature", "_UI_YStrategyLayout_type"),
+				 YECviewPackage.Literals.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(YECviewPackage.Literals.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY);
+			childrenFeatures.add(YECviewPackage.Literals.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES);
+			childrenFeatures.add(YECviewPackage.Literals.YSTRATEGY_LAYOUT__SUSPECTS);
+			childrenFeatures.add(YECviewPackage.Literals.YSTRATEGY_LAYOUT__LAYOUTING_INFO);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YStrategyLayout.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YStrategyLayout"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YStrategyLayout)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YStrategyLayout_type") :
+			getString("_UI_YStrategyLayout_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YStrategyLayout.class)) {
+			case YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
+			case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
+			case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTextDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTextAreaDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYNumericDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYDecimalDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTableDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYCheckBoxDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYComboBoxDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYListDataType()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYOptionsGroupDataType()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYBrowserDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYDateTimeDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTreeDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYProgressBarDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYTabSheetDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YEMBEDDABLE__ORPHAN_DATATYPES,
+				 ExtDatatypesFactory.eINSTANCE.createYMasterDetailDatatype()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY,
+				 YECviewFactory.eINSTANCE.createYLayoutingStrategy()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY,
+				 YECviewFactory.eINSTANCE.createYDefaultLayoutingStrategy()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY,
+				 YECviewFactory.eINSTANCE.createYDelegatingLayoutingStrategy()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES,
+				 YECviewFactory.eINSTANCE.createYFocusingStrategy()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES,
+				 YECviewFactory.eINSTANCE.createYDelegatingFocusingStrategy()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__SUSPECTS,
+				 YECviewFactory.eINSTANCE.createYSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__SUSPECTS,
+				 YECviewFactory.eINSTANCE.createYTypedSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__SUSPECTS,
+				 YECviewFactory.eINSTANCE.createYTypedCompoundSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__SUSPECTS,
+				 YECviewFactory.eINSTANCE.createYSubTypeBaseSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__SUSPECTS,
+				 YECviewFactory.eINSTANCE.createYSubTypeSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__SUSPECTS,
+				 YECviewFactory.eINSTANCE.createYCollectionSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSTRATEGY_LAYOUT__LAYOUTING_INFO,
+				 YECviewFactory.eINSTANCE.createYLayoutingInfo()));
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSubTypeBaseSuspectItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSubTypeBaseSuspectItemProvider.java
new file mode 100644
index 0000000..1508aae
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSubTypeBaseSuspectItemProvider.java
@@ -0,0 +1,117 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YSubTypeBaseSuspectItemProvider extends YTypedCompoundSuspectItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YSubTypeBaseSuspectItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns YSubTypeBaseSuspect.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YSubTypeBaseSuspect"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YSubTypeBaseSuspect)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YSubTypeBaseSuspect_type") :
+			getString("_UI_YSubTypeBaseSuspect_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSubTypeSuspectItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSubTypeSuspectItemProvider.java
new file mode 100644
index 0000000..da61308
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSubTypeSuspectItemProvider.java
@@ -0,0 +1,142 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YSubTypeSuspectItemProvider extends YTypedCompoundSuspectItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YSubTypeSuspectItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addBeanSlotPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Bean Slot feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addBeanSlotPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSubTypeSuspect_beanSlot_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSubTypeSuspect_beanSlot_feature", "_UI_YSubTypeSuspect_type"),
+				 YECviewPackage.Literals.YSUB_TYPE_SUSPECT__BEAN_SLOT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YSubTypeSuspect.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YSubTypeSuspect"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YSubTypeSuspect)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YSubTypeSuspect_type") :
+			getString("_UI_YSubTypeSuspect_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectInfoItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectInfoItemProvider.java
new file mode 100644
index 0000000..a867445
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectInfoItemProvider.java
@@ -0,0 +1,422 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityFactory;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.BindingFactory;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.visibility.VisibilityFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YSuspectInfoItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YSuspectInfoItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addSuspectPropertyDescriptor(object);
+			addNextFocusPropertyDescriptor(object);
+			addPreviousFocusPropertyDescriptor(object);
+			addTargetPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Suspect feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addSuspectPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspectInfo_suspect_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspectInfo_suspect_feature", "_UI_YSuspectInfo_type"),
+				 YECviewPackage.Literals.YSUSPECT_INFO__SUSPECT,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Next Focus feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addNextFocusPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspectInfo_nextFocus_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspectInfo_nextFocus_feature", "_UI_YSuspectInfo_type"),
+				 YECviewPackage.Literals.YSUSPECT_INFO__NEXT_FOCUS,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Previous Focus feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addPreviousFocusPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspectInfo_previousFocus_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspectInfo_previousFocus_feature", "_UI_YSuspectInfo_type"),
+				 YECviewPackage.Literals.YSUSPECT_INFO__PREVIOUS_FOCUS,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Target feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTargetPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspectInfo_target_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspectInfo_target_feature", "_UI_YSuspectInfo_type"),
+				 YECviewPackage.Literals.YSUSPECT_INFO__TARGET,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(YECviewPackage.Literals.YSUSPECT_INFO__BINDINGS);
+			childrenFeatures.add(YECviewPackage.Literals.YSUSPECT_INFO__VISIBILITY_PROCESSORS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YSuspectInfo.gif. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the image
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YSuspectInfo"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YSuspectInfo)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YSuspectInfo_type") :
+			getString("_UI_YSuspectInfo_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YSuspectInfo.class)) {
+			case YECviewPackage.YSUSPECT_INFO__TAGS:
+			case YECviewPackage.YSUSPECT_INFO__ID:
+			case YECviewPackage.YSUSPECT_INFO__NAME:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YSUSPECT_INFO__PROPERTIES:
+			case YECviewPackage.YSUSPECT_INFO__BINDINGS:
+			case YECviewPackage.YSUSPECT_INFO__VISIBILITY_PROCESSORS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT_INFO__BINDINGS,
+				 BindingFactory.eINSTANCE.createYValueBinding()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT_INFO__BINDINGS,
+				 BindingFactory.eINSTANCE.createYListBinding()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT_INFO__VISIBILITY_PROCESSORS,
+				 YVisibilityFactory.eINSTANCE.createYAuthorizationVisibilityProcessor()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT_INFO__VISIBILITY_PROCESSORS,
+				 YVisibilityFactory.eINSTANCE.createYSubTypeVisibilityProcessor()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT_INFO__VISIBILITY_PROCESSORS,
+				 VisibilityFactory.eINSTANCE.createYVisibilityProcessor()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectItemProvider.java
new file mode 100644
index 0000000..41a452b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectItemProvider.java
@@ -0,0 +1,583 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityFactory;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IChildCreationExtender;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.BindingFactory;
+
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+import org.eclipse.osbp.ecview.core.common.model.visibility.VisibilityFactory;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YSuspect} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YSuspectItemProvider 
+	extends ItemProviderAdapter
+	implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YSuspectItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTagsPropertyDescriptor(object);
+			addIdPropertyDescriptor(object);
+			addNamePropertyDescriptor(object);
+			addAuthorizationGroupPropertyDescriptor(object);
+			addAuthorizationIdPropertyDescriptor(object);
+			addLabelI18nKeyPropertyDescriptor(object);
+			addImageI18nKeyPropertyDescriptor(object);
+			addAssocNewiatedElementsPropertyDescriptor(object);
+			addLabelPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Id feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_id_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_id_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YElement_name_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YElement_name_feature", "_UI_YElement_type"),
+				 CoreModelPackage.Literals.YELEMENT__NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Tags feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTagsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTaggable_tags_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTaggable_tags_feature", "_UI_YTaggable_type"),
+				 CoreModelPackage.Literals.YTAGGABLE__TAGS,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Authorization Group feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addAuthorizationGroupPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YAuthorizationable_authorizationGroup_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YAuthorizationable_authorizationGroup_feature", "_UI_YAuthorizationable_type"),
+				 CoreModelPackage.Literals.YAUTHORIZATIONABLE__AUTHORIZATION_GROUP,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Authorization Id feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addAuthorizationIdPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YAuthorizationable_authorizationId_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YAuthorizationable_authorizationId_feature", "_UI_YAuthorizationable_type"),
+				 CoreModelPackage.Literals.YAUTHORIZATIONABLE__AUTHORIZATION_ID,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label I1 8n Key feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelI18nKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspect_labelI18nKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspect_labelI18nKey_feature", "_UI_YSuspect_type"),
+				 YECviewPackage.Literals.YSUSPECT__LABEL_I1_8N_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Image I1 8n Key feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addImageI18nKeyPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspect_imageI18nKey_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspect_imageI18nKey_feature", "_UI_YSuspect_type"),
+				 YECviewPackage.Literals.YSUSPECT__IMAGE_I1_8N_KEY,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Assoc Newiated Elements feature.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addAssocNewiatedElementsPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspect_assocNewiatedElements_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspect_assocNewiatedElements_feature", "_UI_YSuspect_type"),
+				 YECviewPackage.Literals.YSUSPECT__ASSOC_NEWIATED_ELEMENTS,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Label feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addLabelPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspect_label_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspect_label_feature", "_UI_YSuspect_type"),
+				 YECviewPackage.Literals.YSUSPECT__LABEL,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(CoreModelPackage.Literals.YELEMENT__PROPERTIES);
+			childrenFeatures.add(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS);
+			childrenFeatures.add(YECviewPackage.Literals.YSUSPECT__VISIBILITY_PROCESSORS);
+			childrenFeatures.add(YECviewPackage.Literals.YSUSPECT__COMMANDS);
+			childrenFeatures.add(YECviewPackage.Literals.YSUSPECT__ASSOCIATED_BINDINGS);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YSuspect.gif.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YSuspect"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YSuspect)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YSuspect_type") :
+			getString("_UI_YSuspect_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YSuspect.class)) {
+			case YECviewPackage.YSUSPECT__TAGS:
+			case YECviewPackage.YSUSPECT__ID:
+			case YECviewPackage.YSUSPECT__NAME:
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP:
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_ID:
+			case YECviewPackage.YSUSPECT__LABEL_I1_8N_KEY:
+			case YECviewPackage.YSUSPECT__IMAGE_I1_8N_KEY:
+			case YECviewPackage.YSUSPECT__LABEL:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+			case YECviewPackage.YSUSPECT__PROPERTIES:
+			case YECviewPackage.YSUSPECT__VALUE_BINDING_ENDPOINTS:
+			case YECviewPackage.YSUSPECT__VISIBILITY_PROCESSORS:
+			case YECviewPackage.YSUSPECT__COMMANDS:
+			case YECviewPackage.YSUSPECT__ASSOCIATED_BINDINGS:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(CoreModelPackage.Literals.YELEMENT__PROPERTIES,
+				 CoreModelFactory.eINSTANCE.create(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP)));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYBeanValueBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYDetailValueBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYEnumListBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYECViewModelValueBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYECViewModelListBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYVisibilityProcessorValueBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYNoOpValueBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 BindingFactory.eINSTANCE.createYNoOpListBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYContextValueBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYBeanSlotValueBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYBeanSlotListBindingEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYEmbeddableValueEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYEmbeddableSelectionEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYEmbeddableMultiSelectionEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYEmbeddableCollectionEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VALUE_BINDING_ENDPOINTS,
+				 CoreModelFactory.eINSTANCE.createYActivatedEndpoint()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VISIBILITY_PROCESSORS,
+				 YVisibilityFactory.eINSTANCE.createYAuthorizationVisibilityProcessor()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VISIBILITY_PROCESSORS,
+				 YVisibilityFactory.eINSTANCE.createYSubTypeVisibilityProcessor()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__VISIBILITY_PROCESSORS,
+				 VisibilityFactory.eINSTANCE.createYVisibilityProcessor()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__COMMANDS,
+				 CoreModelFactory.eINSTANCE.createYOpenDialogCommand()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__COMMANDS,
+				 CoreModelFactory.eINSTANCE.createYSendEventCommand()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__COMMANDS,
+				 ExtensionModelFactory.eINSTANCE.createYAddToTableCommand()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__COMMANDS,
+				 ExtensionModelFactory.eINSTANCE.createYRemoveFromTableCommand()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__COMMANDS,
+				 ExtensionModelFactory.eINSTANCE.createYSetNewBeanInstanceCommand()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__ASSOCIATED_BINDINGS,
+				 BindingFactory.eINSTANCE.createYValueBinding()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YSUSPECT__ASSOCIATED_BINDINGS,
+				 BindingFactory.eINSTANCE.createYListBinding()));
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ((IChildCreationExtender)adapterFactory).getResourceLocator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YTypedCompoundSuspectItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YTypedCompoundSuspectItemProvider.java
new file mode 100644
index 0000000..d7df33d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YTypedCompoundSuspectItemProvider.java
@@ -0,0 +1,205 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YTypedCompoundSuspectItemProvider extends YTypedSuspectItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YTypedCompoundSuspectItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT__CHILDREN);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param child
+	 *            the child
+	 * @return the child feature
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
+	 * This returns YTypedCompoundSuspect.gif.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YTypedCompoundSuspect"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YTypedCompoundSuspect)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YTypedCompoundSuspect_type") :
+			getString("_UI_YTypedCompoundSuspect_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YTypedCompoundSuspect.class)) {
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT__CHILDREN:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT__CHILDREN,
+				 YECviewFactory.eINSTANCE.createYSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT__CHILDREN,
+				 YECviewFactory.eINSTANCE.createYTypedSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT__CHILDREN,
+				 YECviewFactory.eINSTANCE.createYTypedCompoundSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT__CHILDREN,
+				 YECviewFactory.eINSTANCE.createYSubTypeBaseSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT__CHILDREN,
+				 YECviewFactory.eINSTANCE.createYSubTypeSuspect()));
+
+		newChildDescriptors.add
+			(createChildParameter
+				(YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT__CHILDREN,
+				 YECviewFactory.eINSTANCE.createYCollectionSuspect()));
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YTypedSuspectItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YTypedSuspectItemProvider.java
new file mode 100644
index 0000000..4460829
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YTypedSuspectItemProvider.java
@@ -0,0 +1,192 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YTypedSuspect;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YTypedSuspectItemProvider extends YSuspectItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YTypedSuspectItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTypeQualifiedNamePropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTypedSuspect_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTypedSuspect_typeQualifiedName_feature", "_UI_YTypedSuspect_type"),
+				 YECviewPackage.Literals.YTYPED_SUSPECT__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YTypedSuspect_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YTypedSuspect_type_feature", "_UI_YTypedSuspect_type"),
+				 YECviewPackage.Literals.YTYPED_SUSPECT__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YTypedSuspect.gif. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the image
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YTypedSuspect"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YTypedSuspect)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YTypedSuspect_type") :
+			getString("_UI_YTypedSuspect_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YTypedSuspect.class)) {
+			case YECviewPackage.YTYPED_SUSPECT__TYPE_QUALIFIED_NAME:
+			case YECviewPackage.YTYPED_SUSPECT__TYPE:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/ecviewEditPlugin.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/ecviewEditPlugin.java
new file mode 100644
index 0000000..f7dfef8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/ecviewEditPlugin.java
@@ -0,0 +1,118 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.provider;
+
+import org.eclipse.emf.common.EMFPlugin;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.xtext.common.types.provider.TypesEditPlugin;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.provider.ECViewCoreEditPlugin;
+
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.provider.ExtensionEditPlugin;
+
+/**
+ * This is the central singleton for the ecview edit plugin.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public final class ecviewEditPlugin extends EMFPlugin {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final ecviewEditPlugin INSTANCE = new ecviewEditPlugin();
+
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static Implementation plugin;
+
+	/**
+	 * Create the instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ecviewEditPlugin() {
+		super
+		  (new ResourceLocator [] {
+		     ECViewCoreEditPlugin.INSTANCE,
+		     ExtensionEditPlugin.INSTANCE,
+		     TypesEditPlugin.INSTANCE,
+		   });
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getPluginResourceLocator() {
+		return plugin;
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	public static Implementation getPlugin() {
+		return plugin;
+	}
+
+	/**
+	 * The actual implementation of the Eclipse <b>Plugin</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static class Implementation extends EclipsePlugin {
+		/**
+		 * Creates an instance.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		public Implementation() {
+			super();
+
+			// Remember the static instance.
+			//
+			plugin = this;
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YAuthorizationVisibilityProcessorItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YAuthorizationVisibilityProcessorItemProvider.java
new file mode 100644
index 0000000..12470a2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YAuthorizationVisibilityProcessorItemProvider.java
@@ -0,0 +1,183 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility.provider;
+
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.osbp.ecview.core.common.model.visibility.VisibilityPackage;
+
+import org.eclipse.osbp.ecview.core.common.model.visibility.provider.YVisibilityProcessorItemProvider;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YAuthorizationVisibilityProcessorItemProvider extends YVisibilityProcessorItemProvider {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+=======
+>>>>>>> branch 'development' of ssh://lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+	 * This constructs an instance from a factory and a notifier. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param adapterFactory
+	 *            the adapter factory
+	 * @generated
+	 */
+	public YAuthorizationVisibilityProcessorItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the object
+	 * @return the property descriptors
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns YAuthorizationVisibilityProcessor.gif.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YAuthorizationVisibilityProcessor"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YAuthorizationVisibilityProcessor)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YAuthorizationVisibilityProcessor_type") :
+			getString("_UI_YAuthorizationVisibilityProcessor_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s
+	 * describing the children that can be created under this object. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param newChildDescriptors
+	 *            the new child descriptors
+	 * @param object
+	 *            the object
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * This returns the label text for
+	 * {@link org.eclipse.emf.edit.command.CreateChildCommand}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param owner
+	 *            the owner
+	 * @param feature
+	 *            the feature
+	 * @param child
+	 *            the child
+	 * @param selection
+	 *            the selection
+	 * @return the creates the child text
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == VisibilityPackage.Literals.YVISIBILITY_PROCESSOR__DATA_USED ||
+			childFeature == VisibilityPackage.Literals.YVISIBILITY_PROCESSOR__TRIGGERS_ON;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the resource locator
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YSubTypeVisibilityProcessorItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YSubTypeVisibilityProcessorItemProvider.java
new file mode 100644
index 0000000..bf2a2a9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YSubTypeVisibilityProcessorItemProvider.java
@@ -0,0 +1,239 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.visibility.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.osbp.ecview.core.common.model.visibility.VisibilityPackage;
+
+import org.eclipse.osbp.ecview.core.common.model.visibility.provider.YVisibilityProcessorItemProvider;
+
+import org.eclipse.osbp.ecview.extension.model.provider.ecviewEditPlugin;
+
+import org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YSubTypeVisibilityProcessorItemProvider extends YVisibilityProcessorItemProvider {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YSubTypeVisibilityProcessorItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addTypeQualifiedNamePropertyDescriptor(object);
+			addTypePropertyDescriptor(object);
+			addTargetPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Type Qualified Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypeQualifiedNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSubTypeVisibilityProcessor_typeQualifiedName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSubTypeVisibilityProcessor_typeQualifiedName_feature", "_UI_YSubTypeVisibilityProcessor_type"),
+				 YVisibilityPackage.Literals.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Type feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTypePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSubTypeVisibilityProcessor_type_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSubTypeVisibilityProcessor_type_feature", "_UI_YSubTypeVisibilityProcessor_type"),
+				 YVisibilityPackage.Literals.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Target feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addTargetPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSubTypeVisibilityProcessor_target_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSubTypeVisibilityProcessor_target_feature", "_UI_YSubTypeVisibilityProcessor_type"),
+				 YVisibilityPackage.Literals.YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET,
+				 true,
+				 false,
+				 true,
+				 null,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns YSubTypeVisibilityProcessor.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/YSubTypeVisibilityProcessor"));
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((YSubTypeVisibilityProcessor)object).getName();
+		return label == null || label.length() == 0 ?
+			getString("_UI_YSubTypeVisibilityProcessor_type") :
+			getString("_UI_YSubTypeVisibilityProcessor_type") + " " + label;
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(YSubTypeVisibilityProcessor.class)) {
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME:
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreateChildText(Object owner, Object feature, Object child, Collection<?> selection) {
+		Object childFeature = feature;
+		Object childObject = child;
+
+		boolean qualify =
+			childFeature == VisibilityPackage.Literals.YVISIBILITY_PROCESSOR__DATA_USED ||
+			childFeature == VisibilityPackage.Literals.YVISIBILITY_PROCESSOR__TRIGGERS_ON;
+
+		if (qualify) {
+			return getString
+				("_UI_CreateChild_text2",
+				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
+		}
+		return super.getCreateChildText(owner, feature, child, selection);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return ecviewEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YVisibilityItemProviderAdapterFactory.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YVisibilityItemProviderAdapterFactory.java
new file mode 100644
index 0000000..e1f91f1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/visibility/provider/YVisibilityItemProviderAdapterFactory.java
@@ -0,0 +1,254 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility.provider;
+
+import org.eclipse.osbp.ecview.extension.model.visibility.util.YVisibilityAdapterFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support Viewers.
+ * The adapters generated by this factory convert EMF adapter notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}.
+ * The adapters also support Eclipse property sheets.
+ * Note that most of the adapters are shared among multiple instances.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YVisibilityItemProviderAdapterFactory extends YVisibilityAdapterFactory implements ComposeableAdapterFactory, IChangeNotifier, IDisposable {
+	
+	/**
+<<<<<<< HEAD
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * This keeps track of the root adapter factory that delegates to this adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement {@link org.eclipse.emf.edit.provider.IChangeNotifier}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This keeps track of all the supported types checked by {@link #isFactoryForType isFactoryForType}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YVisibilityItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YAuthorizationVisibilityProcessorItemProvider yAuthorizationVisibilityProcessorItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor}.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYAuthorizationVisibilityProcessorAdapter() {
+		if (yAuthorizationVisibilityProcessorItemProvider == null) {
+			yAuthorizationVisibilityProcessorItemProvider = new YAuthorizationVisibilityProcessorItemProvider(this);
+		}
+
+		return yAuthorizationVisibilityProcessorItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSubTypeVisibilityProcessorItemProvider ySubTypeVisibilityProcessorItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createYSubTypeVisibilityProcessorAdapter() {
+		if (ySubTypeVisibilityProcessorItemProvider == null) {
+			ySubTypeVisibilityProcessorItemProvider = new YSubTypeVisibilityProcessorItemProvider(this);
+		}
+
+		return ySubTypeVisibilityProcessorItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the root adapter factory
+	 * @generated
+	 */
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param parentAdapterFactory
+	 *            the new this keeps track of the root adapter factory that
+	 *            delegates to this adapter factory
+	 * @generated
+	 */
+	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param type
+	 *            the type
+	 * @return true, if is factory for type
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the adapter.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param object
+	 *            the object
+	 * @param type
+	 *            the type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>) || (((Class<?>)type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * This adds a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to
+	 * {@link #parentAdapterFactory}. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 *
+	 * @param notification
+	 *            the notification
+	 * @generated
+	 */
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory. 
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void dispose() {
+		if (yAuthorizationVisibilityProcessorItemProvider != null) yAuthorizationVisibilityProcessorItemProvider.dispose();
+		if (ySubTypeVisibilityProcessorItemProvider != null) ySubTypeVisibilityProcessorItemProvider.dispose();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/.project b/org.eclipse.osbp.ecview.extension.model/.project
new file mode 100644
index 0000000..52bcca0
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/.project
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.ecview.extension.model</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.ecview.extension.model/LICENSE.txt b/org.eclipse.osbp.ecview.extension.model/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model/META-INF/MANIFEST.MF b/org.eclipse.osbp.ecview.extension.model/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..a5cc85d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/META-INF/MANIFEST.MF
@@ -0,0 +1,46 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.ecview.extension.model
+Bundle-SymbolicName: org.eclipse.osbp.ecview.extension.model;singleton:=true
+Bundle-Version: 0.9.0.qualifier
+Bundle-ClassPath: .
+Bundle-Vendor: Eclipse OSBP
+ Germany)
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Export-Package: org.eclipse.osbp.ecview.extension.model;version="0.9.0";
+  uses:="org.eclipse.osbp.ecview.core.common.model.binding,
+   org.eclipse.emf.ecore,
+   org.eclipse.emf.common.util,
+   org.eclipse.osbp.ecview.core.common.model.datatypes,
+   org.eclipse.osbp.ecview.core.common.model.core",
+ org.eclipse.osbp.ecview.extension.model.converter;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.model.converter.impl;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.model.converter.util;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.model.impl;version="0.9.0";
+  uses:="org.eclipse.osbp.ecview.core.common.model.binding,
+   org.eclipse.emf.ecore,
+   org.eclipse.emf.common.util,
+   org.eclipse.osbp.ecview.extension.model,
+   org.eclipse.osbp.ecview.core.common.model.datatypes,
+   org.eclipse.osbp.ecview.core.common.model.core,
+   org.eclipse.emf.common.notify,
+   org.eclipse.emf.ecore.impl,
+   org.eclipse.osbp.ecview.core.common.model.core.impl",
+ org.eclipse.osbp.ecview.extension.model.util;version="0.9.0";
+  uses:="org.eclipse.emf.ecore.util,
+   org.eclipse.emf.ecore,
+   org.eclipse.emf.common.notify.impl,
+   org.eclipse.osbp.ecview.extension.model,
+   org.eclipse.osbp.ecview.core.common.model.core,
+   org.eclipse.emf.common.notify",
+ org.eclipse.osbp.ecview.extension.model.visibility;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.model.visibility.impl;version="0.9.0",
+ org.eclipse.osbp.ecview.extension.model.visibility.util;version="0.9.0"
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.emf.ecore;visibility:=reexport,
+ org.eclipse.osbp.ecview.core.common;bundle-version="[0.9.0,0.10.0)",
+ org.eclipse.osbp.ecview.core.common.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.osbp.ecview.core.extension.model;bundle-version="[0.9.0,0.10.0)";visibility:=reexport,
+ org.eclipse.xtext.common.types;bundle-version="[2.7.3,2.8.0)";visibility:=reexport
+Bundle-ActivationPolicy: lazy
diff --git a/org.eclipse.osbp.ecview.extension.model/about.html b/org.eclipse.osbp.ecview.extension.model/about.html
new file mode 100644
index 0000000..64c0598
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/about.html
@@ -0,0 +1,28 @@
+<!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>June 1, 2016</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &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>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model/about.ini b/org.eclipse.osbp.ecview.extension.model/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/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.ecview.extension.model/about.mappings b/org.eclipse.osbp.ecview.extension.model/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/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.ecview.extension.model/about.properties b/org.eclipse.osbp.ecview.extension.model/about.properties
new file mode 100644
index 0000000..011eda2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/about.properties
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.ecview.extension.model
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - implementation\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.ecview.extension.model/build.properties b/org.eclipse.osbp.ecview.extension.model/build.properties
new file mode 100644
index 0000000..296d8b1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/build.properties
@@ -0,0 +1,16 @@
+#
+output.. = target/classes/
+bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  .,\
+               .settings/,\
+               model/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               license.html,\
+               LICENSE.txt,\
+               epl-v10.html
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
+               LICENSE.txt,\
+               epl-v10.html			   
+jars.compile.order = .
+source.. = src/
diff --git a/org.eclipse.osbp.ecview.extension.model/epl-v10.html b/org.eclipse.osbp.ecview.extension.model/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model/license.html b/org.eclipse.osbp.ecview.extension.model/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.ecview.extension.model/model/ecview.ecore b/org.eclipse.osbp.ecview.extension.model/model/ecview.ecore
new file mode 100644
index 0000000..cf9af0d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/model/ecview.ecore
@@ -0,0 +1,281 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="model" nsURI="http://osbp.de/ecview/v1/extension" nsPrefix="model">
+  <eClassifiers xsi:type="ecore:EClass" name="YStrategyLayout" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YEmbeddable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="layoutingStrategy" eType="#//YLayoutingStrategy"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="focusingStrategies" upperBound="-1"
+        eType="#//YFocusingStrategy" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="suspects" upperBound="-1"
+        eType="#//YSuspect" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="layoutingInfo" eType="#//YLayoutingInfo"
+        transient="true" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="defaultFocusingEnhancerId"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YLayoutingStrategy" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement">
+    <eOperations name="getView" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YView"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="trigger" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YDefaultLayoutingStrategy" eSuperTypes="#//YLayoutingStrategy"/>
+  <eClassifiers xsi:type="ecore:EClass" name="YFocusingStrategy" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement">
+    <eOperations name="getView" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YView"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="keyStrokeDefinition" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YKeyStrokeDefinition"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="tempStrokeDefinition" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YKeyStrokeDefinition"
+        transient="true" containment="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YDelegatingLayoutingStrategy" eSuperTypes="#//YLayoutingStrategy">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="delegateStrategyId" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YDelegatingFocusingStrategy" eSuperTypes="#//YFocusingStrategy">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="delegateStrategyId" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YSuspect" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YAuthorizationable">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="labelI18nKey" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="imageI18nKey" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="valueBindingEndpoints"
+        upperBound="-1" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/binding.ecore#//YBindingEndpoint"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="visibilityProcessors" upperBound="-1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/visibility.ecore#//YVisibilityProcessor"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="commands" upperBound="-1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YCommand"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="assocNewiatedElements"
+        upperBound="-1" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YEmbeddable"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="associatedBindings" upperBound="-1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/binding.ecore#//YBinding"
+        transient="true" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="label" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YTypedSuspect" eSuperTypes="#//YSuspect">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+      <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YTypedCompoundSuspect" eSuperTypes="#//YTypedSuspect">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="children" upperBound="-1"
+        eType="#//YSuspect" containment="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YSubTypeBaseSuspect" eSuperTypes="#//YTypedCompoundSuspect"/>
+  <eClassifiers xsi:type="ecore:EClass" name="YSubTypeSuspect" eSuperTypes="#//YTypedCompoundSuspect">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="beanSlot" lowerBound="1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YBeanSlot"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YLayoutingInfo" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="layout" eType="#//YStrategyLayout"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="content" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YEmbeddable"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="activeSuspectInfos" upperBound="-1"
+        eType="#//YSuspectInfo" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="firstFocus" eType="#//YSuspectInfo"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YSuspectInfo" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="suspect" eType="#//YSuspect"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="bindings" upperBound="-1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/binding.ecore#//YBinding"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="nextFocus" eType="#//YSuspectInfo"
+        eOpposite="#//YSuspectInfo/previousFocus"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="previousFocus" eType="#//YSuspectInfo"
+        eOpposite="#//YSuspectInfo/nextFocus"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="target" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YEmbeddable"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="visibilityProcessors" upperBound="-1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/visibility.ecore#//YVisibilityProcessor"
+        containment="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YBlobUploadComponent" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="displayResolutionId" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="firmlyLinked" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="uniqueNameEnabled" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YCustomDecimalField" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datatype" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.extension.model/model/extdatatypes.ecore#//YDecimalDatatype"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDouble"
+        transient="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YIconComboBox" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YCollectionBindable ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YSelectionBindable ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YBeanServiceConsumer">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datatype" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.extension.model/model/extdatatypes.ecore#//YComboBoxDatatype"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="selection" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+      <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="emfNsURI" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="captionProperty" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="imageProperty" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="descriptionProperty" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="description" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YQuantityTextField" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YCollectionSuspect" eSuperTypes="#//YTypedSuspect">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="columns" upperBound="-1"
+        eType="#//YColumnInfo" containment="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YColumnInfo">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+      <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="properties" upperBound="-1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YStringToStringMap"
+        containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="labelI18nKey" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YContentSensitiveLayout" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YLayout ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YSpacingable ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YMarginable"/>
+  <eClassifiers xsi:type="ecore:EClass" name="YRichTextArea" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="blobValue" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EByteArray"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="useBlob" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="false"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YMaskedTextField" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mask" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        defaultValueLiteral=""/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YPrefixedMaskedTextField" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mask" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        defaultValueLiteral=""/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="prefixes" upperBound="-1"
+        eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YStringToStringMap"
+        containment="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YMaskedNumericField" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="#//Number"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mask" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        defaultValueLiteral=""/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="YMaskedDecimalField" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YValueBindable">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="#//Number"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mask" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        defaultValueLiteral=""/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="decimalSeparator" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//ECharacterObject"
+        defaultValueLiteral="null"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="groupingSeparator" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//ECharacterObject"
+        defaultValueLiteral="null"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="Number" instanceClassName="java.lang.Number"/>
+  <eClassifiers xsi:type="ecore:EClass" name="YPairComboBox" eSuperTypes="../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YInput ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YCollectionBindable ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YSelectionBindable ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.ecore#//YBeanServiceConsumer">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datadescription" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/datatypes.ecore#//YDatadescription"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="datatype" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.extension.model/model/extdatatypes.ecore#//YComboBoxDatatype"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="selection" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="collection" upperBound="-1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+      <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="emfNsURI" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="captionProperty" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="imageProperty" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="descriptionProperty" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="description" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eSubpackages name="converter" nsURI="http://osbp.de/ecview/v1/extension/converter"
+      nsPrefix="converter">
+    <eClassifiers xsi:type="ecore:EClass" name="YObjectToStringConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter"/>
+    <eClassifiers xsi:type="ecore:EClass" name="YCustomDecimalConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="baseUnit" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="YNumericToResourceConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter">
+      <eStructuralFeatures xsi:type="ecore:EReference" name="configs" upperBound="-1"
+          eType="#//converter/YNumericToResourceConfig" containment="true"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="YStringToResourceConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter">
+      <eStructuralFeatures xsi:type="ecore:EReference" name="configs" upperBound="-1"
+          eType="#//converter/YStringToResourceConfig" containment="true"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="YNumericToResourceConfig">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDouble"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="compare" eType="ecore:EEnum ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YCompare"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="resourceThemePath" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="YStringToResourceConfig">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="compare" eType="ecore:EEnum ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YCompare"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="resourceThemePath" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="YPriceToStringConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="valuePropertyPath" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="currencyPropertyPath"
+          lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+        <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+          <eTypeArguments/>
+        </eGenericType>
+      </eStructuralFeatures>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="YQuantityToStringConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="amountPropertyPath" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="uomPropertyPath" lowerBound="1"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="uomCodeRelativePropertyPath"
+          lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="quantityTypeQualifiedName"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="YNumericToUomoConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter"/>
+    <eClassifiers xsi:type="ecore:EClass" name="YDecimalToUomoConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter"/>
+    <eClassifiers xsi:type="ecore:EClass" name="YSimpleDecimalConverter" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YConverter">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="numberFormatPattern"
+          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eClassifiers>
+  </eSubpackages>
+  <eSubpackages name="visibility" nsURI="http://osbp.de/ecview/v1/extension/visibility"
+      nsPrefix="visibility">
+    <eClassifiers xsi:type="ecore:EClass" name="YAuthorizationVisibilityProcessor"
+        eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/visibility.ecore#//YVisibilityProcessor"/>
+    <eClassifiers xsi:type="ecore:EClass" name="YSubTypeVisibilityProcessor" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/visibility.ecore#//YVisibilityProcessor">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="type">
+        <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+          <eTypeArguments/>
+        </eGenericType>
+      </eStructuralFeatures>
+      <eStructuralFeatures xsi:type="ecore:EReference" name="target" lowerBound="1"
+          eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YEmbeddable"/>
+    </eClassifiers>
+  </eSubpackages>
+</ecore:EPackage>
diff --git a/org.eclipse.osbp.ecview.extension.model/model/ecview.genmodel b/org.eclipse.osbp.ecview.extension.model/model/ecview.genmodel
new file mode 100644
index 0000000..4f2e6d7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/model/ecview.genmodel
@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.&#xA;&#xA;Contributors:&#xA;      Florian Pirchner - initial API and implementation"
+    modelDirectory="/org.eclipse.osbp.ecview.extension.model/src" modelPluginID="org.eclipse.osbp.ecview.extension.model"
+    modelName="ecview" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
+    importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0" language=""
+    usedGenPackages="../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//binding ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//core ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//validation ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//datatypes ../../org.eclipse.osbp.ecview.core.common.model/model/core.genmodel#//visibility ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.genmodel#//datatypes ../../org.eclipse.osbp.ecview.core.extension.model/model/extension.genmodel#//extension ../../org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel#//types"
+    importOrganizing="true">
+  <foreignModel>ecview.ecore</foreignModel>
+  <genPackages prefix="YECview" basePackage="org.eclipse.osbp.ecview.extension" disposableProviderFactory="true"
+      extensibleProviderFactory="true" childCreationExtenders="true" ecorePackage="ecview.ecore#/">
+    <genClasses ecoreClass="ecview.ecore#//YStrategyLayout">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YStrategyLayout/layoutingStrategy"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YStrategyLayout/focusingStrategies"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YStrategyLayout/suspects"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YStrategyLayout/layoutingInfo"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YStrategyLayout/defaultFocusingEnhancerId"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YLayoutingStrategy">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YLayoutingStrategy/trigger"/>
+      <genOperations ecoreOperation="ecview.ecore#//YLayoutingStrategy/getView"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YDefaultLayoutingStrategy"/>
+    <genClasses ecoreClass="ecview.ecore#//YFocusingStrategy">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YFocusingStrategy/keyStrokeDefinition"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YFocusingStrategy/tempStrokeDefinition"/>
+      <genOperations ecoreOperation="ecview.ecore#//YFocusingStrategy/getView"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YDelegatingLayoutingStrategy">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YDelegatingLayoutingStrategy/delegateStrategyId"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YDelegatingFocusingStrategy">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YDelegatingFocusingStrategy/delegateStrategyId"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YSuspect">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YSuspect/labelI18nKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YSuspect/imageI18nKey"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspect/valueBindingEndpoints"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspect/visibilityProcessors"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspect/commands"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspect/assocNewiatedElements"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspect/associatedBindings"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YSuspect/label"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YTypedSuspect">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YTypedSuspect/typeQualifiedName"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YTypedSuspect/type"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YTypedCompoundSuspect">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YTypedCompoundSuspect/children"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YLayoutingInfo">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YLayoutingInfo/layout"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YLayoutingInfo/content"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YLayoutingInfo/activeSuspectInfos"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YLayoutingInfo/firstFocus"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YSuspectInfo">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspectInfo/suspect"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspectInfo/bindings"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspectInfo/nextFocus"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspectInfo/previousFocus"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspectInfo/target"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YBlobUploadComponent">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YBlobUploadComponent/value"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YBlobUploadComponent/label"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YBlobUploadComponent/labelI18nKey"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YBlobUploadComponent/displayResolutionId"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YCustomDecimalField">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YCustomDecimalField/datatype"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YCustomDecimalField/datadescription"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YCustomDecimalField/value"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YQuantityTextField">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference ecview.ecore#//YQuantityTextField/datadescription"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YQuantityTextField/value"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YCollectionSuspect">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YCollectionSuspect/columns"/>
+    </genClasses>
+    <genClasses ecoreClass="ecview.ecore#//YColumnInfo">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YColumnInfo/name"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YColumnInfo/type"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YColumnInfo/typeQualifiedName"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YColumnInfo/properties"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YColumnInfo/labelI18nKey"/>
+    </genClasses>
+    <nestedGenPackages prefix="YConverter" basePackage="org.eclipse.osbp.ecview.extension.model"
+        disposableProviderFactory="true" ecorePackage="ecview.ecore#//converter">
+      <genClasses ecoreClass="ecview.ecore#//converter/YObjectToStringConverter"/>
+      <genClasses ecoreClass="ecview.ecore#//converter/YCustomDecimalConverter">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YCustomDecimalConverter/baseUnit"/>
+      </genClasses>
+      <genClasses ecoreClass="ecview.ecore#//converter/YNumericToResourceConverter">
+        <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//converter/YNumericToResourceConverter/configs"/>
+      </genClasses>
+      <genClasses ecoreClass="ecview.ecore#//converter/YStringToResourceConverter">
+        <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//converter/YStringToResourceConverter/configs"/>
+      </genClasses>
+      <genClasses ecoreClass="ecview.ecore#//converter/YNumericToResourceConfig">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YNumericToResourceConfig/value"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YNumericToResourceConfig/compare"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YNumericToResourceConfig/resourceThemePath"/>
+      </genClasses>
+      <genClasses ecoreClass="ecview.ecore#//converter/YStringToResourceConfig">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YStringToResourceConfig/value"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YStringToResourceConfig/compare"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YStringToResourceConfig/resourceThemePath"/>
+      </genClasses>
+      <genClasses ecoreClass="ecview.ecore#//converter/YPriceToStringConverter">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YPriceToStringConverter/valuePropertyPath"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YPriceToStringConverter/currencyPropertyPath"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YPriceToStringConverter/typeQualifiedName"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YPriceToStringConverter/type"/>
+      </genClasses>
+      <genClasses ecoreClass="ecview.ecore#//converter/YQuantityToStringConverter">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YQuantityToStringConverter/amountPropertyPath"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YQuantityToStringConverter/uomPropertyPath"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YQuantityToStringConverter/uomCodeRelativePropertyPath"/>
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YQuantityToStringConverter/quantityTypeQualifiedName"/>
+      </genClasses>
+      <genClasses ecoreClass="ecview.ecore#//converter/YNumericToUomoConverter"/>
+      <genClasses ecoreClass="ecview.ecore#//converter/YDecimalToUomoConverter"/>
+      <genClasses ecoreClass="ecview.ecore#//converter/YSimpleDecimalConverter">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//converter/YSimpleDecimalConverter/numberFormatPattern"/>
+      </genClasses>
+    </nestedGenPackages>
+    <nestedGenPackages prefix="YVisibility" disposableProviderFactory="true" ecorePackage="ecview.ecore#//visibility">
+      <genClasses ecoreClass="ecview.ecore#//visibility/YAuthorizationVisibilityProcessor"/>
+    </nestedGenPackages>
+  </genPackages>
+</genmodel:GenModel>
diff --git a/org.eclipse.osbp.ecview.extension.model/notice.html b/org.eclipse.osbp.ecview.extension.model/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/notice.html
@@ -0,0 +1,107 @@
+<?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>April 9, 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 1.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-v10.html">http://www.eclipse.org/legal/epl-v10.html</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 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.ecview.extension.model/plugin.properties b/org.eclipse.osbp.ecview.extension.model/plugin.properties
new file mode 100644
index 0000000..4a6a554
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/plugin.properties
@@ -0,0 +1,2 @@
+pluginName = Extension model
+providerName = 
diff --git a/org.eclipse.osbp.ecview.extension.model/plugin.xml b/org.eclipse.osbp.ecview.extension.model/plugin.xml
new file mode 100644
index 0000000..13f0b0f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/plugin.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+-->
+
+<plugin>
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated ecview -->
+      <package
+            uri="http://osbp.de/ecview/v1/extension"
+            class="org.eclipse.osbp.ecview.extension.model.YECviewPackage"
+            genModel="model/ecview.genmodel"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated ecview -->
+      <package
+            uri="http://osbp.de/ecview/v1/extension/converter"
+            class="org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage"
+            genModel="model/ecview.genmodel"/>
+   </extension>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated ecview -->
+      <package
+            uri="http://osbp.de/ecview/v1/extension/visibility"
+            class="org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage"
+            genModel="model/ecview.genmodel"/>
+   </extension>
+
+</plugin>
diff --git a/org.eclipse.osbp.ecview.extension.model/pom.xml b/org.eclipse.osbp.ecview.extension.model/pom.xml
new file mode 100644
index 0000000..c40fa8f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/pom.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial 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.ecview.extension.api</groupId>
+		<artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.ecview.extension.model</artifactId>
+	<packaging>eclipse-plugin</packaging>
+	<description>Contains the extension ECView-Model</description>
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+	</build>
+</project>
diff --git a/org.eclipse.osbp.ecview.extension.model/representations.aird b/org.eclipse.osbp.ecview.extension.model/representations.aird
new file mode 100644
index 0000000..2c20abd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/representations.aird
@@ -0,0 +1,785 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<viewpoint:DAnalysis xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:description="http://www.eclipse.org/sirius/description/1.1.0" xmlns:description_1="http://www.eclipse.org/sirius/diagram/description/1.1.0" xmlns:diagram="http://www.eclipse.org/sirius/diagram/1.1.0" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:notation="http://www.eclipse.org/gmf/runtime/1.0.2/notation" xmlns:style="http://www.eclipse.org/sirius/diagram/description/style/1.1.0" xmlns:viewpoint="http://www.eclipse.org/sirius/1.1.0" xsi:schemaLocation="http://www.eclipse.org/sirius/description/1.1.0 http://www.eclipse.org/sirius/1.1.0#//description http://www.eclipse.org/sirius/diagram/description/1.1.0 http://www.eclipse.org/sirius/diagram/1.1.0#//description http://www.eclipse.org/sirius/diagram/description/style/1.1.0 http://www.eclipse.org/sirius/diagram/1.1.0#//description/style" xmi:id="_mOMWQAIqEeaZkPiwH6BSQw" selectedViews="_n2nFkAIqEeaZkPiwH6BSQw _n2w2kAIqEeaZkPiwH6BSQw _n5Z64AIqEeaZkPiwH6BSQw" version="10.0.0.201505222000">
+  <semanticResources>model/ecview.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore</semanticResources>
+  <semanticResources>http://www.eclipse.org/emf/2002/Ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore</semanticResources>
+  <semanticResources>platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore</semanticResources>
+  <ownedViews xmi:type="viewpoint:DRepresentationContainer" xmi:id="_n2nFkAIqEeaZkPiwH6BSQw">
+    <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Review']"/>
+  </ownedViews>
+  <ownedViews xmi:type="viewpoint:DRepresentationContainer" xmi:id="_n2w2kAIqEeaZkPiwH6BSQw">
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n4sJMAIqEeaZkPiwH6BSQw" name="model class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n4sJMQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n4sJMgIqEeaZkPiwH6BSQw">
+          <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_uq9uQQIqEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan">
+            <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            <centerLabelStyleDescription xmi:type="style:CenterLabelStyleDescription" xmi:id="_uq9uQgIqEeaZkPiwH6BSQw" showIcon="false" labelExpression="service:render">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>
+            </centerLabelStyleDescription>
+            <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_uq9uQwIqEeaZkPiwH6BSQw" labelSize="6" showIcon="false" labelExpression="service:eKeysLabel">
+              <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>
+            </endLabelStyleDescription>
+          </computedStyleDescriptions>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n4swQAIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n4swQQIqEeaZkPiwH6BSQw" type="Sirius" element="_n4sJMAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_uq_jcAIqEeaZkPiwH6BSQw" type="2003" element="_uqvEwAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_uq_jcwIqEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_uq_jdAIqEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_uq_jdQIqEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_uq_jdgIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_uq_jcQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_uq_jcgIqEeaZkPiwH6BSQw" x="180" y="414"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_urAKgAIqEeaZkPiwH6BSQw" type="2003" element="_uqwS4AIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_urAKgwIqEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_urAKhAIqEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_urAKhwIqEeaZkPiwH6BSQw" type="3010" element="_uq6D4AIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urAKiAIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urAKiQIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_urAxkAIqEeaZkPiwH6BSQw" type="3010" element="_uq6q8QIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urAxkQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urAxkgIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_urAxkwIqEeaZkPiwH6BSQw" type="3010" element="_uq6q8wIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urAxlAIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urAxlQIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_urAxlgIqEeaZkPiwH6BSQw" type="3010" element="_uq7SAQIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urAxlwIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urAxmAIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_urBYoAIqEeaZkPiwH6BSQw" type="3010" element="_uq7SAwIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urBYoQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urBYogIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_urBYowIqEeaZkPiwH6BSQw" type="3010" element="_uq75EQIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urBYpAIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urBYpQIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_urBYpgIqEeaZkPiwH6BSQw" type="3010" element="_uq75EwIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urBYpwIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urBYqAIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_urBYqQIqEeaZkPiwH6BSQw" type="3010" element="_uq8gIQIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_urBYqgIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_urBYqwIqEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_urAKhQIqEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_urAKhgIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_urAKgQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_urAKggIqEeaZkPiwH6BSQw" x="423" y="405"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_xuWmwAIqEeaZkPiwH6BSQw" type="2003" element="_xuGIEAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_xuWmwwIqEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_xuWmxAIqEeaZkPiwH6BSQw" type="7004">
+              <children xmi:type="notation:Node" xmi:id="_xuXN0AIqEeaZkPiwH6BSQw" type="3010" element="_xuSVUAIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_xuXN0QIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_xuXN0gIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_xuXN0wIqEeaZkPiwH6BSQw" type="3010" element="_xuSVUgIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_xuXN1AIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_xuXN1QIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_xuXN1gIqEeaZkPiwH6BSQw" type="3010" element="_xuS8YQIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_xuXN1wIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_xuXN2AIqEeaZkPiwH6BSQw"/>
+              </children>
+              <children xmi:type="notation:Node" xmi:id="_xuX04AIqEeaZkPiwH6BSQw" type="3010" element="_xuS8YwIqEeaZkPiwH6BSQw">
+                <styles xmi:type="notation:FontStyle" xmi:id="_xuX04QIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+                <layoutConstraint xmi:type="notation:Location" xmi:id="_xuX04gIqEeaZkPiwH6BSQw"/>
+              </children>
+              <styles xmi:type="notation:SortingStyle" xmi:id="_xuWmxQIqEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_xuWmxgIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_xuWmwQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8" italic="true"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_xuWmwgIqEeaZkPiwH6BSQw" x="405" y="54"/>
+          </children>
+          <children xmi:type="notation:Node" xmi:id="_z8i8oAIqEeaZkPiwH6BSQw" type="2003" element="_z8VhQAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_z8jjsAIqEeaZkPiwH6BSQw" type="5007"/>
+            <children xmi:type="notation:Node" xmi:id="_z8jjsQIqEeaZkPiwH6BSQw" type="7004">
+              <styles xmi:type="notation:SortingStyle" xmi:id="_z8jjsgIqEeaZkPiwH6BSQw"/>
+              <styles xmi:type="notation:FilteringStyle" xmi:id="_z8jjswIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_z8i8oQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8i8ogIqEeaZkPiwH6BSQw" x="180" y="210"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n4swQgIqEeaZkPiwH6BSQw"/>
+          <edges xmi:type="notation:Edge" xmi:id="_urB_sAIqEeaZkPiwH6BSQw" type="4001" element="_uq9uQAIqEeaZkPiwH6BSQw" source="_uq_jcAIqEeaZkPiwH6BSQw" target="_urAKgAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_urB_tAIqEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_urB_tQIqEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_urB_tgIqEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_urB_twIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_urCmwAIqEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_urCmwQIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_urB_sQIqEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_urB_sgIqEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_urB_swIqEeaZkPiwH6BSQw" points="[59, 54, -193, -94]$[184, 54, -68, -94]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_urCmwgIqEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_urCmwwIqEeaZkPiwH6BSQw" id="(0.49640287769784175,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_xuX04wIqEeaZkPiwH6BSQw" type="4001" element="_xuUxkAIqEeaZkPiwH6BSQw" source="_urAKgAIqEeaZkPiwH6BSQw" target="_xuWmwAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_xuYb8AIqEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_xuYb8QIqEeaZkPiwH6BSQw" x="-69" y="36"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_xuYb8gIqEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_xuYb8wIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_xuYb9AIqEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_xuYb9QIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_xuX05AIqEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_xuX05QIqEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_xuX05gIqEeaZkPiwH6BSQw" points="[-4, 180, -3, 433]$[-4, -253, -3, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_xuYb9gIqEeaZkPiwH6BSQw" id="(0.49640287769784175,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_xuYb9wIqEeaZkPiwH6BSQw" id="(0.4971098265895953,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_z8kKwAIqEeaZkPiwH6BSQw" type="4001" element="_z8fSQAIqEeaZkPiwH6BSQw" source="_z8i8oAIqEeaZkPiwH6BSQw" target="_xuWmwAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_z8kKxAIqEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8kKxQIqEeaZkPiwH6BSQw" x="-22" y="-11"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_z8kKxgIqEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8kKxwIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_z8kx0AIqEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8kx0QIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_z8kKwQIqEeaZkPiwH6BSQw" routing="Rectilinear"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_z8kKwgIqEeaZkPiwH6BSQw" fontColor="7490599" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_z8kKwwIqEeaZkPiwH6BSQw" points="[59, 60, -192, 118]$[220, 60, -31, 118]$[220, -58, -31, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_z8kx0gIqEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_z8kx0wIqEeaZkPiwH6BSQw" id="(0.4971098265895953,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_z8kx1AIqEeaZkPiwH6BSQw" type="4001" element="_z8f5UAIqEeaZkPiwH6BSQw" source="_uq_jcAIqEeaZkPiwH6BSQw" target="_z8i8oAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_z8lY4AIqEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8lY4QIqEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_z8lY4gIqEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8lY4wIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_z8lY5AIqEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8lY5QIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_z8kx1QIqEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_z8kx1gIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_z8kx1wIqEeaZkPiwH6BSQw" points="[0, 0, 0, 286]$[0, -268, 0, 18]$[1, -268, 1, 18]$[1, -286, 1, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_z8lY5gIqEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_z8lY5wIqEeaZkPiwH6BSQw" id="(0.5,1.0)"/>
+          </edges>
+          <edges xmi:type="notation:Edge" xmi:id="_z8l_9AIqEeaZkPiwH6BSQw" type="4001" element="_z8hHcAIqEeaZkPiwH6BSQw" source="_z8i8oAIqEeaZkPiwH6BSQw" target="_xuWmwAIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_z8l_-AIqEeaZkPiwH6BSQw" type="6001">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8l_-QIqEeaZkPiwH6BSQw" y="-10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_z8l_-gIqEeaZkPiwH6BSQw" type="6002">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8l_-wIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_z8l__AIqEeaZkPiwH6BSQw" type="6003">
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_z8l__QIqEeaZkPiwH6BSQw" y="10"/>
+            </children>
+            <styles xmi:type="notation:ConnectorStyle" xmi:id="_z8l_9QIqEeaZkPiwH6BSQw" routing="Tree"/>
+            <styles xmi:type="notation:FontStyle" xmi:id="_z8l_9gIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_z8l_9wIqEeaZkPiwH6BSQw" points="[0, 0, -251, 58]$[0, -21, -251, 37]$[193, -21, -58, 37]$[193, -58, -58, 0]"/>
+            <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_z8mnAAIqEeaZkPiwH6BSQw" id="(0.5,0.0)"/>
+            <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_z8mnAQIqEeaZkPiwH6BSQw" id="(0.4971098265895953,1.0)"/>
+          </edges>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_uqvEwAIqEeaZkPiwH6BSQw" name="YAbsoluteLayout" tooltipText="" outgoingEdges="_uq9uQAIqEeaZkPiwH6BSQw _z8f5UAIqEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="model/ecview.ecore#//YAbsoluteLayout"/>
+        <semanticElements xmi:type="ecore:EClass" href="model/ecview.ecore#//YAbsoluteLayout"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_uqvr0AIqEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_uqwS4AIqEeaZkPiwH6BSQw" name="YEmbeddablePosition" tooltipText="" outgoingEdges="_xuUxkAIqEeaZkPiwH6BSQw" incomingEdges="_uq9uQAIqEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="model/ecview.ecore#//YEmbeddablePosition"/>
+        <semanticElements xmi:type="ecore:EClass" href="model/ecview.ecore#//YEmbeddablePosition"/>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_uqwS4QIqEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq6D4AIqEeaZkPiwH6BSQw" name="top : EFloat = 0.0" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/top"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/top"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq6q8AIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq6q8QIqEeaZkPiwH6BSQw" name="topUnit : YUnit = PIXEL" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/topUnit"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/topUnit"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq6q8gIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq6q8wIqEeaZkPiwH6BSQw" name="bottom : EFloat = 0.0" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/bottom"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/bottom"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq7SAAIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq7SAQIqEeaZkPiwH6BSQw" name="bottomUnit : YUnit = PIXEL" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/bottomUnit"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/bottomUnit"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq7SAgIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq7SAwIqEeaZkPiwH6BSQw" name="left : EFloat = 0.0" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/left"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/left"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq75EAIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq75EQIqEeaZkPiwH6BSQw" name="leftUnit : YUnit = PIXEL" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/leftUnit"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/leftUnit"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq75EgIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq75EwIqEeaZkPiwH6BSQw" name="right : EFloat = 0.0" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/right"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/right"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq8gIAIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_uq8gIQIqEeaZkPiwH6BSQw" name="rightUnit : YUnit = PIXEL" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/rightUnit"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="model/ecview.ecore#//YEmbeddablePosition/rightUnit"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_uq9HMAIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_uq9uQAIqEeaZkPiwH6BSQw" name="[0..*] positions" sourceNode="_uqvEwAIqEeaZkPiwH6BSQw" targetNode="_uqwS4AIqEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="model/ecview.ecore#//YAbsoluteLayout/positions"/>
+        <semanticElements xmi:type="ecore:EReference" href="model/ecview.ecore#//YAbsoluteLayout/positions"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_uq9uRAIqEeaZkPiwH6BSQw" description="_uq9uQQIqEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_uq9uRQIqEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_uq9uRgIqEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_xuGIEAIqEeaZkPiwH6BSQw" name="YEmbeddable" tooltipText="" incomingEdges="_xuUxkAIqEeaZkPiwH6BSQw _z8fSQAIqEeaZkPiwH6BSQw _z8hHcAIqEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable"/>
+        <semanticElements xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable"/>
+        <decorations xmi:type="viewpoint:Decoration" xmi:id="_xuTjcQIqEeaZkPiwH6BSQw">
+          <description xmi:type="description:SemanticBasedDecoration" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@decorationDescriptionsSet/@decorationDescriptions[name='External']"/>
+        </decorations>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_xuGvIAIqEeaZkPiwH6BSQw" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_abstract.gif" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">
+          <labelFormat>italic</labelFormat>
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.1/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_xuSVUAIqEeaZkPiwH6BSQw" name="mementoEnabled : EBoolean = false" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoEnabled"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoEnabled"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_xuSVUQIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_xuSVUgIqEeaZkPiwH6BSQw" name="mementoId : EString" tooltipText="">
+          <target xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoId"/>
+          <semanticElements xmi:type="ecore:EAttribute" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/mementoId"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_xuS8YAIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_xuS8YQIqEeaZkPiwH6BSQw" name="getView() : YView" tooltipText="getView() : YView">
+          <target xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getView"/>
+          <semanticElements xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getView"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_xuS8YgIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']"/>
+        </ownedElements>
+        <ownedElements xmi:type="diagram:DNodeListElement" xmi:id="_xuS8YwIqEeaZkPiwH6BSQw" name="getParent() : YLayout" tooltipText="getParent() : YLayout">
+          <target xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getParent"/>
+          <semanticElements xmi:type="ecore:EOperation" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YEmbeddable/getParent"/>
+          <ownedStyle xmi:type="diagram:BundledImage" xmi:id="_xuTjcAIqEeaZkPiwH6BSQw" labelAlignment="LEFT">
+            <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']/@style"/>
+          </ownedStyle>
+          <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='Operation']"/>
+        </ownedElements>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_xuUxkAIqEeaZkPiwH6BSQw" name="[0..1] element" sourceNode="_uqwS4AIqEeaZkPiwH6BSQw" targetNode="_xuGIEAIqEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="model/ecview.ecore#//YEmbeddablePosition/element"/>
+        <semanticElements xmi:type="ecore:EReference" href="model/ecview.ecore#//YEmbeddablePosition/element"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_xuUxkQIqEeaZkPiwH6BSQw" routingStyle="manhattan" strokeColor="0,0,0">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']/@style"/>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_xuUxkgIqEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_xuUxkwIqEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DNodeList" xmi:id="_z8VhQAIqEeaZkPiwH6BSQw" name="YLayout" tooltipText="" outgoingEdges="_z8fSQAIqEeaZkPiwH6BSQw _z8hHcAIqEeaZkPiwH6BSQw" incomingEdges="_z8f5UAIqEeaZkPiwH6BSQw" width="12" height="10">
+        <target xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout"/>
+        <semanticElements xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout"/>
+        <decorations xmi:type="viewpoint:Decoration" xmi:id="_z8ddEAIqEeaZkPiwH6BSQw">
+          <description xmi:type="description:SemanticBasedDecoration" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@decorationDescriptionsSet/@decorationDescriptions[name='External']"/>
+        </decorations>
+        <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>
+        <arrangeConstraints>KEEP_SIZE</arrangeConstraints>
+        <arrangeConstraints>KEEP_RATIO</arrangeConstraints>
+        <ownedStyle xmi:type="diagram:FlatContainerStyle" xmi:id="_z8WIUAIqEeaZkPiwH6BSQw" backgroundStyle="Liquid" foregroundColor="255,252,216">
+          <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_z8fSQAIqEeaZkPiwH6BSQw" name="[0..*] elements" sourceNode="_z8VhQAIqEeaZkPiwH6BSQw" targetNode="_xuGIEAIqEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EReference" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout/elements"/>
+        <semanticElements xmi:type="ecore:EReference" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout/elements"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_z8fSQQIqEeaZkPiwH6BSQw" description="_uq9uQQIqEeaZkPiwH6BSQw" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_z8fSQgIqEeaZkPiwH6BSQw" showIcon="false">
+            <customFeatures>labelSize</customFeatures>
+          </centerLabelStyle>
+          <endLabelStyle xmi:type="diagram:EndLabelStyle" xmi:id="_z8fSQwIqEeaZkPiwH6BSQw" showIcon="false" labelColor="39,76,114">
+            <customFeatures>labelSize</customFeatures>
+          </endLabelStyle>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_z8f5UAIqEeaZkPiwH6BSQw" sourceNode="_uqvEwAIqEeaZkPiwH6BSQw" targetNode="_z8VhQAIqEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="model/ecview.ecore#//YAbsoluteLayout"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="model/ecview.ecore#//YAbsoluteLayout/@eGenericSuperTypes.0"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_z8f5UQIqEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_z8f5UgIqEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_z8f5UwIqEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <ownedDiagramElements xmi:type="diagram:DEdge" xmi:id="_z8hHcAIqEeaZkPiwH6BSQw" sourceNode="_z8VhQAIqEeaZkPiwH6BSQw" targetNode="_xuGIEAIqEeaZkPiwH6BSQw">
+        <target xmi:type="ecore:EClass" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout/@eGenericSuperTypes.0"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout/@eGenericSuperTypes.1"/>
+        <semanticElements xmi:type="ecore:EGenericType" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#//YLayout/@eGenericSuperTypes.2"/>
+        <ownedStyle xmi:type="diagram:EdgeStyle" xmi:id="_z8hHcQIqEeaZkPiwH6BSQw" targetArrow="InputClosedArrow" routingStyle="tree">
+          <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>
+          <beginLabelStyle xmi:type="diagram:BeginLabelStyle" xmi:id="_z8hHcgIqEeaZkPiwH6BSQw" showIcon="false">
+            <labelFormat>italic</labelFormat>
+          </beginLabelStyle>
+          <centerLabelStyle xmi:type="diagram:CenterLabelStyle" xmi:id="_z8hHcwIqEeaZkPiwH6BSQw" showIcon="false"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n4sJNQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="model/ecview.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n4waoAIqEeaZkPiwH6BSQw" name="converter class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n4waoQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n4waogIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n4wapgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n4xBsAIqEeaZkPiwH6BSQw" type="Sirius" element="_n4waoAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n4xBsgIqEeaZkPiwH6BSQw" type="2001" element="_n4waowIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n4xBtQIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n4xBtgIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n4xBtwIqEeaZkPiwH6BSQw" type="3005" element="_n4wapAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n4xBuAIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n4xBuQIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n4xBswIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n4xBtAIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n4xBsQIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n4waowIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="model/ecview.ecore#//converter"/>
+        <semanticElements xmi:type="ecore:EPackage" href="model/ecview.ecore#//converter"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n4wapAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n4wapQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="model/ecview.ecore#//converter"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n4zd8AIqEeaZkPiwH6BSQw" name="visibility class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n4zd8QIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n4zd8gIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n4zd9gIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n4zd9wIqEeaZkPiwH6BSQw" type="Sirius" element="_n4zd8AIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n4zd-QIqEeaZkPiwH6BSQw" type="2001" element="_n4zd8wIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n4zd_AIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n4zd_QIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n40FAAIqEeaZkPiwH6BSQw" type="3005" element="_n4zd9AIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n40FAQIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n40FAgIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n4zd-gIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n4zd-wIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n4zd-AIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n4zd8wIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="model/ecview.ecore#//visibility"/>
+        <semanticElements xmi:type="ecore:EPackage" href="model/ecview.ecore#//visibility"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n4zd9AIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n4zd9QIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="model/ecview.ecore#//visibility"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n42hQAIqEeaZkPiwH6BSQw" name="core class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n42hQQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n42hQgIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n42hRgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n42hRwIqEeaZkPiwH6BSQw" type="Sirius" element="_n42hQAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n42hSQIqEeaZkPiwH6BSQw" type="2001" element="_n42hQwIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n42hTAIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n42hTQIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n43IUAIqEeaZkPiwH6BSQw" type="3005" element="_n42hRAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n43IUQIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n43IUgIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n42hSgIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n42hSwIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n42hSAIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n42hQwIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n42hRAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n42hRQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/core.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n46LoAIqEeaZkPiwH6BSQw" name="ecore class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n46LoQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n46LogIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n46LpgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n46LpwIqEeaZkPiwH6BSQw" type="Sirius" element="_n46LoAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n46LqQIqEeaZkPiwH6BSQw" type="2001" element="_n46LowIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n46LrAIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n46LrQIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n46ysAIqEeaZkPiwH6BSQw" type="3005" element="_n46LpAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n46ysQIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n46ysgIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n46LqgIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n46LqwIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n46LqAIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n46LowIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="http://www.eclipse.org/emf/2002/Ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="http://www.eclipse.org/emf/2002/Ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n46LpAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n46LpQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="http://www.eclipse.org/emf/2002/Ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n492AAIqEeaZkPiwH6BSQw" name="binding class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n492AQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n492AgIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n492BgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n492BwIqEeaZkPiwH6BSQw" type="Sirius" element="_n492AAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n4-dEAIqEeaZkPiwH6BSQw" type="2001" element="_n492AwIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n4-dEwIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n4-dFAIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n4_EIAIqEeaZkPiwH6BSQw" type="3005" element="_n492BAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n4_EIQIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n4_EIgIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n4-dEQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n4-dEgIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n492CAIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n492AwIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n492BAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n492BQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/binding.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n5BgYAIqEeaZkPiwH6BSQw" name="visibility class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5BgYQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n5BgYgIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5BgZgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n5BgZwIqEeaZkPiwH6BSQw" type="Sirius" element="_n5BgYAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n5CHcAIqEeaZkPiwH6BSQw" type="2001" element="_n5BgYwIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n5CHcwIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n5CHdAIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n5CugAIqEeaZkPiwH6BSQw" type="3005" element="_n5BgZAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n5CugQIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5CuggIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n5CHcQIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5CHcgIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n5BgaAIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n5BgYwIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n5BgZAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n5BgZQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/visibility.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n5FKwAIqEeaZkPiwH6BSQw" name="extension class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5FKwQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n5FKwgIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5FKxgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n5FKxwIqEeaZkPiwH6BSQw" type="Sirius" element="_n5FKwAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n5FKyQIqEeaZkPiwH6BSQw" type="2001" element="_n5FKwwIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n5FKzAIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n5FKzQIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n5Fx0AIqEeaZkPiwH6BSQw" type="3005" element="_n5FKxAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n5Fx0QIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5Fx0gIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n5FKygIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5FKywIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n5FKyAIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n5FKwwIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n5FKxAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n5FKxQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extension.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n5JcMAIqEeaZkPiwH6BSQw" name="datatypes class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5JcMQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n5JcMgIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5JcNgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n5JcNwIqEeaZkPiwH6BSQw" type="Sirius" element="_n5JcMAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n5JcOQIqEeaZkPiwH6BSQw" type="2001" element="_n5JcMwIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n5KDQAIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n5KDQQIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n5KDQgIqEeaZkPiwH6BSQw" type="3005" element="_n5JcNAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n5KDQwIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5KDRAIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n5JcOgIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5JcOwIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n5JcOAIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n5JcMwIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n5JcNAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n5JcNQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.extension.model/model/extdatatypes.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n5NGkAIqEeaZkPiwH6BSQw" name="datatypes class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5NGkQIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n5NGkgIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5NGlgIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n5NGlwIqEeaZkPiwH6BSQw" type="Sirius" element="_n5NGkAIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n5NGmQIqEeaZkPiwH6BSQw" type="2001" element="_n5NGkwIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n5NtoAIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n5NtoQIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n5NtogIqEeaZkPiwH6BSQw" type="3005" element="_n5NGlAIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n5NtowIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5NtpAIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n5NGmgIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5NGmwIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n5NGmAIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n5NGkwIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n5NGlAIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n5NGlQIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/datatypes.ecore#/"/>
+    </ownedRepresentations>
+    <ownedRepresentations xmi:type="diagram:DSemanticDiagram" xmi:id="_n5Qw8AIqEeaZkPiwH6BSQw" name="validation class diagram">
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5Qw8QIqEeaZkPiwH6BSQw" source="DANNOTATION_CUSTOMIZATION_KEY">
+        <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_n5Qw8gIqEeaZkPiwH6BSQw"/>
+      </ownedAnnotationEntries>
+      <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_n5Qw9gIqEeaZkPiwH6BSQw" source="GMF_DIAGRAMS">
+        <data xmi:type="notation:Diagram" xmi:id="_n5Qw9wIqEeaZkPiwH6BSQw" type="Sirius" element="_n5Qw8AIqEeaZkPiwH6BSQw" measurementUnit="Pixel">
+          <children xmi:type="notation:Node" xmi:id="_n5Qw-QIqEeaZkPiwH6BSQw" type="2001" element="_n5Qw8wIqEeaZkPiwH6BSQw">
+            <children xmi:type="notation:Node" xmi:id="_n5RYAAIqEeaZkPiwH6BSQw" type="5002">
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_n5RYAQIqEeaZkPiwH6BSQw" y="5"/>
+            </children>
+            <children xmi:type="notation:Node" xmi:id="_n5RYAgIqEeaZkPiwH6BSQw" type="3005" element="_n5Qw9AIqEeaZkPiwH6BSQw">
+              <styles xmi:type="notation:ShapeStyle" xmi:id="_n5RYAwIqEeaZkPiwH6BSQw" fontName=".SF NS Text"/>
+              <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5RYBAIqEeaZkPiwH6BSQw"/>
+            </children>
+            <styles xmi:type="notation:ShapeStyle" xmi:id="_n5Qw-gIqEeaZkPiwH6BSQw" fontName=".SF NS Text" fontHeight="8"/>
+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_n5Qw-wIqEeaZkPiwH6BSQw" width="672" height="67"/>
+          </children>
+          <styles xmi:type="notation:DiagramStyle" xmi:id="_n5Qw-AIqEeaZkPiwH6BSQw"/>
+        </data>
+      </ownedAnnotationEntries>
+      <ownedDiagramElements xmi:type="diagram:DNode" xmi:id="_n5Qw8wIqEeaZkPiwH6BSQw" width="-1" height="-1">
+        <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore#/"/>
+        <semanticElements xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore#/"/>
+        <ownedStyle xmi:type="diagram:WorkspaceImage" xmi:id="_n5Qw9AIqEeaZkPiwH6BSQw" showIcon="false" labelPosition="node" workspacePath="/org.eclipse.emf.ecoretools.design/icons/full/back/empty.svg">
+          <description xmi:type="style:WorkspaceImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@nodeMappings[name='Empty%20Diagram']"/>
+      </ownedDiagramElements>
+      <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
+      <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_n5Qw9QIqEeaZkPiwH6BSQw"/>
+      <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>
+      <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>
+      <target xmi:type="ecore:EPackage" href="platform:/resource/org.lunifera.ecview.core.common.model/model/validation.ecore#/"/>
+    </ownedRepresentations>
+    <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']"/>
+  </ownedViews>
+  <ownedViews xmi:type="viewpoint:DRepresentationContainer" xmi:id="_n5Z64AIqEeaZkPiwH6BSQw">
+    <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']"/>
+  </ownedViews>
+</viewpoint:DAnalysis>
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YBlobUploadComponent.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YBlobUploadComponent.java
new file mode 100644
index 0000000..8406d09
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YBlobUploadComponent.java
@@ -0,0 +1,151 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YBlob Upload Component</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getDisplayResolutionId <em>Display Resolution Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isFirmlyLinked <em>Firmly Linked</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isUniqueNameEnabled <em>Unique Name Enabled</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYBlobUploadComponent()
+ * @model
+ * @generated
+ */
+public interface YBlobUploadComponent extends YInput, YValueBindable {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYBlobUploadComponent_Value()
+	 * @model
+	 * @generated
+	 */
+	String getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Display Resolution Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Display Resolution Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Display Resolution Id</em>' attribute.
+	 * @see #setDisplayResolutionId(int)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYBlobUploadComponent_DisplayResolutionId()
+	 * @model
+	 * @generated
+	 */
+	int getDisplayResolutionId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getDisplayResolutionId <em>Display Resolution Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Display Resolution Id</em>' attribute.
+	 * @see #getDisplayResolutionId()
+	 * @generated
+	 */
+	void setDisplayResolutionId(int value);
+
+	/**
+	 * Returns the value of the '<em><b>Firmly Linked</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Firmly Linked</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Firmly Linked</em>' attribute.
+	 * @see #setFirmlyLinked(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYBlobUploadComponent_FirmlyLinked()
+	 * @model
+	 * @generated
+	 */
+	boolean isFirmlyLinked();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isFirmlyLinked <em>Firmly Linked</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Firmly Linked</em>' attribute.
+	 * @see #isFirmlyLinked()
+	 * @generated
+	 */
+	void setFirmlyLinked(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Unique Name Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Unique Name Enabled</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Unique Name Enabled</em>' attribute.
+	 * @see #setUniqueNameEnabled(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYBlobUploadComponent_UniqueNameEnabled()
+	 * @model
+	 * @generated
+	 */
+	boolean isUniqueNameEnabled();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isUniqueNameEnabled <em>Unique Name Enabled</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Unique Name Enabled</em>' attribute.
+	 * @see #isUniqueNameEnabled()
+	 * @generated
+	 */
+	void setUniqueNameEnabled(boolean value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YCollectionSuspect.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YCollectionSuspect.java
new file mode 100644
index 0000000..6549866
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YCollectionSuspect.java
@@ -0,0 +1,59 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YCollection Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YCollectionSuspect#getColumns <em>Columns</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYCollectionSuspect()
+ * @model
+ * @generated
+ */
+public interface YCollectionSuspect extends YTypedSuspect {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Columns</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.model.YColumnInfo}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Columns</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Columns</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYCollectionSuspect_Columns()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YColumnInfo> getColumns();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YColumnInfo.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YColumnInfo.java
new file mode 100644
index 0000000..d35de5e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YColumnInfo.java
@@ -0,0 +1,169 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YColumn Info</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYColumnInfo()
+ * @model
+ * @generated
+ */
+public interface YColumnInfo extends EObject {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Name</em>' attribute.
+	 * @see #setName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYColumnInfo_Name()
+	 * @model
+	 * @generated
+	 */
+	String getName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getName <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Name</em>' attribute.
+	 * @see #getName()
+	 * @generated
+	 */
+	void setName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYColumnInfo_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYColumnInfo_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Properties</b></em>' map.
+	 * The key is of type {@link java.lang.String},
+	 * and the value is of type {@link java.lang.String},
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Properties</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Properties</em>' map.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYColumnInfo_Properties()
+	 * @model mapType="org.eclipse.osbp.ecview.core.common.model.core.YStringToStringMap<org.eclipse.emf.ecore.EString, org.eclipse.emf.ecore.EString>"
+	 * @generated
+	 */
+	EMap<String, String> getProperties();
+
+	/**
+	 * Returns the value of the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label I1 8n Key</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #setLabelI18nKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYColumnInfo_LabelI18nKey()
+	 * @model
+	 * @generated
+	 */
+	String getLabelI18nKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getLabelI18nKey <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 */
+	void setLabelI18nKey(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YContentSensitiveLayout.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YContentSensitiveLayout.java
new file mode 100644
index 0000000..107ca64
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YContentSensitiveLayout.java
@@ -0,0 +1,38 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YMarginable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSpacingable;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YContent Sensitive Layout</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYContentSensitiveLayout()
+ * @model
+ * @generated
+ */
+public interface YContentSensitiveLayout extends YLayout, YSpacingable, YMarginable {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+} // YContentSensitiveLayout
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YCustomDecimalField.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YCustomDecimalField.java
new file mode 100644
index 0000000..dfb1c9a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YCustomDecimalField.java
@@ -0,0 +1,126 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YDecimalDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YCustom Decimal Field</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatatype <em>Datatype</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getValue <em>Value</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYCustomDecimalField()
+ * @model
+ * @generated
+ */
+public interface YCustomDecimalField extends YInput, YValueBindable {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datatype</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datatype</em>' reference.
+	 * @see #setDatatype(YDecimalDatatype)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYCustomDecimalField_Datatype()
+	 * @model
+	 * @generated
+	 */
+	YDecimalDatatype getDatatype();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatatype <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datatype</em>' reference.
+	 * @see #getDatatype()
+	 * @generated
+	 */
+	void setDatatype(YDecimalDatatype value);
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYCustomDecimalField_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(double)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYCustomDecimalField_Value()
+	 * @model transient="true"
+	 * @generated
+	 */
+	double getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(double value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDefaultLayoutingStrategy.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDefaultLayoutingStrategy.java
new file mode 100644
index 0000000..69d7a3f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDefaultLayoutingStrategy.java
@@ -0,0 +1,36 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YDefault Layouting Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYDefaultLayoutingStrategy()
+ * @model
+ * @generated
+ */
+public interface YDefaultLayoutingStrategy extends YLayoutingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDelegatingFocusingStrategy.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDelegatingFocusingStrategy.java
new file mode 100644
index 0000000..319b375
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDelegatingFocusingStrategy.java
@@ -0,0 +1,68 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YDelegating Focusing Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy#getDelegateStrategyId <em>Delegate Strategy Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYDelegatingFocusingStrategy()
+ * @model
+ * @generated
+ */
+public interface YDelegatingFocusingStrategy extends YFocusingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Delegate Strategy Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Delegate Strategy Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Delegate Strategy Id</em>' attribute.
+	 * @see #setDelegateStrategyId(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYDelegatingFocusingStrategy_DelegateStrategyId()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getDelegateStrategyId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy#getDelegateStrategyId <em>Delegate Strategy Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Delegate Strategy Id</em>' attribute.
+	 * @see #getDelegateStrategyId()
+	 * @generated
+	 */
+	void setDelegateStrategyId(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDelegatingLayoutingStrategy.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDelegatingLayoutingStrategy.java
new file mode 100644
index 0000000..9c83505
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YDelegatingLayoutingStrategy.java
@@ -0,0 +1,68 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YDelegating Layouting Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy#getDelegateStrategyId <em>Delegate Strategy Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYDelegatingLayoutingStrategy()
+ * @model
+ * @generated
+ */
+public interface YDelegatingLayoutingStrategy extends YLayoutingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Delegate Strategy Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Delegate Strategy Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Delegate Strategy Id</em>' attribute.
+	 * @see #setDelegateStrategyId(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYDelegatingLayoutingStrategy_DelegateStrategyId()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getDelegateStrategyId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy#getDelegateStrategyId <em>Delegate Strategy Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Delegate Strategy Id</em>' attribute.
+	 * @see #getDelegateStrategyId()
+	 * @generated
+	 */
+	void setDelegateStrategyId(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewFactory.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewFactory.java
new file mode 100644
index 0000000..37b03d1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewFactory.java
@@ -0,0 +1,286 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage
+ * @generated
+ */
+public interface YECviewFactory extends EFactory {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	YECviewFactory eINSTANCE = org.eclipse.osbp.ecview.extension.model.impl.YECviewFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>YStrategy Layout</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YStrategy Layout</em>'.
+	 * @generated
+	 */
+	YStrategyLayout createYStrategyLayout();
+
+	/**
+	 * Returns a new object of class '<em>YLayouting Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YLayouting Strategy</em>'.
+	 * @generated
+	 */
+	YLayoutingStrategy createYLayoutingStrategy();
+
+	/**
+	 * Returns a new object of class '<em>YDefault Layouting Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YDefault Layouting Strategy</em>'.
+	 * @generated
+	 */
+	YDefaultLayoutingStrategy createYDefaultLayoutingStrategy();
+
+	/**
+	 * Returns a new object of class '<em>YFocusing Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YFocusing Strategy</em>'.
+	 * @generated
+	 */
+	YFocusingStrategy createYFocusingStrategy();
+
+	/**
+	 * Returns a new object of class '<em>YDelegating Layouting Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YDelegating Layouting Strategy</em>'.
+	 * @generated
+	 */
+	YDelegatingLayoutingStrategy createYDelegatingLayoutingStrategy();
+
+	/**
+	 * Returns a new object of class '<em>YDelegating Focusing Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YDelegating Focusing Strategy</em>'.
+	 * @generated
+	 */
+	YDelegatingFocusingStrategy createYDelegatingFocusingStrategy();
+
+	/**
+	 * Returns a new object of class '<em>YSuspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YSuspect</em>'.
+	 * @generated
+	 */
+	YSuspect createYSuspect();
+
+	/**
+	 * Returns a new object of class '<em>YLayouting Info</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YLayouting Info</em>'.
+	 * @generated
+	 */
+	YLayoutingInfo createYLayoutingInfo();
+
+	/**
+	 * Returns a new object of class '<em>YSuspect Info</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YSuspect Info</em>'.
+	 * @generated
+	 */
+	YSuspectInfo createYSuspectInfo();
+
+	/**
+	 * Returns a new object of class '<em>YBlob Upload Component</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YBlob Upload Component</em>'.
+	 * @generated
+	 */
+	YBlobUploadComponent createYBlobUploadComponent();
+
+	/**
+	 * Returns a new object of class '<em>YTyped Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YTyped Suspect</em>'.
+	 * @generated
+	 */
+	YTypedSuspect createYTypedSuspect();
+
+	/**
+	 * Returns a new object of class '<em>YTyped Compound Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YTyped Compound Suspect</em>'.
+	 * @generated
+	 */
+	YTypedCompoundSuspect createYTypedCompoundSuspect();
+
+	/**
+	 * Returns a new object of class '<em>YSub Type Base Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YSub Type Base Suspect</em>'.
+	 * @generated
+	 */
+	YSubTypeBaseSuspect createYSubTypeBaseSuspect();
+
+	/**
+	 * Returns a new object of class '<em>YSub Type Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YSub Type Suspect</em>'.
+	 * @generated
+	 */
+	YSubTypeSuspect createYSubTypeSuspect();
+
+	/**
+	 * Returns a new object of class '<em>YCustom Decimal Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YCustom Decimal Field</em>'.
+	 * @generated
+	 */
+	YCustomDecimalField createYCustomDecimalField();
+
+	/**
+	 * Returns a new object of class '<em>YIcon Combo Box</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YIcon Combo Box</em>'.
+	 * @generated
+	 */
+	YIconComboBox createYIconComboBox();
+
+	/**
+	 * Returns a new object of class '<em>YQuantity Text Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YQuantity Text Field</em>'.
+	 * @generated
+	 */
+	YQuantityTextField createYQuantityTextField();
+
+	/**
+	 * Returns a new object of class '<em>YCollection Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YCollection Suspect</em>'.
+	 * @generated
+	 */
+	YCollectionSuspect createYCollectionSuspect();
+
+	/**
+	 * Returns a new object of class '<em>YColumn Info</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YColumn Info</em>'.
+	 * @generated
+	 */
+	YColumnInfo createYColumnInfo();
+
+	/**
+	 * Returns a new object of class '<em>YContent Sensitive Layout</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YContent Sensitive Layout</em>'.
+	 * @generated
+	 */
+	YContentSensitiveLayout createYContentSensitiveLayout();
+
+	/**
+	 * Returns a new object of class '<em>YRich Text Area</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YRich Text Area</em>'.
+	 * @generated
+	 */
+	YRichTextArea createYRichTextArea();
+
+	/**
+	 * Returns a new object of class '<em>YMasked Text Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YMasked Text Field</em>'.
+	 * @generated
+	 */
+	YMaskedTextField createYMaskedTextField();
+
+	/**
+	 * Returns a new object of class '<em>YPrefixed Masked Text Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YPrefixed Masked Text Field</em>'.
+	 * @generated
+	 */
+	YPrefixedMaskedTextField createYPrefixedMaskedTextField();
+
+	/**
+	 * Returns a new object of class '<em>YMasked Numeric Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YMasked Numeric Field</em>'.
+	 * @generated
+	 */
+	YMaskedNumericField createYMaskedNumericField();
+
+	/**
+	 * Returns a new object of class '<em>YMasked Decimal Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YMasked Decimal Field</em>'.
+	 * @generated
+	 */
+	YMaskedDecimalField createYMaskedDecimalField();
+
+	/**
+	 * Returns a new object of class '<em>YPair Combo Box</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YPair Combo Box</em>'.
+	 * @generated
+	 */
+	YPairComboBox createYPairComboBox();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	YECviewPackage getYECviewPackage();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewPackage.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewPackage.java
new file mode 100644
index 0000000..16a8ed5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewPackage.java
@@ -0,0 +1,7284 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface YECviewPackage extends EPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "model";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://osbp.de/ecview/v1/extension";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "model";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	YECviewPackage eINSTANCE = org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl <em>YStrategy Layout</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYStrategyLayout()
+	 * @generated
+	 */
+	int YSTRATEGY_LAYOUT = 0;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__TAGS = CoreModelPackage.YEMBEDDABLE__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__ID = CoreModelPackage.YEMBEDDABLE__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__NAME = CoreModelPackage.YEMBEDDABLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__PROPERTIES = CoreModelPackage.YEMBEDDABLE__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__CSS_CLASS = CoreModelPackage.YEMBEDDABLE__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__CSS_ID = CoreModelPackage.YEMBEDDABLE__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__INITIAL_VISIBLE = CoreModelPackage.YEMBEDDABLE__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__VISIBLE = CoreModelPackage.YEMBEDDABLE__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__AUTHORIZATION_GROUP = CoreModelPackage.YEMBEDDABLE__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__AUTHORIZATION_ID = CoreModelPackage.YEMBEDDABLE__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__ORPHAN_DATATYPES = CoreModelPackage.YEMBEDDABLE__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__ORPHAN_DATADESCRIPTIONS = CoreModelPackage.YEMBEDDABLE__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__MEMENTO_ENABLED = CoreModelPackage.YEMBEDDABLE__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__MEMENTO_ID = CoreModelPackage.YEMBEDDABLE__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__LABEL = CoreModelPackage.YEMBEDDABLE__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__LABEL_I1_8N_KEY = CoreModelPackage.YEMBEDDABLE__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Layouting Strategy</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Focusing Strategies</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Suspects</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__SUSPECTS = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Layouting Info</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__LAYOUTING_INFO = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Default Focusing Enhancer Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>YStrategy Layout</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT_FEATURE_COUNT = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 5;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl <em>YLayouting Strategy</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYLayoutingStrategy()
+	 * @generated
+	 */
+	int YLAYOUTING_STRATEGY = 1;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_STRATEGY__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_STRATEGY__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_STRATEGY__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_STRATEGY__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Trigger</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_STRATEGY__TRIGGER = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YLayouting Strategy</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_STRATEGY_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YDefaultLayoutingStrategyImpl <em>YDefault Layouting Strategy</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YDefaultLayoutingStrategyImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYDefaultLayoutingStrategy()
+	 * @generated
+	 */
+	int YDEFAULT_LAYOUTING_STRATEGY = 2;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDEFAULT_LAYOUTING_STRATEGY__TAGS = YLAYOUTING_STRATEGY__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDEFAULT_LAYOUTING_STRATEGY__ID = YLAYOUTING_STRATEGY__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDEFAULT_LAYOUTING_STRATEGY__NAME = YLAYOUTING_STRATEGY__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDEFAULT_LAYOUTING_STRATEGY__PROPERTIES = YLAYOUTING_STRATEGY__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Trigger</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDEFAULT_LAYOUTING_STRATEGY__TRIGGER = YLAYOUTING_STRATEGY__TRIGGER;
+
+	/**
+	 * The number of structural features of the '<em>YDefault Layouting Strategy</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDEFAULT_LAYOUTING_STRATEGY_FEATURE_COUNT = YLAYOUTING_STRATEGY_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl <em>YFocusing Strategy</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYFocusingStrategy()
+	 * @generated
+	 */
+	int YFOCUSING_STRATEGY = 3;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YFOCUSING_STRATEGY__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YFOCUSING_STRATEGY__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YFOCUSING_STRATEGY__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YFOCUSING_STRATEGY__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Key Stroke Definition</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Temp Stroke Definition</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>YFocusing Strategy</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YFOCUSING_STRATEGY_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YDelegatingLayoutingStrategyImpl <em>YDelegating Layouting Strategy</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YDelegatingLayoutingStrategyImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYDelegatingLayoutingStrategy()
+	 * @generated
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY = 4;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY__TAGS = YLAYOUTING_STRATEGY__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY__ID = YLAYOUTING_STRATEGY__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY__NAME = YLAYOUTING_STRATEGY__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY__PROPERTIES = YLAYOUTING_STRATEGY__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Trigger</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY__TRIGGER = YLAYOUTING_STRATEGY__TRIGGER;
+
+	/**
+	 * The feature id for the '<em><b>Delegate Strategy Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID = YLAYOUTING_STRATEGY_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YDelegating Layouting Strategy</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_LAYOUTING_STRATEGY_FEATURE_COUNT = YLAYOUTING_STRATEGY_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YDelegatingFocusingStrategyImpl <em>YDelegating Focusing Strategy</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YDelegatingFocusingStrategyImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYDelegatingFocusingStrategy()
+	 * @generated
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY = 5;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY__TAGS = YFOCUSING_STRATEGY__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY__ID = YFOCUSING_STRATEGY__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY__NAME = YFOCUSING_STRATEGY__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY__PROPERTIES = YFOCUSING_STRATEGY__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Key Stroke Definition</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY__KEY_STROKE_DEFINITION = YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION;
+
+	/**
+	 * The feature id for the '<em><b>Temp Stroke Definition</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY__TEMP_STROKE_DEFINITION = YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION;
+
+	/**
+	 * The feature id for the '<em><b>Delegate Strategy Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID = YFOCUSING_STRATEGY_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YDelegating Focusing Strategy</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDELEGATING_FOCUSING_STRATEGY_FEATURE_COUNT = YFOCUSING_STRATEGY_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl <em>YSuspect</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSuspect()
+	 * @generated
+	 */
+	int YSUSPECT = 6;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__AUTHORIZATION_GROUP = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__AUTHORIZATION_ID = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__LABEL_I1_8N_KEY = CoreModelPackage.YELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Image I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__IMAGE_I1_8N_KEY = CoreModelPackage.YELEMENT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoints</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__VALUE_BINDING_ENDPOINTS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__VISIBILITY_PROCESSORS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Commands</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__COMMANDS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Assoc Newiated Elements</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__ASSOC_NEWIATED_ELEMENTS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 7;
+
+	/**
+	 * The feature id for the '<em><b>Associated Bindings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__ASSOCIATED_BINDINGS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 8;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__LABEL = CoreModelPackage.YELEMENT_FEATURE_COUNT + 9;
+
+	/**
+	 * The number of structural features of the '<em>YSuspect</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 10;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl <em>YLayouting Info</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYLayoutingInfo()
+	 * @generated
+	 */
+	int YLAYOUTING_INFO = 11;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl <em>YSuspect Info</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSuspectInfo()
+	 * @generated
+	 */
+	int YSUSPECT_INFO = 12;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl <em>YBlob Upload Component</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYBlobUploadComponent()
+	 * @generated
+	 */
+	int YBLOB_UPLOAD_COMPONENT = 13;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YTypedSuspectImpl <em>YTyped Suspect</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YTypedSuspectImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYTypedSuspect()
+	 * @generated
+	 */
+	int YTYPED_SUSPECT = 7;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__TAGS = YSUSPECT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__ID = YSUSPECT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__NAME = YSUSPECT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__PROPERTIES = YSUSPECT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__AUTHORIZATION_GROUP = YSUSPECT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__AUTHORIZATION_ID = YSUSPECT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__LABEL_I1_8N_KEY = YSUSPECT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Image I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__IMAGE_I1_8N_KEY = YSUSPECT__IMAGE_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoints</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__VALUE_BINDING_ENDPOINTS = YSUSPECT__VALUE_BINDING_ENDPOINTS;
+
+	/**
+	 * The feature id for the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__VISIBILITY_PROCESSORS = YSUSPECT__VISIBILITY_PROCESSORS;
+
+	/**
+	 * The feature id for the '<em><b>Commands</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__COMMANDS = YSUSPECT__COMMANDS;
+
+	/**
+	 * The feature id for the '<em><b>Assoc Newiated Elements</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__ASSOC_NEWIATED_ELEMENTS = YSUSPECT__ASSOC_NEWIATED_ELEMENTS;
+
+	/**
+	 * The feature id for the '<em><b>Associated Bindings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__ASSOCIATED_BINDINGS = YSUSPECT__ASSOCIATED_BINDINGS;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__LABEL = YSUSPECT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__TYPE_QUALIFIED_NAME = YSUSPECT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__TYPE = YSUSPECT_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>YTyped Suspect</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT_FEATURE_COUNT = YSUSPECT_FEATURE_COUNT + 2;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YTypedCompoundSuspectImpl <em>YTyped Compound Suspect</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YTypedCompoundSuspectImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYTypedCompoundSuspect()
+	 * @generated
+	 */
+	int YTYPED_COMPOUND_SUSPECT = 8;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__TAGS = YTYPED_SUSPECT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__ID = YTYPED_SUSPECT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__NAME = YTYPED_SUSPECT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__PROPERTIES = YTYPED_SUSPECT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__AUTHORIZATION_GROUP = YTYPED_SUSPECT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__AUTHORIZATION_ID = YTYPED_SUSPECT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__LABEL_I1_8N_KEY = YTYPED_SUSPECT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Image I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__IMAGE_I1_8N_KEY = YTYPED_SUSPECT__IMAGE_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoints</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__VALUE_BINDING_ENDPOINTS = YTYPED_SUSPECT__VALUE_BINDING_ENDPOINTS;
+
+	/**
+	 * The feature id for the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__VISIBILITY_PROCESSORS = YTYPED_SUSPECT__VISIBILITY_PROCESSORS;
+
+	/**
+	 * The feature id for the '<em><b>Commands</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__COMMANDS = YTYPED_SUSPECT__COMMANDS;
+
+	/**
+	 * The feature id for the '<em><b>Assoc Newiated Elements</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__ASSOC_NEWIATED_ELEMENTS = YTYPED_SUSPECT__ASSOC_NEWIATED_ELEMENTS;
+
+	/**
+	 * The feature id for the '<em><b>Associated Bindings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__ASSOCIATED_BINDINGS = YTYPED_SUSPECT__ASSOCIATED_BINDINGS;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__LABEL = YTYPED_SUSPECT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__TYPE_QUALIFIED_NAME = YTYPED_SUSPECT__TYPE_QUALIFIED_NAME;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__TYPE = YTYPED_SUSPECT__TYPE;
+
+	/**
+	 * The feature id for the '<em><b>Children</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__CHILDREN = YTYPED_SUSPECT_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YTyped Compound Suspect</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT_FEATURE_COUNT = YTYPED_SUSPECT_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSubTypeBaseSuspectImpl <em>YSub Type Base Suspect</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YSubTypeBaseSuspectImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSubTypeBaseSuspect()
+	 * @generated
+	 */
+	int YSUB_TYPE_BASE_SUSPECT = 9;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__TAGS = YTYPED_COMPOUND_SUSPECT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__ID = YTYPED_COMPOUND_SUSPECT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__NAME = YTYPED_COMPOUND_SUSPECT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__PROPERTIES = YTYPED_COMPOUND_SUSPECT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__AUTHORIZATION_GROUP = YTYPED_COMPOUND_SUSPECT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__AUTHORIZATION_ID = YTYPED_COMPOUND_SUSPECT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__LABEL_I1_8N_KEY = YTYPED_COMPOUND_SUSPECT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Image I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__IMAGE_I1_8N_KEY = YTYPED_COMPOUND_SUSPECT__IMAGE_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoints</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__VALUE_BINDING_ENDPOINTS = YTYPED_COMPOUND_SUSPECT__VALUE_BINDING_ENDPOINTS;
+
+	/**
+	 * The feature id for the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__VISIBILITY_PROCESSORS = YTYPED_COMPOUND_SUSPECT__VISIBILITY_PROCESSORS;
+
+	/**
+	 * The feature id for the '<em><b>Commands</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__COMMANDS = YTYPED_COMPOUND_SUSPECT__COMMANDS;
+
+	/**
+	 * The feature id for the '<em><b>Assoc Newiated Elements</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__ASSOC_NEWIATED_ELEMENTS = YTYPED_COMPOUND_SUSPECT__ASSOC_NEWIATED_ELEMENTS;
+
+	/**
+	 * The feature id for the '<em><b>Associated Bindings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__ASSOCIATED_BINDINGS = YTYPED_COMPOUND_SUSPECT__ASSOCIATED_BINDINGS;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__LABEL = YTYPED_COMPOUND_SUSPECT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__TYPE_QUALIFIED_NAME = YTYPED_COMPOUND_SUSPECT__TYPE_QUALIFIED_NAME;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__TYPE = YTYPED_COMPOUND_SUSPECT__TYPE;
+
+	/**
+	 * The feature id for the '<em><b>Children</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__CHILDREN = YTYPED_COMPOUND_SUSPECT__CHILDREN;
+
+	/**
+	 * The number of structural features of the '<em>YSub Type Base Suspect</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT_FEATURE_COUNT = YTYPED_COMPOUND_SUSPECT_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSubTypeSuspectImpl <em>YSub Type Suspect</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YSubTypeSuspectImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSubTypeSuspect()
+	 * @generated
+	 */
+	int YSUB_TYPE_SUSPECT = 10;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__TAGS = YTYPED_COMPOUND_SUSPECT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__ID = YTYPED_COMPOUND_SUSPECT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__NAME = YTYPED_COMPOUND_SUSPECT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__PROPERTIES = YTYPED_COMPOUND_SUSPECT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__AUTHORIZATION_GROUP = YTYPED_COMPOUND_SUSPECT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__AUTHORIZATION_ID = YTYPED_COMPOUND_SUSPECT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__LABEL_I1_8N_KEY = YTYPED_COMPOUND_SUSPECT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Image I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__IMAGE_I1_8N_KEY = YTYPED_COMPOUND_SUSPECT__IMAGE_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoints</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__VALUE_BINDING_ENDPOINTS = YTYPED_COMPOUND_SUSPECT__VALUE_BINDING_ENDPOINTS;
+
+	/**
+	 * The feature id for the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__VISIBILITY_PROCESSORS = YTYPED_COMPOUND_SUSPECT__VISIBILITY_PROCESSORS;
+
+	/**
+	 * The feature id for the '<em><b>Commands</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__COMMANDS = YTYPED_COMPOUND_SUSPECT__COMMANDS;
+
+	/**
+	 * The feature id for the '<em><b>Assoc Newiated Elements</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__ASSOC_NEWIATED_ELEMENTS = YTYPED_COMPOUND_SUSPECT__ASSOC_NEWIATED_ELEMENTS;
+
+	/**
+	 * The feature id for the '<em><b>Associated Bindings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__ASSOCIATED_BINDINGS = YTYPED_COMPOUND_SUSPECT__ASSOCIATED_BINDINGS;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__LABEL = YTYPED_COMPOUND_SUSPECT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__TYPE_QUALIFIED_NAME = YTYPED_COMPOUND_SUSPECT__TYPE_QUALIFIED_NAME;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__TYPE = YTYPED_COMPOUND_SUSPECT__TYPE;
+
+	/**
+	 * The feature id for the '<em><b>Children</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__CHILDREN = YTYPED_COMPOUND_SUSPECT__CHILDREN;
+
+	/**
+	 * The feature id for the '<em><b>Bean Slot</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__BEAN_SLOT = YTYPED_COMPOUND_SUSPECT_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YSub Type Suspect</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT_FEATURE_COUNT = YTYPED_COMPOUND_SUSPECT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Layout</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__LAYOUT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Content</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__CONTENT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Active Suspect Infos</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>First Focus</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO__FIRST_FOCUS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>YLayouting Info</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YLAYOUTING_INFO_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__TAGS = CoreModelPackage.YELEMENT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__ID = CoreModelPackage.YELEMENT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__NAME = CoreModelPackage.YELEMENT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__PROPERTIES = CoreModelPackage.YELEMENT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Suspect</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__SUSPECT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Bindings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__BINDINGS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Next Focus</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__NEXT_FOCUS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Previous Focus</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__PREVIOUS_FOCUS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Target</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__TARGET = CoreModelPackage.YELEMENT_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO__VISIBILITY_PROCESSORS = CoreModelPackage.YELEMENT_FEATURE_COUNT + 5;
+
+	/**
+	 * The number of structural features of the '<em>YSuspect Info</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT_INFO_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Display Resolution Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Firmly Linked</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Unique Name Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>YBlob Upload Component</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YBLOB_UPLOAD_COMPONENT_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 5;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl <em>YCustom Decimal Field</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYCustomDecimalField()
+	 * @generated
+	 */
+	int YCUSTOM_DECIMAL_FIELD = 14;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__DATATYPE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>YCustom Decimal Field</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_FIELD_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl <em>YIcon Combo Box</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYIconComboBox()
+	 * @generated
+	 */
+	int YICON_COMBO_BOX = 15;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Collection Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Selection Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Use Bean Service</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__USE_BEAN_SERVICE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__DATATYPE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Selection</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__SELECTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__TYPE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Emf Ns URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__EMF_NS_URI = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 7;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__TYPE_QUALIFIED_NAME = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 8;
+
+	/**
+	 * The feature id for the '<em><b>Caption Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__CAPTION_PROPERTY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 9;
+
+	/**
+	 * The feature id for the '<em><b>Image Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__IMAGE_PROPERTY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 10;
+
+	/**
+	 * The feature id for the '<em><b>Description Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__DESCRIPTION_PROPERTY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 11;
+
+	/**
+	 * The feature id for the '<em><b>Description</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX__DESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 12;
+
+	/**
+	 * The number of structural features of the '<em>YIcon Combo Box</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YICON_COMBO_BOX_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 13;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YQuantityTextFieldImpl <em>YQuantity Text Field</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YQuantityTextFieldImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYQuantityTextField()
+	 * @generated
+	 */
+	int YQUANTITY_TEXT_FIELD = 16;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The number of structural features of the '<em>YQuantity Text Field</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TEXT_FIELD_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YCollectionSuspectImpl <em>YCollection Suspect</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YCollectionSuspectImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYCollectionSuspect()
+	 * @generated
+	 */
+	int YCOLLECTION_SUSPECT = 17;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__TAGS = YTYPED_SUSPECT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__ID = YTYPED_SUSPECT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__NAME = YTYPED_SUSPECT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__PROPERTIES = YTYPED_SUSPECT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__AUTHORIZATION_GROUP = YTYPED_SUSPECT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__AUTHORIZATION_ID = YTYPED_SUSPECT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__LABEL_I1_8N_KEY = YTYPED_SUSPECT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Image I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__IMAGE_I1_8N_KEY = YTYPED_SUSPECT__IMAGE_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoints</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__VALUE_BINDING_ENDPOINTS = YTYPED_SUSPECT__VALUE_BINDING_ENDPOINTS;
+
+	/**
+	 * The feature id for the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__VISIBILITY_PROCESSORS = YTYPED_SUSPECT__VISIBILITY_PROCESSORS;
+
+	/**
+	 * The feature id for the '<em><b>Commands</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__COMMANDS = YTYPED_SUSPECT__COMMANDS;
+
+	/**
+	 * The feature id for the '<em><b>Assoc Newiated Elements</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__ASSOC_NEWIATED_ELEMENTS = YTYPED_SUSPECT__ASSOC_NEWIATED_ELEMENTS;
+
+	/**
+	 * The feature id for the '<em><b>Associated Bindings</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__ASSOCIATED_BINDINGS = YTYPED_SUSPECT__ASSOCIATED_BINDINGS;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__LABEL = YTYPED_SUSPECT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__TYPE_QUALIFIED_NAME = YTYPED_SUSPECT__TYPE_QUALIFIED_NAME;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__TYPE = YTYPED_SUSPECT__TYPE;
+
+	/**
+	 * The feature id for the '<em><b>Columns</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__COLUMNS = YTYPED_SUSPECT_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YCollection Suspect</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT_FEATURE_COUNT = YTYPED_SUSPECT_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl <em>YColumn Info</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYColumnInfo()
+	 * @generated
+	 */
+	int YCOLUMN_INFO = 18;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLUMN_INFO__NAME = 0;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLUMN_INFO__TYPE = 1;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLUMN_INFO__TYPE_QUALIFIED_NAME = 2;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLUMN_INFO__PROPERTIES = 3;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLUMN_INFO__LABEL_I1_8N_KEY = 4;
+
+	/**
+	 * The number of structural features of the '<em>YColumn Info</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLUMN_INFO_FEATURE_COUNT = 5;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YContentSensitiveLayoutImpl <em>YContent Sensitive Layout</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YContentSensitiveLayoutImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYContentSensitiveLayout()
+	 * @generated
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT = 19;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__TAGS = CoreModelPackage.YLAYOUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__ID = CoreModelPackage.YLAYOUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__NAME = CoreModelPackage.YLAYOUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__PROPERTIES = CoreModelPackage.YLAYOUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__CSS_CLASS = CoreModelPackage.YLAYOUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__CSS_ID = CoreModelPackage.YLAYOUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__INITIAL_VISIBLE = CoreModelPackage.YLAYOUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__VISIBLE = CoreModelPackage.YLAYOUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__AUTHORIZATION_GROUP = CoreModelPackage.YLAYOUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__AUTHORIZATION_ID = CoreModelPackage.YLAYOUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__ORPHAN_DATATYPES = CoreModelPackage.YLAYOUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__ORPHAN_DATADESCRIPTIONS = CoreModelPackage.YLAYOUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__MEMENTO_ENABLED = CoreModelPackage.YLAYOUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__MEMENTO_ID = CoreModelPackage.YLAYOUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__LABEL = CoreModelPackage.YLAYOUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__LABEL_I1_8N_KEY = CoreModelPackage.YLAYOUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__INITIAL_EDITABLE = CoreModelPackage.YLAYOUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__EDITABLE = CoreModelPackage.YLAYOUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__INITIAL_ENABLED = CoreModelPackage.YLAYOUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__ENABLED = CoreModelPackage.YLAYOUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Elements</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__ELEMENTS = CoreModelPackage.YLAYOUT__ELEMENTS;
+
+	/**
+	 * The feature id for the '<em><b>Spacing</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__SPACING = CoreModelPackage.YLAYOUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Margin</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__MARGIN = CoreModelPackage.YLAYOUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>YContent Sensitive Layout</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT_FEATURE_COUNT = CoreModelPackage.YLAYOUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl <em>YRich Text Area</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYRichTextArea()
+	 * @generated
+	 */
+	int YRICH_TEXT_AREA = 20;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Blob Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__BLOB_VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Use Blob</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA__USE_BLOB = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>YRich Text Area</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YRICH_TEXT_AREA_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 5;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl <em>YPair Combo Box</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYPairComboBox()
+	 * @generated
+	 */
+	int YPAIR_COMBO_BOX = 25;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl <em>YMasked Text Field</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYMaskedTextField()
+	 * @generated
+	 */
+	int YMASKED_TEXT_FIELD = 21;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Mask</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD__MASK = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>YMasked Text Field</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_TEXT_FIELD_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl <em>YPrefixed Masked Text Field</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYPrefixedMaskedTextField()
+	 * @generated
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD = 22;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Mask</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__MASK = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Prefixes</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD__PREFIXES = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The number of structural features of the '<em>YPrefixed Masked Text Field</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPREFIXED_MASKED_TEXT_FIELD_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 5;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl <em>YMasked Numeric Field</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYMaskedNumericField()
+	 * @generated
+	 */
+	int YMASKED_NUMERIC_FIELD = 23;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Mask</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD__MASK = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>YMasked Numeric Field</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_NUMERIC_FIELD_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl <em>YMasked Decimal Field</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYMaskedDecimalField()
+	 * @generated
+	 */
+	int YMASKED_DECIMAL_FIELD = 24;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Value Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__VALUE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Mask</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__MASK = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Decimal Separator</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Grouping Separator</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 5;
+
+	/**
+	 * The number of structural features of the '<em>YMasked Decimal Field</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YMASKED_DECIMAL_FIELD_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__TAGS = ExtensionModelPackage.YINPUT__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__ID = ExtensionModelPackage.YINPUT__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__NAME = ExtensionModelPackage.YINPUT__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__PROPERTIES = ExtensionModelPackage.YINPUT__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Css Class</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__CSS_CLASS = ExtensionModelPackage.YINPUT__CSS_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Css ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__CSS_ID = ExtensionModelPackage.YINPUT__CSS_ID;
+
+	/**
+	 * The feature id for the '<em><b>Initial Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__INITIAL_VISIBLE = ExtensionModelPackage.YINPUT__INITIAL_VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Visible</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__VISIBLE = ExtensionModelPackage.YINPUT__VISIBLE;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Group</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__AUTHORIZATION_GROUP = ExtensionModelPackage.YINPUT__AUTHORIZATION_GROUP;
+
+	/**
+	 * The feature id for the '<em><b>Authorization Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__AUTHORIZATION_ID = ExtensionModelPackage.YINPUT__AUTHORIZATION_ID;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datatypes</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__ORPHAN_DATATYPES = ExtensionModelPackage.YINPUT__ORPHAN_DATATYPES;
+
+	/**
+	 * The feature id for the '<em><b>Orphan Datadescriptions</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__ORPHAN_DATADESCRIPTIONS = ExtensionModelPackage.YINPUT__ORPHAN_DATADESCRIPTIONS;
+
+	/**
+	 * The feature id for the '<em><b>Memento Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__MEMENTO_ENABLED = ExtensionModelPackage.YINPUT__MEMENTO_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Memento Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__MEMENTO_ID = ExtensionModelPackage.YINPUT__MEMENTO_ID;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__LABEL = ExtensionModelPackage.YINPUT__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__LABEL_I1_8N_KEY = ExtensionModelPackage.YINPUT__LABEL_I1_8N_KEY;
+
+	/**
+	 * The feature id for the '<em><b>Initial Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__INITIAL_EDITABLE = ExtensionModelPackage.YINPUT__INITIAL_EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Editable</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__EDITABLE = ExtensionModelPackage.YINPUT__EDITABLE;
+
+	/**
+	 * The feature id for the '<em><b>Initial Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__INITIAL_ENABLED = ExtensionModelPackage.YINPUT__INITIAL_ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Enabled</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__ENABLED = ExtensionModelPackage.YINPUT__ENABLED;
+
+	/**
+	 * The feature id for the '<em><b>Tab Index</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__TAB_INDEX = ExtensionModelPackage.YINPUT__TAB_INDEX;
+
+	/**
+	 * The feature id for the '<em><b>Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__VALIDATORS = ExtensionModelPackage.YINPUT__VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Internal Validators</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__INTERNAL_VALIDATORS = ExtensionModelPackage.YINPUT__INTERNAL_VALIDATORS;
+
+	/**
+	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__CONVERTER = ExtensionModelPackage.YINPUT__CONVERTER;
+
+	/**
+	 * The feature id for the '<em><b>Collection Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Selection Binding Endpoint</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Use Bean Service</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__USE_BEAN_SERVICE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__DATADESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__DATATYPE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Selection</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__SELECTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Collection</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__COLLECTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__TYPE = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 7;
+
+	/**
+	 * The feature id for the '<em><b>Emf Ns URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__EMF_NS_URI = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 8;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 9;
+
+	/**
+	 * The feature id for the '<em><b>Caption Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__CAPTION_PROPERTY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 10;
+
+	/**
+	 * The feature id for the '<em><b>Image Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__IMAGE_PROPERTY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 11;
+
+	/**
+	 * The feature id for the '<em><b>Description Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 12;
+
+	/**
+	 * The feature id for the '<em><b>Description</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX__DESCRIPTION = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 13;
+
+	/**
+	 * The number of structural features of the '<em>YPair Combo Box</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPAIR_COMBO_BOX_FEATURE_COUNT = ExtensionModelPackage.YINPUT_FEATURE_COUNT + 14;
+
+	/**
+	 * The meta object id for the '<em>Number</em>' data type.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see java.lang.Number
+	 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getNumber()
+	 * @generated
+	 */
+	int NUMBER = 26;
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout <em>YStrategy Layout</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YStrategy Layout</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout
+	 * @generated
+	 */
+	EClass getYStrategyLayout();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingStrategy <em>Layouting Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Layouting Strategy</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingStrategy()
+	 * @see #getYStrategyLayout()
+	 * @generated
+	 */
+	EReference getYStrategyLayout_LayoutingStrategy();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getFocusingStrategies <em>Focusing Strategies</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Focusing Strategies</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getFocusingStrategies()
+	 * @see #getYStrategyLayout()
+	 * @generated
+	 */
+	EReference getYStrategyLayout_FocusingStrategies();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getSuspects <em>Suspects</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Suspects</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getSuspects()
+	 * @see #getYStrategyLayout()
+	 * @generated
+	 */
+	EReference getYStrategyLayout_Suspects();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingInfo <em>Layouting Info</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Layouting Info</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingInfo()
+	 * @see #getYStrategyLayout()
+	 * @generated
+	 */
+	EReference getYStrategyLayout_LayoutingInfo();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getDefaultFocusingEnhancerId <em>Default Focusing Enhancer Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Default Focusing Enhancer Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getDefaultFocusingEnhancerId()
+	 * @see #getYStrategyLayout()
+	 * @generated
+	 */
+	EAttribute getYStrategyLayout_DefaultFocusingEnhancerId();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy <em>YLayouting Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YLayouting Strategy</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy
+	 * @generated
+	 */
+	EClass getYLayoutingStrategy();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy#getTrigger <em>Trigger</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Trigger</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy#getTrigger()
+	 * @see #getYLayoutingStrategy()
+	 * @generated
+	 */
+	EAttribute getYLayoutingStrategy_Trigger();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy <em>YDefault Layouting Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YDefault Layouting Strategy</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy
+	 * @generated
+	 */
+	EClass getYDefaultLayoutingStrategy();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy <em>YFocusing Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YFocusing Strategy</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YFocusingStrategy
+	 * @generated
+	 */
+	EClass getYFocusingStrategy();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getKeyStrokeDefinition <em>Key Stroke Definition</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Key Stroke Definition</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getKeyStrokeDefinition()
+	 * @see #getYFocusingStrategy()
+	 * @generated
+	 */
+	EReference getYFocusingStrategy_KeyStrokeDefinition();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getTempStrokeDefinition <em>Temp Stroke Definition</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Temp Stroke Definition</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getTempStrokeDefinition()
+	 * @see #getYFocusingStrategy()
+	 * @generated
+	 */
+	EReference getYFocusingStrategy_TempStrokeDefinition();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy <em>YDelegating Layouting Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YDelegating Layouting Strategy</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy
+	 * @generated
+	 */
+	EClass getYDelegatingLayoutingStrategy();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy#getDelegateStrategyId <em>Delegate Strategy Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Delegate Strategy Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy#getDelegateStrategyId()
+	 * @see #getYDelegatingLayoutingStrategy()
+	 * @generated
+	 */
+	EAttribute getYDelegatingLayoutingStrategy_DelegateStrategyId();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy <em>YDelegating Focusing Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YDelegating Focusing Strategy</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy
+	 * @generated
+	 */
+	EClass getYDelegatingFocusingStrategy();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy#getDelegateStrategyId <em>Delegate Strategy Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Delegate Strategy Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy#getDelegateStrategyId()
+	 * @see #getYDelegatingFocusingStrategy()
+	 * @generated
+	 */
+	EAttribute getYDelegatingFocusingStrategy_DelegateStrategyId();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YSuspect <em>YSuspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YSuspect</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect
+	 * @generated
+	 */
+	EClass getYSuspect();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getLabelI18nKey <em>Label I1 8n Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label I1 8n Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getLabelI18nKey()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EAttribute getYSuspect_LabelI18nKey();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getImageI18nKey <em>Image I1 8n Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Image I1 8n Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getImageI18nKey()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EAttribute getYSuspect_ImageI18nKey();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getValueBindingEndpoints <em>Value Binding Endpoints</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Value Binding Endpoints</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getValueBindingEndpoints()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EReference getYSuspect_ValueBindingEndpoints();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getVisibilityProcessors <em>Visibility Processors</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Visibility Processors</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getVisibilityProcessors()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EReference getYSuspect_VisibilityProcessors();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getCommands <em>Commands</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Commands</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getCommands()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EReference getYSuspect_Commands();
+
+	/**
+	 * Returns the meta object for the reference list '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getAssocNewiatedElements <em>Assoc Newiated Elements</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference list '<em>Assoc Newiated Elements</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getAssocNewiatedElements()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EReference getYSuspect_AssocNewiatedElements();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getAssociatedBindings <em>Associated Bindings</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Associated Bindings</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getAssociatedBindings()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EReference getYSuspect_AssociatedBindings();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getLabel <em>Label</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getLabel()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EAttribute getYSuspect_Label();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo <em>YLayouting Info</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YLayouting Info</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingInfo
+	 * @generated
+	 */
+	EClass getYLayoutingInfo();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getLayout <em>Layout</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Layout</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getLayout()
+	 * @see #getYLayoutingInfo()
+	 * @generated
+	 */
+	EReference getYLayoutingInfo_Layout();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getContent <em>Content</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Content</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getContent()
+	 * @see #getYLayoutingInfo()
+	 * @generated
+	 */
+	EReference getYLayoutingInfo_Content();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getActiveSuspectInfos <em>Active Suspect Infos</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Active Suspect Infos</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getActiveSuspectInfos()
+	 * @see #getYLayoutingInfo()
+	 * @generated
+	 */
+	EReference getYLayoutingInfo_ActiveSuspectInfos();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getFirstFocus <em>First Focus</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>First Focus</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getFirstFocus()
+	 * @see #getYLayoutingInfo()
+	 * @generated
+	 */
+	EReference getYLayoutingInfo_FirstFocus();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo <em>YSuspect Info</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YSuspect Info</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo
+	 * @generated
+	 */
+	EClass getYSuspectInfo();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getSuspect <em>Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Suspect</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getSuspect()
+	 * @see #getYSuspectInfo()
+	 * @generated
+	 */
+	EReference getYSuspectInfo_Suspect();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getBindings <em>Bindings</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Bindings</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getBindings()
+	 * @see #getYSuspectInfo()
+	 * @generated
+	 */
+	EReference getYSuspectInfo_Bindings();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getNextFocus <em>Next Focus</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Next Focus</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getNextFocus()
+	 * @see #getYSuspectInfo()
+	 * @generated
+	 */
+	EReference getYSuspectInfo_NextFocus();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getPreviousFocus <em>Previous Focus</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Previous Focus</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getPreviousFocus()
+	 * @see #getYSuspectInfo()
+	 * @generated
+	 */
+	EReference getYSuspectInfo_PreviousFocus();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getTarget <em>Target</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Target</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getTarget()
+	 * @see #getYSuspectInfo()
+	 * @generated
+	 */
+	EReference getYSuspectInfo_Target();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getVisibilityProcessors <em>Visibility Processors</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Visibility Processors</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getVisibilityProcessors()
+	 * @see #getYSuspectInfo()
+	 * @generated
+	 */
+	EReference getYSuspectInfo_VisibilityProcessors();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent <em>YBlob Upload Component</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YBlob Upload Component</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent
+	 * @generated
+	 */
+	EClass getYBlobUploadComponent();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getValue()
+	 * @see #getYBlobUploadComponent()
+	 * @generated
+	 */
+	EAttribute getYBlobUploadComponent_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getDisplayResolutionId <em>Display Resolution Id</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Display Resolution Id</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#getDisplayResolutionId()
+	 * @see #getYBlobUploadComponent()
+	 * @generated
+	 */
+	EAttribute getYBlobUploadComponent_DisplayResolutionId();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isFirmlyLinked <em>Firmly Linked</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Firmly Linked</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isFirmlyLinked()
+	 * @see #getYBlobUploadComponent()
+	 * @generated
+	 */
+	EAttribute getYBlobUploadComponent_FirmlyLinked();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isUniqueNameEnabled <em>Unique Name Enabled</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Unique Name Enabled</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent#isUniqueNameEnabled()
+	 * @see #getYBlobUploadComponent()
+	 * @generated
+	 */
+	EAttribute getYBlobUploadComponent_UniqueNameEnabled();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect <em>YTyped Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YTyped Suspect</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YTypedSuspect
+	 * @generated
+	 */
+	EClass getYTypedSuspect();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getTypeQualifiedName()
+	 * @see #getYTypedSuspect()
+	 * @generated
+	 */
+	EAttribute getYTypedSuspect_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getType()
+	 * @see #getYTypedSuspect()
+	 * @generated
+	 */
+	EAttribute getYTypedSuspect_Type();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect <em>YTyped Compound Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YTyped Compound Suspect</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect
+	 * @generated
+	 */
+	EClass getYTypedCompoundSuspect();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect#getChildren <em>Children</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Children</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect#getChildren()
+	 * @see #getYTypedCompoundSuspect()
+	 * @generated
+	 */
+	EReference getYTypedCompoundSuspect_Children();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect <em>YSub Type Base Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YSub Type Base Suspect</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect
+	 * @generated
+	 */
+	EClass getYSubTypeBaseSuspect();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect <em>YSub Type Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YSub Type Suspect</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect
+	 * @generated
+	 */
+	EClass getYSubTypeSuspect();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect#getBeanSlot <em>Bean Slot</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Bean Slot</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect#getBeanSlot()
+	 * @see #getYSubTypeSuspect()
+	 * @generated
+	 */
+	EReference getYSubTypeSuspect_BeanSlot();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField <em>YCustom Decimal Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YCustom Decimal Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCustomDecimalField
+	 * @generated
+	 */
+	EClass getYCustomDecimalField();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatatype <em>Datatype</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datatype</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatatype()
+	 * @see #getYCustomDecimalField()
+	 * @generated
+	 */
+	EReference getYCustomDecimalField_Datatype();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getDatadescription()
+	 * @see #getYCustomDecimalField()
+	 * @generated
+	 */
+	EReference getYCustomDecimalField_Datadescription();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCustomDecimalField#getValue()
+	 * @see #getYCustomDecimalField()
+	 * @generated
+	 */
+	EAttribute getYCustomDecimalField_Value();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox <em>YIcon Combo Box</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YIcon Combo Box</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox
+	 * @generated
+	 */
+	EClass getYIconComboBox();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatadescription()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EReference getYIconComboBox_Datadescription();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatatype <em>Datatype</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datatype</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatatype()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EReference getYIconComboBox_Datatype();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getSelection <em>Selection</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Selection</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getSelection()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_Selection();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getType()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_Type();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getEmfNsURI <em>Emf Ns URI</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Emf Ns URI</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getEmfNsURI()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_EmfNsURI();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getTypeQualifiedName()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getCaptionProperty <em>Caption Property</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Caption Property</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getCaptionProperty()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_CaptionProperty();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getImageProperty <em>Image Property</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Image Property</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getImageProperty()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_ImageProperty();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescriptionProperty <em>Description Property</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Description Property</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescriptionProperty()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_DescriptionProperty();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescription <em>Description</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Description</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescription()
+	 * @see #getYIconComboBox()
+	 * @generated
+	 */
+	EAttribute getYIconComboBox_Description();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField <em>YQuantity Text Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YQuantity Text Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YQuantityTextField
+	 * @generated
+	 */
+	EClass getYQuantityTextField();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getDatadescription()
+	 * @see #getYQuantityTextField()
+	 * @generated
+	 */
+	EReference getYQuantityTextField_Datadescription();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getValue()
+	 * @see #getYQuantityTextField()
+	 * @generated
+	 */
+	EAttribute getYQuantityTextField_Value();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YCollectionSuspect <em>YCollection Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YCollection Suspect</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCollectionSuspect
+	 * @generated
+	 */
+	EClass getYCollectionSuspect();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.YCollectionSuspect#getColumns <em>Columns</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Columns</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCollectionSuspect#getColumns()
+	 * @see #getYCollectionSuspect()
+	 * @generated
+	 */
+	EReference getYCollectionSuspect_Columns();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo <em>YColumn Info</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YColumn Info</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YColumnInfo
+	 * @generated
+	 */
+	EClass getYColumnInfo();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getName <em>Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YColumnInfo#getName()
+	 * @see #getYColumnInfo()
+	 * @generated
+	 */
+	EAttribute getYColumnInfo_Name();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YColumnInfo#getType()
+	 * @see #getYColumnInfo()
+	 * @generated
+	 */
+	EAttribute getYColumnInfo_Type();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YColumnInfo#getTypeQualifiedName()
+	 * @see #getYColumnInfo()
+	 * @generated
+	 */
+	EAttribute getYColumnInfo_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for the map '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getProperties <em>Properties</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the map '<em>Properties</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YColumnInfo#getProperties()
+	 * @see #getYColumnInfo()
+	 * @generated
+	 */
+	EReference getYColumnInfo_Properties();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo#getLabelI18nKey <em>Label I1 8n Key</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label I1 8n Key</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YColumnInfo#getLabelI18nKey()
+	 * @see #getYColumnInfo()
+	 * @generated
+	 */
+	EAttribute getYColumnInfo_LabelI18nKey();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout <em>YContent Sensitive Layout</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YContent Sensitive Layout</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout
+	 * @generated
+	 */
+	EClass getYContentSensitiveLayout();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea <em>YRich Text Area</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YRich Text Area</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YRichTextArea
+	 * @generated
+	 */
+	EClass getYRichTextArea();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YRichTextArea#getDatadescription()
+	 * @see #getYRichTextArea()
+	 * @generated
+	 */
+	EReference getYRichTextArea_Datadescription();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getBlobValue <em>Blob Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Blob Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YRichTextArea#getBlobValue()
+	 * @see #getYRichTextArea()
+	 * @generated
+	 */
+	EAttribute getYRichTextArea_BlobValue();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YRichTextArea#getValue()
+	 * @see #getYRichTextArea()
+	 * @generated
+	 */
+	EAttribute getYRichTextArea_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#isUseBlob <em>Use Blob</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Use Blob</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YRichTextArea#isUseBlob()
+	 * @see #getYRichTextArea()
+	 * @generated
+	 */
+	EAttribute getYRichTextArea_UseBlob();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField <em>YMasked Text Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YMasked Text Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedTextField
+	 * @generated
+	 */
+	EClass getYMaskedTextField();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getDatadescription()
+	 * @see #getYMaskedTextField()
+	 * @generated
+	 */
+	EReference getYMaskedTextField_Datadescription();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getValue()
+	 * @see #getYMaskedTextField()
+	 * @generated
+	 */
+	EAttribute getYMaskedTextField_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getMask <em>Mask</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Mask</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getMask()
+	 * @see #getYMaskedTextField()
+	 * @generated
+	 */
+	EAttribute getYMaskedTextField_Mask();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField <em>YPrefixed Masked Text Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YPrefixed Masked Text Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField
+	 * @generated
+	 */
+	EClass getYPrefixedMaskedTextField();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getDatadescription()
+	 * @see #getYPrefixedMaskedTextField()
+	 * @generated
+	 */
+	EReference getYPrefixedMaskedTextField_Datadescription();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getValue()
+	 * @see #getYPrefixedMaskedTextField()
+	 * @generated
+	 */
+	EAttribute getYPrefixedMaskedTextField_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getMask <em>Mask</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Mask</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getMask()
+	 * @see #getYPrefixedMaskedTextField()
+	 * @generated
+	 */
+	EAttribute getYPrefixedMaskedTextField_Mask();
+
+	/**
+	 * Returns the meta object for the map '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getPrefixes <em>Prefixes</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the map '<em>Prefixes</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getPrefixes()
+	 * @see #getYPrefixedMaskedTextField()
+	 * @generated
+	 */
+	EReference getYPrefixedMaskedTextField_Prefixes();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField <em>YMasked Numeric Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YMasked Numeric Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedNumericField
+	 * @generated
+	 */
+	EClass getYMaskedNumericField();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getDatadescription()
+	 * @see #getYMaskedNumericField()
+	 * @generated
+	 */
+	EReference getYMaskedNumericField_Datadescription();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getValue()
+	 * @see #getYMaskedNumericField()
+	 * @generated
+	 */
+	EAttribute getYMaskedNumericField_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getMask <em>Mask</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Mask</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getMask()
+	 * @see #getYMaskedNumericField()
+	 * @generated
+	 */
+	EAttribute getYMaskedNumericField_Mask();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField <em>YMasked Decimal Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YMasked Decimal Field</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField
+	 * @generated
+	 */
+	EClass getYMaskedDecimalField();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDatadescription()
+	 * @see #getYMaskedDecimalField()
+	 * @generated
+	 */
+	EReference getYMaskedDecimalField_Datadescription();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getValue()
+	 * @see #getYMaskedDecimalField()
+	 * @generated
+	 */
+	EAttribute getYMaskedDecimalField_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getMask <em>Mask</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Mask</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getMask()
+	 * @see #getYMaskedDecimalField()
+	 * @generated
+	 */
+	EAttribute getYMaskedDecimalField_Mask();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDecimalSeparator <em>Decimal Separator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Decimal Separator</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDecimalSeparator()
+	 * @see #getYMaskedDecimalField()
+	 * @generated
+	 */
+	EAttribute getYMaskedDecimalField_DecimalSeparator();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getGroupingSeparator <em>Grouping Separator</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Grouping Separator</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getGroupingSeparator()
+	 * @see #getYMaskedDecimalField()
+	 * @generated
+	 */
+	EAttribute getYMaskedDecimalField_GroupingSeparator();
+
+	/**
+	 * Returns the meta object for data type '{@link java.lang.Number <em>Number</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for data type '<em>Number</em>'.
+	 * @see java.lang.Number
+	 * @model instanceClass="java.lang.Number"
+	 * @generated
+	 */
+	EDataType getNumber();
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox <em>YPair Combo Box</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YPair Combo Box</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox
+	 * @generated
+	 */
+	EClass getYPairComboBox();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatadescription <em>Datadescription</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datadescription</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatadescription()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EReference getYPairComboBox_Datadescription();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatatype <em>Datatype</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datatype</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatatype()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EReference getYPairComboBox_Datatype();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getSelection <em>Selection</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Selection</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getSelection()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_Selection();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getCollection <em>Collection</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute list '<em>Collection</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getCollection()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_Collection();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getType()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_Type();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getEmfNsURI <em>Emf Ns URI</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Emf Ns URI</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getEmfNsURI()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_EmfNsURI();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getTypeQualifiedName()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getCaptionProperty <em>Caption Property</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Caption Property</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getCaptionProperty()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_CaptionProperty();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getImageProperty <em>Image Property</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Image Property</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getImageProperty()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_ImageProperty();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescriptionProperty <em>Description Property</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Description Property</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescriptionProperty()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_DescriptionProperty();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescription <em>Description</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Description</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescription()
+	 * @see #getYPairComboBox()
+	 * @generated
+	 */
+	EAttribute getYPairComboBox_Description();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	YECviewFactory getYECviewFactory();
+
+	/**
+	 * <!-- begin-user-doc --> Defines literals for the meta objects that
+	 * represent
+	 * <ul>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl <em>YStrategy Layout</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYStrategyLayout()
+		 * @generated
+		 */
+		EClass YSTRATEGY_LAYOUT = eINSTANCE.getYStrategyLayout();
+
+		/**
+		 * The meta object literal for the '<em><b>Layouting Strategy</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY = eINSTANCE.getYStrategyLayout_LayoutingStrategy();
+
+		/**
+		 * The meta object literal for the '<em><b>Focusing Strategies</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES = eINSTANCE.getYStrategyLayout_FocusingStrategies();
+
+		/**
+		 * The meta object literal for the '<em><b>Suspects</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSTRATEGY_LAYOUT__SUSPECTS = eINSTANCE.getYStrategyLayout_Suspects();
+
+		/**
+		 * The meta object literal for the '<em><b>Layouting Info</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSTRATEGY_LAYOUT__LAYOUTING_INFO = eINSTANCE.getYStrategyLayout_LayoutingInfo();
+
+		/**
+		 * The meta object literal for the '<em><b>Default Focusing Enhancer Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID = eINSTANCE.getYStrategyLayout_DefaultFocusingEnhancerId();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl <em>YLayouting Strategy</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYLayoutingStrategy()
+		 * @generated
+		 */
+		EClass YLAYOUTING_STRATEGY = eINSTANCE.getYLayoutingStrategy();
+
+		/**
+		 * The meta object literal for the '<em><b>Trigger</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YLAYOUTING_STRATEGY__TRIGGER = eINSTANCE.getYLayoutingStrategy_Trigger();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YDefaultLayoutingStrategyImpl <em>YDefault Layouting Strategy</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YDefaultLayoutingStrategyImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYDefaultLayoutingStrategy()
+		 * @generated
+		 */
+		EClass YDEFAULT_LAYOUTING_STRATEGY = eINSTANCE.getYDefaultLayoutingStrategy();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl <em>YFocusing Strategy</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYFocusingStrategy()
+		 * @generated
+		 */
+		EClass YFOCUSING_STRATEGY = eINSTANCE.getYFocusingStrategy();
+
+		/**
+		 * The meta object literal for the '<em><b>Key Stroke Definition</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION = eINSTANCE.getYFocusingStrategy_KeyStrokeDefinition();
+
+		/**
+		 * The meta object literal for the '<em><b>Temp Stroke Definition</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION = eINSTANCE.getYFocusingStrategy_TempStrokeDefinition();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YDelegatingLayoutingStrategyImpl <em>YDelegating Layouting Strategy</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YDelegatingLayoutingStrategyImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYDelegatingLayoutingStrategy()
+		 * @generated
+		 */
+		EClass YDELEGATING_LAYOUTING_STRATEGY = eINSTANCE.getYDelegatingLayoutingStrategy();
+
+		/**
+		 * The meta object literal for the '<em><b>Delegate Strategy Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID = eINSTANCE.getYDelegatingLayoutingStrategy_DelegateStrategyId();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YDelegatingFocusingStrategyImpl <em>YDelegating Focusing Strategy</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YDelegatingFocusingStrategyImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYDelegatingFocusingStrategy()
+		 * @generated
+		 */
+		EClass YDELEGATING_FOCUSING_STRATEGY = eINSTANCE.getYDelegatingFocusingStrategy();
+
+		/**
+		 * The meta object literal for the '<em><b>Delegate Strategy Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID = eINSTANCE.getYDelegatingFocusingStrategy_DelegateStrategyId();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl <em>YSuspect</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSuspect()
+		 * @generated
+		 */
+		EClass YSUSPECT = eINSTANCE.getYSuspect();
+
+		/**
+		 * The meta object literal for the '<em><b>Label I1 8n Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSUSPECT__LABEL_I1_8N_KEY = eINSTANCE.getYSuspect_LabelI18nKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Image I1 8n Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSUSPECT__IMAGE_I1_8N_KEY = eINSTANCE.getYSuspect_ImageI18nKey();
+
+		/**
+		 * The meta object literal for the '<em><b>Value Binding Endpoints</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT__VALUE_BINDING_ENDPOINTS = eINSTANCE.getYSuspect_ValueBindingEndpoints();
+
+		/**
+		 * The meta object literal for the '<em><b>Visibility Processors</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT__VISIBILITY_PROCESSORS = eINSTANCE.getYSuspect_VisibilityProcessors();
+
+		/**
+		 * The meta object literal for the '<em><b>Commands</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT__COMMANDS = eINSTANCE.getYSuspect_Commands();
+
+		/**
+		 * The meta object literal for the '<em><b>Assoc Newiated Elements</b></em>' reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT__ASSOC_NEWIATED_ELEMENTS = eINSTANCE.getYSuspect_AssocNewiatedElements();
+
+		/**
+		 * The meta object literal for the '<em><b>Associated Bindings</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT__ASSOCIATED_BINDINGS = eINSTANCE.getYSuspect_AssociatedBindings();
+
+		/**
+		 * The meta object literal for the '<em><b>Label</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSUSPECT__LABEL = eINSTANCE.getYSuspect_Label();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl <em>YLayouting Info</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYLayoutingInfo()
+		 * @generated
+		 */
+		EClass YLAYOUTING_INFO = eINSTANCE.getYLayoutingInfo();
+
+		/**
+		 * The meta object literal for the '<em><b>Layout</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YLAYOUTING_INFO__LAYOUT = eINSTANCE.getYLayoutingInfo_Layout();
+
+		/**
+		 * The meta object literal for the '<em><b>Content</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YLAYOUTING_INFO__CONTENT = eINSTANCE.getYLayoutingInfo_Content();
+
+		/**
+		 * The meta object literal for the '<em><b>Active Suspect Infos</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS = eINSTANCE.getYLayoutingInfo_ActiveSuspectInfos();
+
+		/**
+		 * The meta object literal for the '<em><b>First Focus</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YLAYOUTING_INFO__FIRST_FOCUS = eINSTANCE.getYLayoutingInfo_FirstFocus();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl <em>YSuspect Info</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSuspectInfo()
+		 * @generated
+		 */
+		EClass YSUSPECT_INFO = eINSTANCE.getYSuspectInfo();
+
+		/**
+		 * The meta object literal for the '<em><b>Suspect</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT_INFO__SUSPECT = eINSTANCE.getYSuspectInfo_Suspect();
+
+		/**
+		 * The meta object literal for the '<em><b>Bindings</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT_INFO__BINDINGS = eINSTANCE.getYSuspectInfo_Bindings();
+
+		/**
+		 * The meta object literal for the '<em><b>Next Focus</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT_INFO__NEXT_FOCUS = eINSTANCE.getYSuspectInfo_NextFocus();
+
+		/**
+		 * The meta object literal for the '<em><b>Previous Focus</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT_INFO__PREVIOUS_FOCUS = eINSTANCE.getYSuspectInfo_PreviousFocus();
+
+		/**
+		 * The meta object literal for the '<em><b>Target</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT_INFO__TARGET = eINSTANCE.getYSuspectInfo_Target();
+
+		/**
+		 * The meta object literal for the '<em><b>Visibility Processors</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUSPECT_INFO__VISIBILITY_PROCESSORS = eINSTANCE.getYSuspectInfo_VisibilityProcessors();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl <em>YBlob Upload Component</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYBlobUploadComponent()
+		 * @generated
+		 */
+		EClass YBLOB_UPLOAD_COMPONENT = eINSTANCE.getYBlobUploadComponent();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YBLOB_UPLOAD_COMPONENT__VALUE = eINSTANCE.getYBlobUploadComponent_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Display Resolution Id</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID = eINSTANCE.getYBlobUploadComponent_DisplayResolutionId();
+
+		/**
+		 * The meta object literal for the '<em><b>Firmly Linked</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED = eINSTANCE.getYBlobUploadComponent_FirmlyLinked();
+
+		/**
+		 * The meta object literal for the '<em><b>Unique Name Enabled</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED = eINSTANCE.getYBlobUploadComponent_UniqueNameEnabled();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YTypedSuspectImpl <em>YTyped Suspect</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YTypedSuspectImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYTypedSuspect()
+		 * @generated
+		 */
+		EClass YTYPED_SUSPECT = eINSTANCE.getYTypedSuspect();
+
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YTYPED_SUSPECT__TYPE_QUALIFIED_NAME = eINSTANCE.getYTypedSuspect_TypeQualifiedName();
+
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YTYPED_SUSPECT__TYPE = eINSTANCE.getYTypedSuspect_Type();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YTypedCompoundSuspectImpl <em>YTyped Compound Suspect</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YTypedCompoundSuspectImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYTypedCompoundSuspect()
+		 * @generated
+		 */
+		EClass YTYPED_COMPOUND_SUSPECT = eINSTANCE.getYTypedCompoundSuspect();
+
+		/**
+		 * The meta object literal for the '<em><b>Children</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YTYPED_COMPOUND_SUSPECT__CHILDREN = eINSTANCE.getYTypedCompoundSuspect_Children();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSubTypeBaseSuspectImpl <em>YSub Type Base Suspect</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YSubTypeBaseSuspectImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSubTypeBaseSuspect()
+		 * @generated
+		 */
+		EClass YSUB_TYPE_BASE_SUSPECT = eINSTANCE.getYSubTypeBaseSuspect();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YSubTypeSuspectImpl <em>YSub Type Suspect</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YSubTypeSuspectImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYSubTypeSuspect()
+		 * @generated
+		 */
+		EClass YSUB_TYPE_SUSPECT = eINSTANCE.getYSubTypeSuspect();
+
+		/**
+		 * The meta object literal for the '<em><b>Bean Slot</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUB_TYPE_SUSPECT__BEAN_SLOT = eINSTANCE.getYSubTypeSuspect_BeanSlot();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl <em>YCustom Decimal Field</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYCustomDecimalField()
+		 * @generated
+		 */
+		EClass YCUSTOM_DECIMAL_FIELD = eINSTANCE.getYCustomDecimalField();
+
+		/**
+		 * The meta object literal for the '<em><b>Datatype</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YCUSTOM_DECIMAL_FIELD__DATATYPE = eINSTANCE.getYCustomDecimalField_Datatype();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION = eINSTANCE.getYCustomDecimalField_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YCUSTOM_DECIMAL_FIELD__VALUE = eINSTANCE.getYCustomDecimalField_Value();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl <em>YIcon Combo Box</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYIconComboBox()
+		 * @generated
+		 */
+		EClass YICON_COMBO_BOX = eINSTANCE.getYIconComboBox();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YICON_COMBO_BOX__DATADESCRIPTION = eINSTANCE.getYIconComboBox_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Datatype</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YICON_COMBO_BOX__DATATYPE = eINSTANCE.getYIconComboBox_Datatype();
+
+		/**
+		 * The meta object literal for the '<em><b>Selection</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__SELECTION = eINSTANCE.getYIconComboBox_Selection();
+
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__TYPE = eINSTANCE.getYIconComboBox_Type();
+
+		/**
+		 * The meta object literal for the '<em><b>Emf Ns URI</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__EMF_NS_URI = eINSTANCE.getYIconComboBox_EmfNsURI();
+
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__TYPE_QUALIFIED_NAME = eINSTANCE.getYIconComboBox_TypeQualifiedName();
+
+		/**
+		 * The meta object literal for the '<em><b>Caption Property</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__CAPTION_PROPERTY = eINSTANCE.getYIconComboBox_CaptionProperty();
+
+		/**
+		 * The meta object literal for the '<em><b>Image Property</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__IMAGE_PROPERTY = eINSTANCE.getYIconComboBox_ImageProperty();
+
+		/**
+		 * The meta object literal for the '<em><b>Description Property</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__DESCRIPTION_PROPERTY = eINSTANCE.getYIconComboBox_DescriptionProperty();
+
+		/**
+		 * The meta object literal for the '<em><b>Description</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YICON_COMBO_BOX__DESCRIPTION = eINSTANCE.getYIconComboBox_Description();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YQuantityTextFieldImpl <em>YQuantity Text Field</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YQuantityTextFieldImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYQuantityTextField()
+		 * @generated
+		 */
+		EClass YQUANTITY_TEXT_FIELD = eINSTANCE.getYQuantityTextField();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YQUANTITY_TEXT_FIELD__DATADESCRIPTION = eINSTANCE.getYQuantityTextField_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YQUANTITY_TEXT_FIELD__VALUE = eINSTANCE.getYQuantityTextField_Value();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YCollectionSuspectImpl <em>YCollection Suspect</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YCollectionSuspectImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYCollectionSuspect()
+		 * @generated
+		 */
+		EClass YCOLLECTION_SUSPECT = eINSTANCE.getYCollectionSuspect();
+
+		/**
+		 * The meta object literal for the '<em><b>Columns</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YCOLLECTION_SUSPECT__COLUMNS = eINSTANCE.getYCollectionSuspect_Columns();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl <em>YColumn Info</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYColumnInfo()
+		 * @generated
+		 */
+		EClass YCOLUMN_INFO = eINSTANCE.getYColumnInfo();
+
+		/**
+		 * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YCOLUMN_INFO__NAME = eINSTANCE.getYColumnInfo_Name();
+
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YCOLUMN_INFO__TYPE = eINSTANCE.getYColumnInfo_Type();
+
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YCOLUMN_INFO__TYPE_QUALIFIED_NAME = eINSTANCE.getYColumnInfo_TypeQualifiedName();
+
+		/**
+		 * The meta object literal for the '<em><b>Properties</b></em>' map feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YCOLUMN_INFO__PROPERTIES = eINSTANCE.getYColumnInfo_Properties();
+
+		/**
+		 * The meta object literal for the '<em><b>Label I1 8n Key</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YCOLUMN_INFO__LABEL_I1_8N_KEY = eINSTANCE.getYColumnInfo_LabelI18nKey();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YContentSensitiveLayoutImpl <em>YContent Sensitive Layout</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YContentSensitiveLayoutImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYContentSensitiveLayout()
+		 * @generated
+		 */
+		EClass YCONTENT_SENSITIVE_LAYOUT = eINSTANCE.getYContentSensitiveLayout();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl <em>YRich Text Area</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYRichTextArea()
+		 * @generated
+		 */
+		EClass YRICH_TEXT_AREA = eINSTANCE.getYRichTextArea();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YRICH_TEXT_AREA__DATADESCRIPTION = eINSTANCE.getYRichTextArea_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Blob Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YRICH_TEXT_AREA__BLOB_VALUE = eINSTANCE.getYRichTextArea_BlobValue();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YRICH_TEXT_AREA__VALUE = eINSTANCE.getYRichTextArea_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Use Blob</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YRICH_TEXT_AREA__USE_BLOB = eINSTANCE.getYRichTextArea_UseBlob();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl <em>YMasked Text Field</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYMaskedTextField()
+		 * @generated
+		 */
+		EClass YMASKED_TEXT_FIELD = eINSTANCE.getYMaskedTextField();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YMASKED_TEXT_FIELD__DATADESCRIPTION = eINSTANCE.getYMaskedTextField_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_TEXT_FIELD__VALUE = eINSTANCE.getYMaskedTextField_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Mask</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_TEXT_FIELD__MASK = eINSTANCE.getYMaskedTextField_Mask();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl <em>YPrefixed Masked Text Field</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYPrefixedMaskedTextField()
+		 * @generated
+		 */
+		EClass YPREFIXED_MASKED_TEXT_FIELD = eINSTANCE.getYPrefixedMaskedTextField();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION = eINSTANCE.getYPrefixedMaskedTextField_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPREFIXED_MASKED_TEXT_FIELD__VALUE = eINSTANCE.getYPrefixedMaskedTextField_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Mask</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPREFIXED_MASKED_TEXT_FIELD__MASK = eINSTANCE.getYPrefixedMaskedTextField_Mask();
+
+		/**
+		 * The meta object literal for the '<em><b>Prefixes</b></em>' map feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YPREFIXED_MASKED_TEXT_FIELD__PREFIXES = eINSTANCE.getYPrefixedMaskedTextField_Prefixes();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl <em>YMasked Numeric Field</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYMaskedNumericField()
+		 * @generated
+		 */
+		EClass YMASKED_NUMERIC_FIELD = eINSTANCE.getYMaskedNumericField();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YMASKED_NUMERIC_FIELD__DATADESCRIPTION = eINSTANCE.getYMaskedNumericField_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_NUMERIC_FIELD__VALUE = eINSTANCE.getYMaskedNumericField_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Mask</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_NUMERIC_FIELD__MASK = eINSTANCE.getYMaskedNumericField_Mask();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl <em>YMasked Decimal Field</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYMaskedDecimalField()
+		 * @generated
+		 */
+		EClass YMASKED_DECIMAL_FIELD = eINSTANCE.getYMaskedDecimalField();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YMASKED_DECIMAL_FIELD__DATADESCRIPTION = eINSTANCE.getYMaskedDecimalField_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_DECIMAL_FIELD__VALUE = eINSTANCE.getYMaskedDecimalField_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Mask</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_DECIMAL_FIELD__MASK = eINSTANCE.getYMaskedDecimalField_Mask();
+
+		/**
+		 * The meta object literal for the '<em><b>Decimal Separator</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR = eINSTANCE.getYMaskedDecimalField_DecimalSeparator();
+
+		/**
+		 * The meta object literal for the '<em><b>Grouping Separator</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR = eINSTANCE.getYMaskedDecimalField_GroupingSeparator();
+
+		/**
+		 * The meta object literal for the '<em>Number</em>' data type.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see java.lang.Number
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getNumber()
+		 * @generated
+		 */
+		EDataType NUMBER = eINSTANCE.getNumber();
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl <em>YPair Combo Box</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl#getYPairComboBox()
+		 * @generated
+		 */
+		EClass YPAIR_COMBO_BOX = eINSTANCE.getYPairComboBox();
+
+		/**
+		 * The meta object literal for the '<em><b>Datadescription</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YPAIR_COMBO_BOX__DATADESCRIPTION = eINSTANCE.getYPairComboBox_Datadescription();
+
+		/**
+		 * The meta object literal for the '<em><b>Datatype</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YPAIR_COMBO_BOX__DATATYPE = eINSTANCE.getYPairComboBox_Datatype();
+
+		/**
+		 * The meta object literal for the '<em><b>Selection</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__SELECTION = eINSTANCE.getYPairComboBox_Selection();
+
+		/**
+		 * The meta object literal for the '<em><b>Collection</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__COLLECTION = eINSTANCE.getYPairComboBox_Collection();
+
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__TYPE = eINSTANCE.getYPairComboBox_Type();
+
+		/**
+		 * The meta object literal for the '<em><b>Emf Ns URI</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__EMF_NS_URI = eINSTANCE.getYPairComboBox_EmfNsURI();
+
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME = eINSTANCE.getYPairComboBox_TypeQualifiedName();
+
+		/**
+		 * The meta object literal for the '<em><b>Caption Property</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__CAPTION_PROPERTY = eINSTANCE.getYPairComboBox_CaptionProperty();
+
+		/**
+		 * The meta object literal for the '<em><b>Image Property</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__IMAGE_PROPERTY = eINSTANCE.getYPairComboBox_ImageProperty();
+
+		/**
+		 * The meta object literal for the '<em><b>Description Property</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY = eINSTANCE.getYPairComboBox_DescriptionProperty();
+
+		/**
+		 * The meta object literal for the '<em><b>Description</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPAIR_COMBO_BOX__DESCRIPTION = eINSTANCE.getYPairComboBox_Description();
+
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YFocusingStrategy.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YFocusingStrategy.java
new file mode 100644
index 0000000..1bbe324
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YFocusingStrategy.java
@@ -0,0 +1,107 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YKeyStrokeDefinition;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YFocusing Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getKeyStrokeDefinition <em>Key Stroke Definition</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getTempStrokeDefinition <em>Temp Stroke Definition</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYFocusingStrategy()
+ * @model
+ * @generated
+ */
+public interface YFocusingStrategy extends YElement {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Key Stroke Definition</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Key Stroke Definition</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Key Stroke Definition</em>' containment reference.
+	 * @see #setKeyStrokeDefinition(YKeyStrokeDefinition)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYFocusingStrategy_KeyStrokeDefinition()
+	 * @model containment="true"
+	 * @generated
+	 */
+	YKeyStrokeDefinition getKeyStrokeDefinition();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getKeyStrokeDefinition <em>Key Stroke Definition</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Key Stroke Definition</em>' containment reference.
+	 * @see #getKeyStrokeDefinition()
+	 * @generated
+	 */
+	void setKeyStrokeDefinition(YKeyStrokeDefinition value);
+
+	/**
+	 * Returns the value of the '<em><b>Temp Stroke Definition</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Temp Stroke Definition</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Temp Stroke Definition</em>' containment reference.
+	 * @see #setTempStrokeDefinition(YKeyStrokeDefinition)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYFocusingStrategy_TempStrokeDefinition()
+	 * @model containment="true" transient="true"
+	 * @generated
+	 */
+	YKeyStrokeDefinition getTempStrokeDefinition();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy#getTempStrokeDefinition <em>Temp Stroke Definition</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Temp Stroke Definition</em>' containment reference.
+	 * @see #getTempStrokeDefinition()
+	 * @generated
+	 */
+	void setTempStrokeDefinition(YKeyStrokeDefinition value);
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the view
+	 * @model kind="operation"
+	 * @generated
+	 */
+	YView getView();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YIconComboBox.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YIconComboBox.java
new file mode 100644
index 0000000..f19c324
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YIconComboBox.java
@@ -0,0 +1,317 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YComboBoxDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YIcon Combo Box</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatatype <em>Datatype</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getSelection <em>Selection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getEmfNsURI <em>Emf Ns URI</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getCaptionProperty <em>Caption Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getImageProperty <em>Image Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescriptionProperty <em>Description Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescription <em>Description</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox()
+ * @model
+ * @generated
+ */
+public interface YIconComboBox extends YInput, YCollectionBindable, YSelectionBindable, YBeanServiceConsumer {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datatype</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datatype</em>' reference.
+	 * @see #setDatatype(YComboBoxDatatype)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_Datatype()
+	 * @model
+	 * @generated
+	 */
+	YComboBoxDatatype getDatatype();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDatatype <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datatype</em>' reference.
+	 * @see #getDatatype()
+	 * @generated
+	 */
+	void setDatatype(YComboBoxDatatype value);
+
+	/**
+	 * Returns the value of the '<em><b>Selection</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Selection</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Selection</em>' attribute.
+	 * @see #setSelection(Object)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_Selection()
+	 * @model transient="true"
+	 * @generated
+	 */
+	Object getSelection();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getSelection <em>Selection</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Selection</em>' attribute.
+	 * @see #getSelection()
+	 * @generated
+	 */
+	void setSelection(Object value);
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+	/**
+	 * Returns the value of the '<em><b>Emf Ns URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Emf Ns URI</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Emf Ns URI</em>' attribute.
+	 * @see #setEmfNsURI(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_EmfNsURI()
+	 * @model
+	 * @generated
+	 */
+	String getEmfNsURI();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getEmfNsURI <em>Emf Ns URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Emf Ns URI</em>' attribute.
+	 * @see #getEmfNsURI()
+	 * @generated
+	 */
+	void setEmfNsURI(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Caption Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Caption Property</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Caption Property</em>' attribute.
+	 * @see #setCaptionProperty(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_CaptionProperty()
+	 * @model
+	 * @generated
+	 */
+	String getCaptionProperty();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getCaptionProperty <em>Caption Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Caption Property</em>' attribute.
+	 * @see #getCaptionProperty()
+	 * @generated
+	 */
+	void setCaptionProperty(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Image Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Image Property</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Image Property</em>' attribute.
+	 * @see #setImageProperty(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_ImageProperty()
+	 * @model
+	 * @generated
+	 */
+	String getImageProperty();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getImageProperty <em>Image Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Image Property</em>' attribute.
+	 * @see #getImageProperty()
+	 * @generated
+	 */
+	void setImageProperty(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Description Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Description Property</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Description Property</em>' attribute.
+	 * @see #setDescriptionProperty(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_DescriptionProperty()
+	 * @model
+	 * @generated
+	 */
+	String getDescriptionProperty();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescriptionProperty <em>Description Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Description Property</em>' attribute.
+	 * @see #getDescriptionProperty()
+	 * @generated
+	 */
+	void setDescriptionProperty(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Description</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Description</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Description</em>' attribute.
+	 * @see #setDescription(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYIconComboBox_Description()
+	 * @model
+	 * @generated
+	 */
+	String getDescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox#getDescription <em>Description</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Description</em>' attribute.
+	 * @see #getDescription()
+	 * @generated
+	 */
+	void setDescription(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YLayoutingInfo.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YLayoutingInfo.java
new file mode 100644
index 0000000..a0009b8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YLayoutingInfo.java
@@ -0,0 +1,159 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YLayouting Info</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getLayout <em>Layout</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getContent <em>Content</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getActiveSuspectInfos <em>Active Suspect Infos</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getFirstFocus <em>First Focus</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYLayoutingInfo()
+ * @model
+ * @generated
+ */
+public interface YLayoutingInfo extends YElement {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Layout</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Layout</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Layout</em>' reference.
+	 * @see #setLayout(YStrategyLayout)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYLayoutingInfo_Layout()
+	 * @model
+	 * @generated
+	 */
+	YStrategyLayout getLayout();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getLayout <em>Layout</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Layout</em>' reference.
+	 * @see #getLayout()
+	 * @generated
+	 */
+	void setLayout(YStrategyLayout value);
+
+	/**
+	 * Returns the value of the '<em><b>Content</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Content</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Content</em>' containment reference.
+	 * @see #setContent(YEmbeddable)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYLayoutingInfo_Content()
+	 * @model containment="true"
+	 * @generated
+	 */
+	YEmbeddable getContent();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getContent <em>Content</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Content</em>' containment reference.
+	 * @see #getContent()
+	 * @generated
+	 */
+	void setContent(YEmbeddable value);
+
+	/**
+	 * Returns the value of the '<em><b>Active Suspect Infos</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Active Suspect Infos</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Active Suspect Infos</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYLayoutingInfo_ActiveSuspectInfos()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YSuspectInfo> getActiveSuspectInfos();
+
+	/**
+	 * Returns the value of the '<em><b>First Focus</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>First Focus</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>First Focus</em>' reference.
+	 * @see #setFirstFocus(YSuspectInfo)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYLayoutingInfo_FirstFocus()
+	 * @model
+	 * @generated
+	 */
+	YSuspectInfo getFirstFocus();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo#getFirstFocus <em>First Focus</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>First Focus</em>' reference.
+	 * @see #getFirstFocus()
+	 * @generated
+	 */
+	void setFirstFocus(YSuspectInfo value);
+
+	/**
+	 * Creates a new suspect.
+	 *
+	 * @param suspect
+	 *            the suspect
+	 * @return the y suspect info
+	 */
+	YSuspectInfo createSuspectInfo(YSuspect suspect);
+	
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 */
+	YView getView();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YLayoutingStrategy.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YLayoutingStrategy.java
new file mode 100644
index 0000000..2e9cf7a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YLayoutingStrategy.java
@@ -0,0 +1,79 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YLayouting Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy#getTrigger <em>Trigger</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYLayoutingStrategy()
+ * @model
+ * @generated
+ */
+public interface YLayoutingStrategy extends YElement {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Trigger</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Trigger</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Trigger</em>' attribute.
+	 * @see #setTrigger(Object)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYLayoutingStrategy_Trigger()
+	 * @model transient="true"
+	 * @generated
+	 */
+	Object getTrigger();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy#getTrigger <em>Trigger</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Trigger</em>' attribute.
+	 * @see #getTrigger()
+	 * @generated
+	 */
+	void setTrigger(Object value);
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the view
+	 * @model kind="operation"
+	 * @generated
+	 */
+	YView getView();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedDecimalField.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedDecimalField.java
new file mode 100644
index 0000000..2db5e67
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedDecimalField.java
@@ -0,0 +1,176 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YMasked Decimal Field</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getMask <em>Mask</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDecimalSeparator <em>Decimal Separator</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getGroupingSeparator <em>Grouping Separator</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedDecimalField()
+ * @model
+ * @generated
+ */
+public interface YMaskedDecimalField extends YInput, YValueBindable {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedDecimalField_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(Number)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedDecimalField_Value()
+	 * @model dataType="org.eclipse.osbp.ecview.extension.model.Number" transient="true"
+	 * @generated
+	 */
+	Number getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(Number value);
+
+	/**
+	 * Returns the value of the '<em><b>Mask</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Mask</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Mask</em>' attribute.
+	 * @see #setMask(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedDecimalField_Mask()
+	 * @model default=""
+	 * @generated
+	 */
+	String getMask();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getMask <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Mask</em>' attribute.
+	 * @see #getMask()
+	 * @generated
+	 */
+	void setMask(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Decimal Separator</b></em>' attribute.
+	 * The default value is <code>"null"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Decimal Separator</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Decimal Separator</em>' attribute.
+	 * @see #setDecimalSeparator(Character)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedDecimalField_DecimalSeparator()
+	 * @model default="null"
+	 * @generated
+	 */
+	Character getDecimalSeparator();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getDecimalSeparator <em>Decimal Separator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Decimal Separator</em>' attribute.
+	 * @see #getDecimalSeparator()
+	 * @generated
+	 */
+	void setDecimalSeparator(Character value);
+
+	/**
+	 * Returns the value of the '<em><b>Grouping Separator</b></em>' attribute.
+	 * The default value is <code>"null"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Grouping Separator</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Grouping Separator</em>' attribute.
+	 * @see #setGroupingSeparator(Character)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedDecimalField_GroupingSeparator()
+	 * @model default="null"
+	 * @generated
+	 */
+	Character getGroupingSeparator();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField#getGroupingSeparator <em>Grouping Separator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Grouping Separator</em>' attribute.
+	 * @see #getGroupingSeparator()
+	 * @generated
+	 */
+	void setGroupingSeparator(Character value);
+
+} // YMaskedDecimalField
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedNumericField.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedNumericField.java
new file mode 100644
index 0000000..03ff7ed
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedNumericField.java
@@ -0,0 +1,120 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YMasked Numeric Field</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getMask <em>Mask</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedNumericField()
+ * @model
+ * @generated
+ */
+public interface YMaskedNumericField extends YInput, YValueBindable {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedNumericField_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(Number)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedNumericField_Value()
+	 * @model dataType="org.eclipse.osbp.ecview.extension.model.Number" transient="true"
+	 * @generated
+	 */
+	Number getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(Number value);
+
+	/**
+	 * Returns the value of the '<em><b>Mask</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Mask</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Mask</em>' attribute.
+	 * @see #setMask(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedNumericField_Mask()
+	 * @model default=""
+	 * @generated
+	 */
+	String getMask();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField#getMask <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Mask</em>' attribute.
+	 * @see #getMask()
+	 * @generated
+	 */
+	void setMask(String value);
+
+} // YMaskedNumericField
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedTextField.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedTextField.java
new file mode 100644
index 0000000..d3d9296
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YMaskedTextField.java
@@ -0,0 +1,120 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YMasked Text Field</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getMask <em>Mask</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedTextField()
+ * @model
+ * @generated
+ */
+public interface YMaskedTextField extends YInput, YValueBindable {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedTextField_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedTextField_Value()
+	 * @model transient="true"
+	 * @generated
+	 */
+	String getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Mask</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Mask</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Mask</em>' attribute.
+	 * @see #setMask(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYMaskedTextField_Mask()
+	 * @model default=""
+	 * @generated
+	 */
+	String getMask();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField#getMask <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Mask</em>' attribute.
+	 * @see #getMask()
+	 * @generated
+	 */
+	void setMask(String value);
+
+} // YMaskedTextField
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YPairComboBox.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YPairComboBox.java
new file mode 100644
index 0000000..a34db9a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YPairComboBox.java
@@ -0,0 +1,331 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YComboBoxDatatype;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YPair Combo Box</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatatype <em>Datatype</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getSelection <em>Selection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getCollection <em>Collection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getEmfNsURI <em>Emf Ns URI</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getCaptionProperty <em>Caption Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getImageProperty <em>Image Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescriptionProperty <em>Description Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescription <em>Description</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox()
+ * @model
+ * @generated
+ */
+public interface YPairComboBox extends YInput, YCollectionBindable, YSelectionBindable, YBeanServiceConsumer {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datatype</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datatype</em>' reference.
+	 * @see #setDatatype(YComboBoxDatatype)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_Datatype()
+	 * @model
+	 * @generated
+	 */
+	YComboBoxDatatype getDatatype();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDatatype <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datatype</em>' reference.
+	 * @see #getDatatype()
+	 * @generated
+	 */
+	void setDatatype(YComboBoxDatatype value);
+
+	/**
+	 * Returns the value of the '<em><b>Selection</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Selection</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Selection</em>' attribute.
+	 * @see #setSelection(Object)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_Selection()
+	 * @model transient="true"
+	 * @generated
+	 */
+	Object getSelection();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getSelection <em>Selection</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Selection</em>' attribute.
+	 * @see #getSelection()
+	 * @generated
+	 */
+	void setSelection(Object value);
+
+	/**
+	 * Returns the value of the '<em><b>Collection</b></em>' attribute list.
+	 * The list contents are of type {@link java.lang.Object}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Collection</em>' attribute list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Collection</em>' attribute list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_Collection()
+	 * @model transient="true"
+	 * @generated
+	 */
+	EList<Object> getCollection();
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+	/**
+	 * Returns the value of the '<em><b>Emf Ns URI</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Emf Ns URI</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Emf Ns URI</em>' attribute.
+	 * @see #setEmfNsURI(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_EmfNsURI()
+	 * @model
+	 * @generated
+	 */
+	String getEmfNsURI();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getEmfNsURI <em>Emf Ns URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Emf Ns URI</em>' attribute.
+	 * @see #getEmfNsURI()
+	 * @generated
+	 */
+	void setEmfNsURI(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Caption Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Caption Property</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Caption Property</em>' attribute.
+	 * @see #setCaptionProperty(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_CaptionProperty()
+	 * @model
+	 * @generated
+	 */
+	String getCaptionProperty();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getCaptionProperty <em>Caption Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Caption Property</em>' attribute.
+	 * @see #getCaptionProperty()
+	 * @generated
+	 */
+	void setCaptionProperty(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Image Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Image Property</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Image Property</em>' attribute.
+	 * @see #setImageProperty(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_ImageProperty()
+	 * @model
+	 * @generated
+	 */
+	String getImageProperty();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getImageProperty <em>Image Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Image Property</em>' attribute.
+	 * @see #getImageProperty()
+	 * @generated
+	 */
+	void setImageProperty(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Description Property</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Description Property</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Description Property</em>' attribute.
+	 * @see #setDescriptionProperty(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_DescriptionProperty()
+	 * @model
+	 * @generated
+	 */
+	String getDescriptionProperty();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescriptionProperty <em>Description Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Description Property</em>' attribute.
+	 * @see #getDescriptionProperty()
+	 * @generated
+	 */
+	void setDescriptionProperty(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Description</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Description</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Description</em>' attribute.
+	 * @see #setDescription(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPairComboBox_Description()
+	 * @model
+	 * @generated
+	 */
+	String getDescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox#getDescription <em>Description</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Description</em>' attribute.
+	 * @see #getDescription()
+	 * @generated
+	 */
+	void setDescription(String value);
+
+} // YPairComboBox
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YPrefixedMaskedTextField.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YPrefixedMaskedTextField.java
new file mode 100644
index 0000000..f044956
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YPrefixedMaskedTextField.java
@@ -0,0 +1,140 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EMap;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YPrefixed Masked Text Field</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getMask <em>Mask</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getPrefixes <em>Prefixes</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPrefixedMaskedTextField()
+ * @model
+ * @generated
+ */
+public interface YPrefixedMaskedTextField extends YInput, YValueBindable {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPrefixedMaskedTextField_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPrefixedMaskedTextField_Value()
+	 * @model transient="true"
+	 * @generated
+	 */
+	String getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Mask</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Mask</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Mask</em>' attribute.
+	 * @see #setMask(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPrefixedMaskedTextField_Mask()
+	 * @model default=""
+	 * @generated
+	 */
+	String getMask();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField#getMask <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Mask</em>' attribute.
+	 * @see #getMask()
+	 * @generated
+	 */
+	void setMask(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Prefixes</b></em>' map.
+	 * The key is of type {@link java.lang.String},
+	 * and the value is of type {@link java.lang.String},
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Prefixes</em>' map isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Prefixes</em>' map.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYPrefixedMaskedTextField_Prefixes()
+	 * @model mapType="org.eclipse.osbp.ecview.core.common.model.core.YStringToStringMap<org.eclipse.emf.ecore.EString, org.eclipse.emf.ecore.EString>"
+	 * @generated
+	 */
+	EMap<String, String> getPrefixes();
+
+} // YPrefixedMaskedTextField
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YQuantityTextField.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YQuantityTextField.java
new file mode 100644
index 0000000..89ddceb
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YQuantityTextField.java
@@ -0,0 +1,98 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YQuantity Text Field</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getValue <em>Value</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYQuantityTextField()
+ * @model
+ * @generated
+ */
+public interface YQuantityTextField extends YInput, YValueBindable {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYQuantityTextField_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(Object)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYQuantityTextField_Value()
+	 * @model transient="true"
+	 * @generated
+	 */
+	Object getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(Object value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YRichTextArea.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YRichTextArea.java
new file mode 100644
index 0000000..b302420
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YRichTextArea.java
@@ -0,0 +1,151 @@
+/**
+ * All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.binding.YValueBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YRich Text Area</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getBlobValue <em>Blob Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#isUseBlob <em>Use Blob</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYRichTextArea()
+ * @model
+ * @generated
+ */
+public interface YRichTextArea extends YInput, YValueBindable {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Datadescription</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datadescription</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datadescription</em>' reference.
+	 * @see #setDatadescription(YDatadescription)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYRichTextArea_Datadescription()
+	 * @model
+	 * @generated
+	 */
+	YDatadescription getDatadescription();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getDatadescription <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datadescription</em>' reference.
+	 * @see #getDatadescription()
+	 * @generated
+	 */
+	void setDatadescription(YDatadescription value);
+
+	/**
+	 * Returns the value of the '<em><b>Blob Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Blob Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Blob Value</em>' attribute.
+	 * @see #setBlobValue(byte[])
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYRichTextArea_BlobValue()
+	 * @model transient="true"
+	 * @generated
+	 */
+	byte[] getBlobValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getBlobValue <em>Blob Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Blob Value</em>' attribute.
+	 * @see #getBlobValue()
+	 * @generated
+	 */
+	void setBlobValue(byte[] value);
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYRichTextArea_Value()
+	 * @model transient="true"
+	 * @generated
+	 */
+	String getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(String value);
+	
+	/**
+	 * Returns the value of the '<em><b>Use Blob</b></em>' attribute.
+	 * The default value is <code>"false"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Use Blob</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Use Blob</em>' attribute.
+	 * @see #setUseBlob(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYRichTextArea_UseBlob()
+	 * @model default="false"
+	 * @generated
+	 */
+	boolean isUseBlob();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea#isUseBlob <em>Use Blob</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Use Blob</em>' attribute.
+	 * @see #isUseBlob()
+	 * @generated
+	 */
+	void setUseBlob(boolean value);
+
+	/**
+	 * Creates the endpoint for blob bindings.
+	 */
+	YValueBindingEndpoint createBlobValueEndpoint();
+
+} // YRichTextArea
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YStrategyLayout.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YStrategyLayout.java
new file mode 100644
index 0000000..3157809
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YStrategyLayout.java
@@ -0,0 +1,175 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YStrategy Layout</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingStrategy <em>Layouting Strategy</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getFocusingStrategies <em>Focusing Strategies</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getSuspects <em>Suspects</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingInfo <em>Layouting Info</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getDefaultFocusingEnhancerId <em>Default Focusing Enhancer Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout()
+ * @model
+ * @generated
+ */
+public interface YStrategyLayout extends YEmbeddable {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Layouting Strategy</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Layouting Strategy</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Layouting Strategy</em>' containment reference.
+	 * @see #setLayoutingStrategy(YLayoutingStrategy)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout_LayoutingStrategy()
+	 * @model containment="true"
+	 * @generated
+	 */
+	YLayoutingStrategy getLayoutingStrategy();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingStrategy <em>Layouting Strategy</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Layouting Strategy</em>' containment reference.
+	 * @see #getLayoutingStrategy()
+	 * @generated
+	 */
+	void setLayoutingStrategy(YLayoutingStrategy value);
+
+	/**
+	 * Returns the value of the '<em><b>Focusing Strategies</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Focusing Strategies</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Focusing Strategies</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout_FocusingStrategies()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YFocusingStrategy> getFocusingStrategies();
+
+	/**
+	 * Returns the value of the '<em><b>Suspects</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.model.YSuspect}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Suspects</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Suspects</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout_Suspects()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YSuspect> getSuspects();
+
+	/**
+	 * Returns the value of the '<em><b>Layouting Info</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Layouting Info</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Layouting Info</em>' containment reference.
+	 * @see #setLayoutingInfo(YLayoutingInfo)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout_LayoutingInfo()
+	 * @model containment="true" transient="true"
+	 * @generated
+	 */
+	YLayoutingInfo getLayoutingInfo();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingInfo <em>Layouting Info</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Layouting Info</em>' containment reference.
+	 * @see #getLayoutingInfo()
+	 * @generated
+	 */
+	void setLayoutingInfo(YLayoutingInfo value);
+
+	/**
+	 * Returns the value of the '<em><b>Default Focusing Enhancer Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Default Focusing Enhancer Id</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Default Focusing Enhancer Id</em>' attribute.
+	 * @see #setDefaultFocusingEnhancerId(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout_DefaultFocusingEnhancerId()
+	 * @model
+	 * @generated
+	 */
+	String getDefaultFocusingEnhancerId();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getDefaultFocusingEnhancerId <em>Default Focusing Enhancer Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Default Focusing Enhancer Id</em>' attribute.
+	 * @see #getDefaultFocusingEnhancerId()
+	 * @generated
+	 */
+	void setDefaultFocusingEnhancerId(String value);
+
+	/**
+	 * Uses the suspect info form layouting info to find the proper suspectinfo
+	 * for the given embeddable.
+	 *
+	 * @param yEmbeddable
+	 *            the y embeddable
+	 * @return the y suspect info
+	 */
+	YSuspectInfo findInfoFor(YEmbeddable yEmbeddable);
+	
+	/**
+	 * Tries to find the info without an nextFocus.
+	 *
+	 * @return the y suspect info
+	 */
+	YSuspectInfo findLastFocus();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSubTypeBaseSuspect.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSubTypeBaseSuspect.java
new file mode 100644
index 0000000..c4729dc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSubTypeBaseSuspect.java
@@ -0,0 +1,35 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YSub Type Base Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSubTypeBaseSuspect()
+ * @model
+ * @generated
+ */
+public interface YSubTypeBaseSuspect extends YTypedCompoundSuspect {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+} // YSubTypeBaseSuspect
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSubTypeSuspect.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSubTypeSuspect.java
new file mode 100644
index 0000000..3d6ed52
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSubTypeSuspect.java
@@ -0,0 +1,68 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YBeanSlot;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YSub Type Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect#getBeanSlot <em>Bean Slot</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSubTypeSuspect()
+ * @model
+ * @generated
+ */
+public interface YSubTypeSuspect extends YTypedCompoundSuspect {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Bean Slot</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Bean Slot</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Bean Slot</em>' reference.
+	 * @see #setBeanSlot(YBeanSlot)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSubTypeSuspect_BeanSlot()
+	 * @model required="true"
+	 * @generated
+	 */
+	YBeanSlot getBeanSlot();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect#getBeanSlot <em>Bean Slot</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Bean Slot</em>' reference.
+	 * @see #getBeanSlot()
+	 * @generated
+	 */
+	void setBeanSlot(YBeanSlot value);
+
+} // YSubTypeSuspect
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspect.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspect.java
new file mode 100644
index 0000000..8a72d20
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspect.java
@@ -0,0 +1,223 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.binding.YBinding;
+import org.eclipse.osbp.ecview.core.common.model.binding.YBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCommand;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YSuspect</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getImageI18nKey <em>Image I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getValueBindingEndpoints <em>Value Binding Endpoints</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getVisibilityProcessors <em>Visibility Processors</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getCommands <em>Commands</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getAssocNewiatedElements <em>Assoc Newiated Elements</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getAssociatedBindings <em>Associated Bindings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getLabel <em>Label</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect()
+ * @model
+ * @generated
+ */
+public interface YSuspect extends YElement, YAuthorizationable {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Label I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label I1 8n Key</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #setLabelI18nKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_LabelI18nKey()
+	 * @model
+	 * @generated
+	 */
+	String getLabelI18nKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getLabelI18nKey <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label I1 8n Key</em>' attribute.
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 */
+	void setLabelI18nKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Image I1 8n Key</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Image I1 8n Key</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Image I1 8n Key</em>' attribute.
+	 * @see #setImageI18nKey(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_ImageI18nKey()
+	 * @model
+	 * @generated
+	 */
+	String getImageI18nKey();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getImageI18nKey <em>Image I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Image I1 8n Key</em>' attribute.
+	 * @see #getImageI18nKey()
+	 * @generated
+	 */
+	void setImageI18nKey(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Value Binding Endpoints</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.core.common.model.binding.YBindingEndpoint}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value Binding Endpoints</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value Binding Endpoints</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_ValueBindingEndpoints()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YBindingEndpoint> getValueBindingEndpoints();
+
+	/**
+	 * Returns the value of the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Visibility Processors</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Visibility Processors</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_VisibilityProcessors()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YVisibilityProcessor> getVisibilityProcessors();
+
+	/**
+	 * Returns the value of the '<em><b>Commands</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.core.common.model.core.YCommand}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Commands</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Commands</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_Commands()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YCommand> getCommands();
+
+	/**
+	 * Returns the value of the '<em><b>Assoc Newiated Elements</b></em>' reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Assoc Newiated Elements</em>' reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Assoc Newiated Elements</em>' reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_AssocNewiatedElements()
+	 * @model transient="true"
+	 * @generated
+	 */
+	EList<YEmbeddable> getAssocNewiatedElements();
+
+	/**
+	 * Returns the value of the '<em><b>Associated Bindings</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.core.common.model.binding.YBinding}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Associated Bindings</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Associated Bindings</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_AssociatedBindings()
+	 * @model containment="true" transient="true"
+	 * @generated
+	 */
+	EList<YBinding> getAssociatedBindings();
+
+	/**
+	 * Returns the value of the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label</em>' attribute.
+	 * @see #setLabel(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_Label()
+	 * @model
+	 * @generated
+	 */
+	String getLabel();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getLabel <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label</em>' attribute.
+	 * @see #getLabel()
+	 * @generated
+	 */
+	void setLabel(String value);
+	
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 */
+	YView getView();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspectInfo.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspectInfo.java
new file mode 100644
index 0000000..7c0608c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspectInfo.java
@@ -0,0 +1,200 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.binding.YBinding;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YSuspect Info</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getSuspect <em>Suspect</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getBindings <em>Bindings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getNextFocus <em>Next Focus</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getPreviousFocus <em>Previous Focus</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getTarget <em>Target</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getVisibilityProcessors <em>Visibility Processors</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspectInfo()
+ * @model
+ * @generated
+ */
+public interface YSuspectInfo extends YElement {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Suspect</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Suspect</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Suspect</em>' reference.
+	 * @see #setSuspect(YSuspect)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspectInfo_Suspect()
+	 * @model
+	 * @generated
+	 */
+	YSuspect getSuspect();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getSuspect <em>Suspect</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Suspect</em>' reference.
+	 * @see #getSuspect()
+	 * @generated
+	 */
+	void setSuspect(YSuspect value);
+
+	/**
+	 * Returns the value of the '<em><b>Bindings</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.core.common.model.binding.YBinding}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Bindings</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Bindings</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspectInfo_Bindings()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YBinding> getBindings();
+
+	/**
+	 * Returns the value of the '<em><b>Next Focus</b></em>' reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getPreviousFocus <em>Previous Focus</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Next Focus</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Next Focus</em>' reference.
+	 * @see #setNextFocus(YSuspectInfo)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspectInfo_NextFocus()
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getPreviousFocus
+	 * @model opposite="previousFocus"
+	 * @generated
+	 */
+	YSuspectInfo getNextFocus();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getNextFocus <em>Next Focus</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Next Focus</em>' reference.
+	 * @see #getNextFocus()
+	 * @generated
+	 */
+	void setNextFocus(YSuspectInfo value);
+
+	/**
+	 * Returns the value of the '<em><b>Previous Focus</b></em>' reference.
+	 * It is bidirectional and its opposite is '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getNextFocus <em>Next Focus</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Previous Focus</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Previous Focus</em>' reference.
+	 * @see #setPreviousFocus(YSuspectInfo)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspectInfo_PreviousFocus()
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getNextFocus
+	 * @model opposite="nextFocus"
+	 * @generated
+	 */
+	YSuspectInfo getPreviousFocus();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getPreviousFocus <em>Previous Focus</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Previous Focus</em>' reference.
+	 * @see #getPreviousFocus()
+	 * @generated
+	 */
+	void setPreviousFocus(YSuspectInfo value);
+
+	/**
+	 * Returns the value of the '<em><b>Target</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Target</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Target</em>' reference.
+	 * @see #setTarget(YEmbeddable)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspectInfo_Target()
+	 * @model
+	 * @generated
+	 */
+	YEmbeddable getTarget();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo#getTarget <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Target</em>' reference.
+	 * @see #getTarget()
+	 * @generated
+	 */
+	void setTarget(YEmbeddable value);
+
+	/**
+	 * Returns the value of the '<em><b>Visibility Processors</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Visibility Processors</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Visibility Processors</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspectInfo_VisibilityProcessors()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YVisibilityProcessor> getVisibilityProcessors();
+
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 */
+	YView getView();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YTypedCompoundSuspect.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YTypedCompoundSuspect.java
new file mode 100644
index 0000000..3d98afc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YTypedCompoundSuspect.java
@@ -0,0 +1,59 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YTyped Compound Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect#getChildren <em>Children</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYTypedCompoundSuspect()
+ * @model
+ * @generated
+ */
+public interface YTypedCompoundSuspect extends YTypedSuspect {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Children</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.model.YSuspect}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Children</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Children</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYTypedCompoundSuspect_Children()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YSuspect> getChildren();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YTypedSuspect.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YTypedSuspect.java
new file mode 100644
index 0000000..1849649
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YTypedSuspect.java
@@ -0,0 +1,95 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YTyped Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getType <em>Type</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYTypedSuspect()
+ * @model
+ * @generated
+ */
+public interface YTypedSuspect extends YSuspect {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYTypedSuspect_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYTypedSuspect_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YConverterFactory.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YConverterFactory.java
new file mode 100644
index 0000000..b266b7e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YConverterFactory.java
@@ -0,0 +1,151 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage
+ * @generated
+ */
+public interface YConverterFactory extends EFactory {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	YConverterFactory eINSTANCE = org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>YObject To String Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YObject To String Converter</em>'.
+	 * @generated
+	 */
+	YObjectToStringConverter createYObjectToStringConverter();
+
+	/**
+	 * Returns a new object of class '<em>YCustom Decimal Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YCustom Decimal Converter</em>'.
+	 * @generated
+	 */
+	YCustomDecimalConverter createYCustomDecimalConverter();
+
+	/**
+	 * Returns a new object of class '<em>YNumeric To Resource Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YNumeric To Resource Converter</em>'.
+	 * @generated
+	 */
+	YNumericToResourceConverter createYNumericToResourceConverter();
+
+	/**
+	 * Returns a new object of class '<em>YString To Resource Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YString To Resource Converter</em>'.
+	 * @generated
+	 */
+	YStringToResourceConverter createYStringToResourceConverter();
+
+	/**
+	 * Returns a new object of class '<em>YNumeric To Resource Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YNumeric To Resource Config</em>'.
+	 * @generated
+	 */
+	YNumericToResourceConfig createYNumericToResourceConfig();
+
+	/**
+	 * Returns a new object of class '<em>YString To Resource Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YString To Resource Config</em>'.
+	 * @generated
+	 */
+	YStringToResourceConfig createYStringToResourceConfig();
+
+	/**
+	 * Returns a new object of class '<em>YNumeric To Uomo Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YNumeric To Uomo Converter</em>'.
+	 * @generated
+	 */
+	YNumericToUomoConverter createYNumericToUomoConverter();
+
+	/**
+	 * Returns a new object of class '<em>YDecimal To Uomo Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YDecimal To Uomo Converter</em>'.
+	 * @generated
+	 */
+	YDecimalToUomoConverter createYDecimalToUomoConverter();
+
+	/**
+	 * Returns a new object of class '<em>YSimple Decimal Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YSimple Decimal Converter</em>'.
+	 * @generated
+	 */
+	YSimpleDecimalConverter createYSimpleDecimalConverter();
+
+	/**
+	 * Returns a new object of class '<em>YPrice To String Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YPrice To String Converter</em>'.
+	 * @generated
+	 */
+	YPriceToStringConverter createYPriceToStringConverter();
+
+	/**
+	 * Returns a new object of class '<em>YQuantity To String Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YQuantity To String Converter</em>'.
+	 * @generated
+	 */
+	YQuantityToStringConverter createYQuantityToStringConverter();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	YConverterPackage getYConverterPackage();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YConverterPackage.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YConverterPackage.java
new file mode 100644
index 0000000..e4c21e4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YConverterPackage.java
@@ -0,0 +1,1363 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface YConverterPackage extends EPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "converter";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://osbp.de/ecview/v1/extension/converter";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "converter";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	YConverterPackage eINSTANCE = org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl <em>YObject To String Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYObjectToStringConverter()
+	 * @generated
+	 */
+	int YOBJECT_TO_STRING_CONVERTER = 0;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YOBJECT_TO_STRING_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YOBJECT_TO_STRING_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YOBJECT_TO_STRING_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YOBJECT_TO_STRING_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The number of structural features of the '<em>YObject To String Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YOBJECT_TO_STRING_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl <em>YCustom Decimal Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYCustomDecimalConverter()
+	 * @generated
+	 */
+	int YCUSTOM_DECIMAL_CONVERTER = 1;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Base Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YCustom Decimal Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCUSTOM_DECIMAL_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl <em>YNumeric To Resource Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYNumericToResourceConverter()
+	 * @generated
+	 */
+	int YNUMERIC_TO_RESOURCE_CONVERTER = 2;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Configs</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YNumeric To Resource Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl <em>YString To Resource Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYStringToResourceConverter()
+	 * @generated
+	 */
+	int YSTRING_TO_RESOURCE_CONVERTER = 3;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Configs</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONVERTER__CONFIGS = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YString To Resource Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConfigImpl <em>YNumeric To Resource Config</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConfigImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYNumericToResourceConfig()
+	 * @generated
+	 */
+	int YNUMERIC_TO_RESOURCE_CONFIG = 4;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONFIG__VALUE = 0;
+
+	/**
+	 * The feature id for the '<em><b>Compare</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONFIG__COMPARE = 1;
+
+	/**
+	 * The feature id for the '<em><b>Resource Theme Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH = 2;
+
+	/**
+	 * The number of structural features of the '<em>YNumeric To Resource Config</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_RESOURCE_CONFIG_FEATURE_COUNT = 3;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConfigImpl <em>YString To Resource Config</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConfigImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYStringToResourceConfig()
+	 * @generated
+	 */
+	int YSTRING_TO_RESOURCE_CONFIG = 5;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONFIG__VALUE = 0;
+
+	/**
+	 * The feature id for the '<em><b>Compare</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONFIG__COMPARE = 1;
+
+	/**
+	 * The feature id for the '<em><b>Resource Theme Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH = 2;
+
+	/**
+	 * The number of structural features of the '<em>YString To Resource Config</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRING_TO_RESOURCE_CONFIG_FEATURE_COUNT = 3;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl <em>YNumeric To Uomo Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYNumericToUomoConverter()
+	 * @generated
+	 */
+	int YNUMERIC_TO_UOMO_CONVERTER = 8;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl <em>YPrice To String Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYPriceToStringConverter()
+	 * @generated
+	 */
+	int YPRICE_TO_STRING_CONVERTER = 6;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Value Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Currency Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER__TYPE = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>YPrice To String Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YPRICE_TO_STRING_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 4;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl <em>YQuantity To String Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYQuantityToStringConverter()
+	 * @generated
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER = 7;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Amount Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Uom Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Uom Code Relative Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Quantity Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 3;
+
+	/**
+	 * The number of structural features of the '<em>YQuantity To String Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YQUANTITY_TO_STRING_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_UOMO_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_UOMO_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_UOMO_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The number of structural features of the '<em>YNumeric To Uomo Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YNUMERIC_TO_UOMO_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl <em>YDecimal To Uomo Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYDecimalToUomoConverter()
+	 * @generated
+	 */
+	int YDECIMAL_TO_UOMO_CONVERTER = 9;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDECIMAL_TO_UOMO_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDECIMAL_TO_UOMO_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDECIMAL_TO_UOMO_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The number of structural features of the '<em>YDecimal To Uomo Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YDECIMAL_TO_UOMO_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl <em>YSimple Decimal Converter</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYSimpleDecimalConverter()
+	 * @generated
+	 */
+	int YSIMPLE_DECIMAL_CONVERTER = 10;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSIMPLE_DECIMAL_CONVERTER__TAGS = CoreModelPackage.YCONVERTER__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSIMPLE_DECIMAL_CONVERTER__ID = CoreModelPackage.YCONVERTER__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSIMPLE_DECIMAL_CONVERTER__NAME = CoreModelPackage.YCONVERTER__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSIMPLE_DECIMAL_CONVERTER__PROPERTIES = CoreModelPackage.YCONVERTER__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Number Format Pattern</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>YSimple Decimal Converter</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSIMPLE_DECIMAL_CONVERTER_FEATURE_COUNT = CoreModelPackage.YCONVERTER_FEATURE_COUNT + 1;
+
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter <em>YObject To String Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YObject To String Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter
+	 * @generated
+	 */
+	EClass getYObjectToStringConverter();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter <em>YCustom Decimal Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YCustom Decimal Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter
+	 * @generated
+	 */
+	EClass getYCustomDecimalConverter();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter#getBaseUnit <em>Base Unit</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Base Unit</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter#getBaseUnit()
+	 * @see #getYCustomDecimalConverter()
+	 * @generated
+	 */
+	EAttribute getYCustomDecimalConverter_BaseUnit();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter <em>YNumeric To Resource Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YNumeric To Resource Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter
+	 * @generated
+	 */
+	EClass getYNumericToResourceConverter();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter#getConfigs <em>Configs</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Configs</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter#getConfigs()
+	 * @see #getYNumericToResourceConverter()
+	 * @generated
+	 */
+	EReference getYNumericToResourceConverter_Configs();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter <em>YString To Resource Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YString To Resource Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter
+	 * @generated
+	 */
+	EClass getYStringToResourceConverter();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter#getConfigs <em>Configs</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Configs</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter#getConfigs()
+	 * @see #getYStringToResourceConverter()
+	 * @generated
+	 */
+	EReference getYStringToResourceConverter_Configs();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig <em>YNumeric To Resource Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YNumeric To Resource Config</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig
+	 * @generated
+	 */
+	EClass getYNumericToResourceConfig();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getValue()
+	 * @see #getYNumericToResourceConfig()
+	 * @generated
+	 */
+	EAttribute getYNumericToResourceConfig_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getCompare <em>Compare</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Compare</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getCompare()
+	 * @see #getYNumericToResourceConfig()
+	 * @generated
+	 */
+	EAttribute getYNumericToResourceConfig_Compare();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getResourceThemePath <em>Resource Theme Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Resource Theme Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getResourceThemePath()
+	 * @see #getYNumericToResourceConfig()
+	 * @generated
+	 */
+	EAttribute getYNumericToResourceConfig_ResourceThemePath();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig <em>YString To Resource Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YString To Resource Config</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig
+	 * @generated
+	 */
+	EClass getYStringToResourceConfig();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getValue()
+	 * @see #getYStringToResourceConfig()
+	 * @generated
+	 */
+	EAttribute getYStringToResourceConfig_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getCompare <em>Compare</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Compare</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getCompare()
+	 * @see #getYStringToResourceConfig()
+	 * @generated
+	 */
+	EAttribute getYStringToResourceConfig_Compare();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getResourceThemePath <em>Resource Theme Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Resource Theme Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getResourceThemePath()
+	 * @see #getYStringToResourceConfig()
+	 * @generated
+	 */
+	EAttribute getYStringToResourceConfig_ResourceThemePath();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter <em>YNumeric To Uomo Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YNumeric To Uomo Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter
+	 * @generated
+	 */
+	EClass getYNumericToUomoConverter();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter <em>YDecimal To Uomo Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YDecimal To Uomo Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter
+	 * @generated
+	 */
+	EClass getYDecimalToUomoConverter();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter <em>YSimple Decimal Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YSimple Decimal Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter
+	 * @generated
+	 */
+	EClass getYSimpleDecimalConverter();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter#getNumberFormatPattern <em>Number Format Pattern</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Number Format Pattern</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter#getNumberFormatPattern()
+	 * @see #getYSimpleDecimalConverter()
+	 * @generated
+	 */
+	EAttribute getYSimpleDecimalConverter_NumberFormatPattern();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter <em>YPrice To String Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YPrice To String Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter
+	 * @generated
+	 */
+	EClass getYPriceToStringConverter();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getValuePropertyPath <em>Value Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getValuePropertyPath()
+	 * @see #getYPriceToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYPriceToStringConverter_ValuePropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getCurrencyPropertyPath <em>Currency Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Currency Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getCurrencyPropertyPath()
+	 * @see #getYPriceToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYPriceToStringConverter_CurrencyPropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getTypeQualifiedName()
+	 * @see #getYPriceToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYPriceToStringConverter_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getType()
+	 * @see #getYPriceToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYPriceToStringConverter_Type();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter <em>YQuantity To String Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YQuantity To String Converter</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter
+	 * @generated
+	 */
+	EClass getYQuantityToStringConverter();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getAmountPropertyPath <em>Amount Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Amount Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getAmountPropertyPath()
+	 * @see #getYQuantityToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYQuantityToStringConverter_AmountPropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomPropertyPath <em>Uom Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Uom Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomPropertyPath()
+	 * @see #getYQuantityToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYQuantityToStringConverter_UomPropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomCodeRelativePropertyPath <em>Uom Code Relative Property Path</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Uom Code Relative Property Path</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomCodeRelativePropertyPath()
+	 * @see #getYQuantityToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYQuantityToStringConverter_UomCodeRelativePropertyPath();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getQuantityTypeQualifiedName <em>Quantity Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Quantity Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getQuantityTypeQualifiedName()
+	 * @see #getYQuantityToStringConverter()
+	 * @generated
+	 */
+	EAttribute getYQuantityToStringConverter_QuantityTypeQualifiedName();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	YConverterFactory getYConverterFactory();
+
+	/**
+	 * <!-- begin-user-doc --> Defines literals for the meta objects that
+	 * represent
+	 * <ul>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl <em>YObject To String Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYObjectToStringConverter()
+		 * @generated
+		 */
+		EClass YOBJECT_TO_STRING_CONVERTER = eINSTANCE.getYObjectToStringConverter();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl <em>YCustom Decimal Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYCustomDecimalConverter()
+		 * @generated
+		 */
+		EClass YCUSTOM_DECIMAL_CONVERTER = eINSTANCE.getYCustomDecimalConverter();
+
+		/**
+		 * The meta object literal for the '<em><b>Base Unit</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT = eINSTANCE.getYCustomDecimalConverter_BaseUnit();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl <em>YNumeric To Resource Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYNumericToResourceConverter()
+		 * @generated
+		 */
+		EClass YNUMERIC_TO_RESOURCE_CONVERTER = eINSTANCE.getYNumericToResourceConverter();
+
+		/**
+		 * The meta object literal for the '<em><b>Configs</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS = eINSTANCE.getYNumericToResourceConverter_Configs();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl <em>YString To Resource Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYStringToResourceConverter()
+		 * @generated
+		 */
+		EClass YSTRING_TO_RESOURCE_CONVERTER = eINSTANCE.getYStringToResourceConverter();
+
+		/**
+		 * The meta object literal for the '<em><b>Configs</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSTRING_TO_RESOURCE_CONVERTER__CONFIGS = eINSTANCE.getYStringToResourceConverter_Configs();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConfigImpl <em>YNumeric To Resource Config</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConfigImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYNumericToResourceConfig()
+		 * @generated
+		 */
+		EClass YNUMERIC_TO_RESOURCE_CONFIG = eINSTANCE.getYNumericToResourceConfig();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YNUMERIC_TO_RESOURCE_CONFIG__VALUE = eINSTANCE.getYNumericToResourceConfig_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Compare</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YNUMERIC_TO_RESOURCE_CONFIG__COMPARE = eINSTANCE.getYNumericToResourceConfig_Compare();
+
+		/**
+		 * The meta object literal for the '<em><b>Resource Theme Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH = eINSTANCE.getYNumericToResourceConfig_ResourceThemePath();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConfigImpl <em>YString To Resource Config</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConfigImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYStringToResourceConfig()
+		 * @generated
+		 */
+		EClass YSTRING_TO_RESOURCE_CONFIG = eINSTANCE.getYStringToResourceConfig();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSTRING_TO_RESOURCE_CONFIG__VALUE = eINSTANCE.getYStringToResourceConfig_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Compare</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSTRING_TO_RESOURCE_CONFIG__COMPARE = eINSTANCE.getYStringToResourceConfig_Compare();
+
+		/**
+		 * The meta object literal for the '<em><b>Resource Theme Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH = eINSTANCE.getYStringToResourceConfig_ResourceThemePath();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl <em>YNumeric To Uomo Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYNumericToUomoConverter()
+		 * @generated
+		 */
+		EClass YNUMERIC_TO_UOMO_CONVERTER = eINSTANCE.getYNumericToUomoConverter();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl <em>YDecimal To Uomo Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYDecimalToUomoConverter()
+		 * @generated
+		 */
+		EClass YDECIMAL_TO_UOMO_CONVERTER = eINSTANCE.getYDecimalToUomoConverter();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl <em>YSimple Decimal Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYSimpleDecimalConverter()
+		 * @generated
+		 */
+		EClass YSIMPLE_DECIMAL_CONVERTER = eINSTANCE.getYSimpleDecimalConverter();
+
+		/**
+		 * The meta object literal for the '<em><b>Number Format Pattern</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN = eINSTANCE.getYSimpleDecimalConverter_NumberFormatPattern();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl <em>YPrice To String Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYPriceToStringConverter()
+		 * @generated
+		 */
+		EClass YPRICE_TO_STRING_CONVERTER = eINSTANCE.getYPriceToStringConverter();
+
+		/**
+		 * The meta object literal for the '<em><b>Value Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH = eINSTANCE.getYPriceToStringConverter_ValuePropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Currency Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH = eINSTANCE.getYPriceToStringConverter_CurrencyPropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME = eINSTANCE.getYPriceToStringConverter_TypeQualifiedName();
+
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YPRICE_TO_STRING_CONVERTER__TYPE = eINSTANCE.getYPriceToStringConverter_Type();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl <em>YQuantity To String Converter</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl#getYQuantityToStringConverter()
+		 * @generated
+		 */
+		EClass YQUANTITY_TO_STRING_CONVERTER = eINSTANCE.getYQuantityToStringConverter();
+
+		/**
+		 * The meta object literal for the '<em><b>Amount Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH = eINSTANCE.getYQuantityToStringConverter_AmountPropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Uom Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH = eINSTANCE.getYQuantityToStringConverter_UomPropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Uom Code Relative Property Path</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH = eINSTANCE.getYQuantityToStringConverter_UomCodeRelativePropertyPath();
+
+		/**
+		 * The meta object literal for the '<em><b>Quantity Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME = eINSTANCE.getYQuantityToStringConverter_QuantityTypeQualifiedName();
+
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YCustomDecimalConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YCustomDecimalConverter.java
new file mode 100644
index 0000000..5e7b73a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YCustomDecimalConverter.java
@@ -0,0 +1,69 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YCustom Decimal Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter#getBaseUnit <em>Base Unit</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYCustomDecimalConverter()
+ * @model
+ * @generated
+ */
+public interface YCustomDecimalConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Base Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Base Unit</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Base Unit</em>' attribute.
+	 * @see #setBaseUnit(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYCustomDecimalConverter_BaseUnit()
+	 * @model
+	 * @generated
+	 */
+	String getBaseUnit();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter#getBaseUnit <em>Base Unit</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Base Unit</em>' attribute.
+	 * @see #getBaseUnit()
+	 * @generated
+	 */
+	void setBaseUnit(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YDecimalToUomoConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YDecimalToUomoConverter.java
new file mode 100644
index 0000000..f23eef5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YDecimalToUomoConverter.java
@@ -0,0 +1,37 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YDecimal To Uomo Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYDecimalToUomoConverter()
+ * @model
+ * @generated
+ */
+public interface YDecimalToUomoConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToResourceConfig.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToResourceConfig.java
new file mode 100644
index 0000000..a646c2f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToResourceConfig.java
@@ -0,0 +1,127 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.core.common.model.core.YCompare;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YNumeric To Resource Config</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getCompare <em>Compare</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getResourceThemePath <em>Resource Theme Path</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYNumericToResourceConfig()
+ * @model
+ * @generated
+ */
+public interface YNumericToResourceConfig extends EObject {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(double)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYNumericToResourceConfig_Value()
+	 * @model
+	 * @generated
+	 */
+	double getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Compare</b></em>' attribute.
+	 * The literals are from the enumeration {@link org.eclipse.osbp.ecview.core.common.model.core.YCompare}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Compare</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Compare</em>' attribute.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCompare
+	 * @see #setCompare(YCompare)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYNumericToResourceConfig_Compare()
+	 * @model
+	 * @generated
+	 */
+	YCompare getCompare();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getCompare <em>Compare</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Compare</em>' attribute.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCompare
+	 * @see #getCompare()
+	 * @generated
+	 */
+	void setCompare(YCompare value);
+
+	/**
+	 * Returns the value of the '<em><b>Resource Theme Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Resource Theme Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Resource Theme Path</em>' attribute.
+	 * @see #setResourceThemePath(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYNumericToResourceConfig_ResourceThemePath()
+	 * @model
+	 * @generated
+	 */
+	String getResourceThemePath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig#getResourceThemePath <em>Resource Theme Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Resource Theme Path</em>' attribute.
+	 * @see #getResourceThemePath()
+	 * @generated
+	 */
+	void setResourceThemePath(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToResourceConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToResourceConverter.java
new file mode 100644
index 0000000..73b1467
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToResourceConverter.java
@@ -0,0 +1,60 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YNumeric To Resource Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter#getConfigs <em>Configs</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYNumericToResourceConverter()
+ * @model
+ * @generated
+ */
+public interface YNumericToResourceConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Configs</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Configs</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Configs</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYNumericToResourceConverter_Configs()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YNumericToResourceConfig> getConfigs();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToUomoConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToUomoConverter.java
new file mode 100644
index 0000000..f469236
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YNumericToUomoConverter.java
@@ -0,0 +1,37 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YNumeric To Uomo Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYNumericToUomoConverter()
+ * @model
+ * @generated
+ */
+public interface YNumericToUomoConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YObjectToStringConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YObjectToStringConverter.java
new file mode 100644
index 0000000..da59fc7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YObjectToStringConverter.java
@@ -0,0 +1,37 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YObject To String Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYObjectToStringConverter()
+ * @model
+ * @generated
+ */
+public interface YObjectToStringConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YPriceToStringConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YPriceToStringConverter.java
new file mode 100644
index 0000000..41506dc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YPriceToStringConverter.java
@@ -0,0 +1,150 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YPrice To String Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getValuePropertyPath <em>Value Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getCurrencyPropertyPath <em>Currency Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getType <em>Type</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYPriceToStringConverter()
+ * @model
+ * @generated
+ */
+public interface YPriceToStringConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Value Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value Property Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value Property Path</em>' attribute.
+	 * @see #setValuePropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYPriceToStringConverter_ValuePropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getValuePropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getValuePropertyPath <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value Property Path</em>' attribute.
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 */
+	void setValuePropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Currency Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Currency Property Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Currency Property Path</em>' attribute.
+	 * @see #setCurrencyPropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYPriceToStringConverter_CurrencyPropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getCurrencyPropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getCurrencyPropertyPath <em>Currency Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Currency Property Path</em>' attribute.
+	 * @see #getCurrencyPropertyPath()
+	 * @generated
+	 */
+	void setCurrencyPropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYPriceToStringConverter_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYPriceToStringConverter_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YQuantityToStringConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YQuantityToStringConverter.java
new file mode 100644
index 0000000..469be32
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YQuantityToStringConverter.java
@@ -0,0 +1,146 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YQuantity To String Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getAmountPropertyPath <em>Amount Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomPropertyPath <em>Uom Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomCodeRelativePropertyPath <em>Uom Code Relative Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getQuantityTypeQualifiedName <em>Quantity Type Qualified Name</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYQuantityToStringConverter()
+ * @model
+ * @generated
+ */
+public interface YQuantityToStringConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Amount Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * The property path in DOT notation to access the amount value in the quantity object.
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Amount Property Path</em>' attribute.
+	 * @see #setAmountPropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYQuantityToStringConverter_AmountPropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getAmountPropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getAmountPropertyPath <em>Amount Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Amount Property Path</em>' attribute.
+	 * @see #getAmountPropertyPath()
+	 * @generated
+	 */
+	void setAmountPropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Uom Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 *	The property path in DOT notation to access the uom object in the quantity object.
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Uom Property Path</em>' attribute.
+	 * @see #setUomPropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYQuantityToStringConverter_UomPropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getUomPropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomPropertyPath <em>Uom Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Uom Property Path</em>' attribute.
+	 * @see #getUomPropertyPath()
+	 * @generated
+	 */
+	void setUomPropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Uom Code Relative Property Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * The relative property path in DOT notation to access the uom-code to show in the uom object.
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Uom Code Relative Property Path</em>' attribute.
+	 * @see #setUomCodeRelativePropertyPath(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYQuantityToStringConverter_UomCodeRelativePropertyPath()
+	 * @model required="true"
+	 * @generated
+	 */
+	String getUomCodeRelativePropertyPath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getUomCodeRelativePropertyPath <em>Uom Code Relative Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Uom Code Relative Property Path</em>' attribute.
+	 * @see #getUomCodeRelativePropertyPath()
+	 * @generated
+	 */
+	void setUomCodeRelativePropertyPath(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Quantity Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * The full qualified name of the Quantity class. 
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Quantity Type Qualified Name</em>' attribute.
+	 * @see #setQuantityTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYQuantityToStringConverter_QuantityTypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getQuantityTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter#getQuantityTypeQualifiedName <em>Quantity Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Quantity Type Qualified Name</em>' attribute.
+	 * @see #getQuantityTypeQualifiedName()
+	 * @generated
+	 */
+	void setQuantityTypeQualifiedName(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YSimpleDecimalConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YSimpleDecimalConverter.java
new file mode 100644
index 0000000..9d4f165
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YSimpleDecimalConverter.java
@@ -0,0 +1,69 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YSimple Decimal Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter#getNumberFormatPattern <em>Number Format Pattern</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYSimpleDecimalConverter()
+ * @model
+ * @generated
+ */
+public interface YSimpleDecimalConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Number Format Pattern</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Number Format Pattern</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Number Format Pattern</em>' attribute.
+	 * @see #setNumberFormatPattern(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYSimpleDecimalConverter_NumberFormatPattern()
+	 * @model
+	 * @generated
+	 */
+	String getNumberFormatPattern();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter#getNumberFormatPattern <em>Number Format Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Number Format Pattern</em>' attribute.
+	 * @see #getNumberFormatPattern()
+	 * @generated
+	 */
+	void setNumberFormatPattern(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YStringToResourceConfig.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YStringToResourceConfig.java
new file mode 100644
index 0000000..97551f2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YStringToResourceConfig.java
@@ -0,0 +1,127 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.core.common.model.core.YCompare;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YString To Resource Config</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getCompare <em>Compare</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getResourceThemePath <em>Resource Theme Path</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYStringToResourceConfig()
+ * @model
+ * @generated
+ */
+public interface YStringToResourceConfig extends EObject {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYStringToResourceConfig_Value()
+	 * @model
+	 * @generated
+	 */
+	String getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Compare</b></em>' attribute.
+	 * The literals are from the enumeration {@link org.eclipse.osbp.ecview.core.common.model.core.YCompare}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Compare</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Compare</em>' attribute.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCompare
+	 * @see #setCompare(YCompare)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYStringToResourceConfig_Compare()
+	 * @model
+	 * @generated
+	 */
+	YCompare getCompare();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getCompare <em>Compare</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Compare</em>' attribute.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCompare
+	 * @see #getCompare()
+	 * @generated
+	 */
+	void setCompare(YCompare value);
+
+	/**
+	 * Returns the value of the '<em><b>Resource Theme Path</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Resource Theme Path</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Resource Theme Path</em>' attribute.
+	 * @see #setResourceThemePath(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYStringToResourceConfig_ResourceThemePath()
+	 * @model
+	 * @generated
+	 */
+	String getResourceThemePath();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig#getResourceThemePath <em>Resource Theme Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Resource Theme Path</em>' attribute.
+	 * @see #getResourceThemePath()
+	 * @generated
+	 */
+	void setResourceThemePath(String value);
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YStringToResourceConverter.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YStringToResourceConverter.java
new file mode 100644
index 0000000..75c8d6f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/YStringToResourceConverter.java
@@ -0,0 +1,60 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YString To Resource Converter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter#getConfigs <em>Configs</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYStringToResourceConverter()
+ * @model
+ * @generated
+ */
+public interface YStringToResourceConverter extends YConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Configs</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Configs</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Configs</em>' containment reference list.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#getYStringToResourceConverter_Configs()
+	 * @model containment="true"
+	 * @generated
+	 */
+	EList<YStringToResourceConfig> getConfigs();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YConverterFactoryImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YConverterFactoryImpl.java
new file mode 100644
index 0000000..a1fafc7
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YConverterFactoryImpl.java
@@ -0,0 +1,249 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YConverterFactoryImpl extends EFactoryImpl implements YConverterFactory {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	public static YConverterFactory init() {
+		try {
+			YConverterFactory theYConverterFactory = (YConverterFactory)EPackage.Registry.INSTANCE.getEFactory(YConverterPackage.eNS_URI);
+			if (theYConverterFactory != null) {
+				return theYConverterFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new YConverterFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YConverterFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param eClass
+	 *            the e class
+	 * @return the e object
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER: return createYObjectToStringConverter();
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER: return createYCustomDecimalConverter();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER: return createYNumericToResourceConverter();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER: return createYStringToResourceConverter();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG: return createYNumericToResourceConfig();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG: return createYStringToResourceConfig();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER: return createYPriceToStringConverter();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER: return createYQuantityToStringConverter();
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER: return createYNumericToUomoConverter();
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER: return createYDecimalToUomoConverter();
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER: return createYSimpleDecimalConverter();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y object to string converter
+	 * @generated
+	 */
+	public YObjectToStringConverter createYObjectToStringConverter() {
+		YObjectToStringConverterImpl yObjectToStringConverter = new YObjectToStringConverterImpl();
+		return yObjectToStringConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal converter
+	 * @generated
+	 */
+	public YCustomDecimalConverter createYCustomDecimalConverter() {
+		YCustomDecimalConverterImpl yCustomDecimalConverter = new YCustomDecimalConverterImpl();
+		return yCustomDecimalConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource converter
+	 * @generated
+	 */
+	public YNumericToResourceConverter createYNumericToResourceConverter() {
+		YNumericToResourceConverterImpl yNumericToResourceConverter = new YNumericToResourceConverterImpl();
+		return yNumericToResourceConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource converter
+	 * @generated
+	 */
+	public YStringToResourceConverter createYStringToResourceConverter() {
+		YStringToResourceConverterImpl yStringToResourceConverter = new YStringToResourceConverterImpl();
+		return yStringToResourceConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource config
+	 * @generated
+	 */
+	public YNumericToResourceConfig createYNumericToResourceConfig() {
+		YNumericToResourceConfigImpl yNumericToResourceConfig = new YNumericToResourceConfigImpl();
+		return yNumericToResourceConfig;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource config
+	 * @generated
+	 */
+	public YStringToResourceConfig createYStringToResourceConfig() {
+		YStringToResourceConfigImpl yStringToResourceConfig = new YStringToResourceConfigImpl();
+		return yStringToResourceConfig;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to uomo converter
+	 * @generated
+	 */
+	public YNumericToUomoConverter createYNumericToUomoConverter() {
+		YNumericToUomoConverterImpl yNumericToUomoConverter = new YNumericToUomoConverterImpl();
+		return yNumericToUomoConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y decimal to uomo converter
+	 * @generated
+	 */
+	public YDecimalToUomoConverter createYDecimalToUomoConverter() {
+		YDecimalToUomoConverterImpl yDecimalToUomoConverter = new YDecimalToUomoConverterImpl();
+		return yDecimalToUomoConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y simple decimal converter
+	 * @generated
+	 */
+	public YSimpleDecimalConverter createYSimpleDecimalConverter() {
+		YSimpleDecimalConverterImpl ySimpleDecimalConverter = new YSimpleDecimalConverterImpl();
+		return ySimpleDecimalConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y price to string converter
+	 * @generated
+	 */
+	public YPriceToStringConverter createYPriceToStringConverter() {
+		YPriceToStringConverterImpl yPriceToStringConverter = new YPriceToStringConverterImpl();
+		return yPriceToStringConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity to string converter
+	 * @generated
+	 */
+	public YQuantityToStringConverter createYQuantityToStringConverter() {
+		YQuantityToStringConverterImpl yQuantityToStringConverter = new YQuantityToStringConverterImpl();
+		return yQuantityToStringConverter;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y converter package
+	 * @generated
+	 */
+	public YConverterPackage getYConverterPackage() {
+		return (YConverterPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the package
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static YConverterPackage getPackage() {
+		return YConverterPackage.eINSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YConverterPackageImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YConverterPackageImpl.java
new file mode 100644
index 0000000..80cc241
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YConverterPackageImpl.java
@@ -0,0 +1,661 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EGenericType;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterFactory;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter;
+import org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+import org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityPackageImpl;
+import org.eclipse.xtext.common.types.TypesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YConverterPackageImpl extends EPackageImpl implements YConverterPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yObjectToStringConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yCustomDecimalConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yNumericToResourceConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yStringToResourceConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yNumericToResourceConfigEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yStringToResourceConfigEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yNumericToUomoConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yDecimalToUomoConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass ySimpleDecimalConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yPriceToStringConverterEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yQuantityToStringConverterEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private YConverterPackageImpl() {
+		super(eNS_URI, YConverterFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model,
+	 * and for any others upon which it depends.
+	 * 
+	 * <p>
+	 * This method is used to initialize {@link YConverterPackage#eINSTANCE}
+	 * when that field is accessed. Clients should not invoke it directly.
+	 * Instead, they should simply access that field to obtain the package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the y converter package
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static YConverterPackage init() {
+		if (isInited) return (YConverterPackage)EPackage.Registry.INSTANCE.getEPackage(YConverterPackage.eNS_URI);
+
+		// Obtain or create and register package
+		YConverterPackageImpl theYConverterPackage = (YConverterPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof YConverterPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new YConverterPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		ExtDatatypesPackage.eINSTANCE.eClass();
+		ExtensionModelPackage.eINSTANCE.eClass();
+		TypesPackage.eINSTANCE.eClass();
+
+		// Obtain or create and register interdependencies
+		YECviewPackageImpl theYECviewPackage = (YECviewPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(YECviewPackage.eNS_URI) instanceof YECviewPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(YECviewPackage.eNS_URI) : YECviewPackage.eINSTANCE);
+		YVisibilityPackageImpl theYVisibilityPackage = (YVisibilityPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(YVisibilityPackage.eNS_URI) instanceof YVisibilityPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(YVisibilityPackage.eNS_URI) : YVisibilityPackage.eINSTANCE);
+
+		// Create package meta-data objects
+		theYConverterPackage.createPackageContents();
+		theYECviewPackage.createPackageContents();
+		theYVisibilityPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theYConverterPackage.initializePackageContents();
+		theYECviewPackage.initializePackageContents();
+		theYVisibilityPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theYConverterPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(YConverterPackage.eNS_URI, theYConverterPackage);
+		return theYConverterPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y object to string converter
+	 * @generated
+	 */
+	public EClass getYObjectToStringConverter() {
+		return yObjectToStringConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal converter
+	 * @generated
+	 */
+	public EClass getYCustomDecimalConverter() {
+		return yCustomDecimalConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal converter_ base unit
+	 * @generated
+	 */
+	public EAttribute getYCustomDecimalConverter_BaseUnit() {
+		return (EAttribute)yCustomDecimalConverterEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource converter
+	 * @generated
+	 */
+	public EClass getYNumericToResourceConverter() {
+		return yNumericToResourceConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource converter_ configs
+	 * @generated
+	 */
+	public EReference getYNumericToResourceConverter_Configs() {
+		return (EReference)yNumericToResourceConverterEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource converter
+	 * @generated
+	 */
+	public EClass getYStringToResourceConverter() {
+		return yStringToResourceConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource converter_ configs
+	 * @generated
+	 */
+	public EReference getYStringToResourceConverter_Configs() {
+		return (EReference)yStringToResourceConverterEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource config
+	 * @generated
+	 */
+	public EClass getYNumericToResourceConfig() {
+		return yNumericToResourceConfigEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource config_ value
+	 * @generated
+	 */
+	public EAttribute getYNumericToResourceConfig_Value() {
+		return (EAttribute)yNumericToResourceConfigEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource config_ compare
+	 * @generated
+	 */
+	public EAttribute getYNumericToResourceConfig_Compare() {
+		return (EAttribute)yNumericToResourceConfigEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to resource config_ resource theme path
+	 * @generated
+	 */
+	public EAttribute getYNumericToResourceConfig_ResourceThemePath() {
+		return (EAttribute)yNumericToResourceConfigEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource config
+	 * @generated
+	 */
+	public EClass getYStringToResourceConfig() {
+		return yStringToResourceConfigEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource config_ value
+	 * @generated
+	 */
+	public EAttribute getYStringToResourceConfig_Value() {
+		return (EAttribute)yStringToResourceConfigEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource config_ compare
+	 * @generated
+	 */
+	public EAttribute getYStringToResourceConfig_Compare() {
+		return (EAttribute)yStringToResourceConfigEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y string to resource config_ resource theme path
+	 * @generated
+	 */
+	public EAttribute getYStringToResourceConfig_ResourceThemePath() {
+		return (EAttribute)yStringToResourceConfigEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y numeric to uomo converter
+	 * @generated
+	 */
+	public EClass getYNumericToUomoConverter() {
+		return yNumericToUomoConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y decimal to uomo converter
+	 * @generated
+	 */
+	public EClass getYDecimalToUomoConverter() {
+		return yDecimalToUomoConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y simple decimal converter
+	 * @generated
+	 */
+	public EClass getYSimpleDecimalConverter() {
+		return ySimpleDecimalConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y simple decimal converter_ number format pattern
+	 * @generated
+	 */
+	public EAttribute getYSimpleDecimalConverter_NumberFormatPattern() {
+		return (EAttribute)ySimpleDecimalConverterEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y price to string converter
+	 * @generated
+	 */
+	public EClass getYPriceToStringConverter() {
+		return yPriceToStringConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y price to string converter_ value property path
+	 * @generated
+	 */
+	public EAttribute getYPriceToStringConverter_ValuePropertyPath() {
+		return (EAttribute)yPriceToStringConverterEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y price to string converter_ currency property path
+	 * @generated
+	 */
+	public EAttribute getYPriceToStringConverter_CurrencyPropertyPath() {
+		return (EAttribute)yPriceToStringConverterEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y price to string converter_ type qualified name
+	 * @generated
+	 */
+	public EAttribute getYPriceToStringConverter_TypeQualifiedName() {
+		return (EAttribute)yPriceToStringConverterEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y price to string converter_ type
+	 * @generated
+	 */
+	public EAttribute getYPriceToStringConverter_Type() {
+		return (EAttribute)yPriceToStringConverterEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity to string converter
+	 * @generated
+	 */
+	public EClass getYQuantityToStringConverter() {
+		return yQuantityToStringConverterEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity to string converter_ amount property path
+	 * @generated
+	 */
+	public EAttribute getYQuantityToStringConverter_AmountPropertyPath() {
+		return (EAttribute)yQuantityToStringConverterEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity to string converter_ uom property path
+	 * @generated
+	 */
+	public EAttribute getYQuantityToStringConverter_UomPropertyPath() {
+		return (EAttribute)yQuantityToStringConverterEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity to string converter_ uom code relative property
+	 *         path
+	 * @generated
+	 */
+	public EAttribute getYQuantityToStringConverter_UomCodeRelativePropertyPath() {
+		return (EAttribute)yQuantityToStringConverterEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity to string converter_ quantity type qualified name
+	 * @generated
+	 */
+	public EAttribute getYQuantityToStringConverter_QuantityTypeQualifiedName() {
+		return (EAttribute)yQuantityToStringConverterEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y converter factory
+	 * @generated
+	 */
+	public YConverterFactory getYConverterFactory() {
+		return (YConverterFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		yObjectToStringConverterEClass = createEClass(YOBJECT_TO_STRING_CONVERTER);
+
+		yCustomDecimalConverterEClass = createEClass(YCUSTOM_DECIMAL_CONVERTER);
+		createEAttribute(yCustomDecimalConverterEClass, YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT);
+
+		yNumericToResourceConverterEClass = createEClass(YNUMERIC_TO_RESOURCE_CONVERTER);
+		createEReference(yNumericToResourceConverterEClass, YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS);
+
+		yStringToResourceConverterEClass = createEClass(YSTRING_TO_RESOURCE_CONVERTER);
+		createEReference(yStringToResourceConverterEClass, YSTRING_TO_RESOURCE_CONVERTER__CONFIGS);
+
+		yNumericToResourceConfigEClass = createEClass(YNUMERIC_TO_RESOURCE_CONFIG);
+		createEAttribute(yNumericToResourceConfigEClass, YNUMERIC_TO_RESOURCE_CONFIG__VALUE);
+		createEAttribute(yNumericToResourceConfigEClass, YNUMERIC_TO_RESOURCE_CONFIG__COMPARE);
+		createEAttribute(yNumericToResourceConfigEClass, YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH);
+
+		yStringToResourceConfigEClass = createEClass(YSTRING_TO_RESOURCE_CONFIG);
+		createEAttribute(yStringToResourceConfigEClass, YSTRING_TO_RESOURCE_CONFIG__VALUE);
+		createEAttribute(yStringToResourceConfigEClass, YSTRING_TO_RESOURCE_CONFIG__COMPARE);
+		createEAttribute(yStringToResourceConfigEClass, YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH);
+
+		yPriceToStringConverterEClass = createEClass(YPRICE_TO_STRING_CONVERTER);
+		createEAttribute(yPriceToStringConverterEClass, YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH);
+		createEAttribute(yPriceToStringConverterEClass, YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH);
+		createEAttribute(yPriceToStringConverterEClass, YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME);
+		createEAttribute(yPriceToStringConverterEClass, YPRICE_TO_STRING_CONVERTER__TYPE);
+
+		yQuantityToStringConverterEClass = createEClass(YQUANTITY_TO_STRING_CONVERTER);
+		createEAttribute(yQuantityToStringConverterEClass, YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH);
+		createEAttribute(yQuantityToStringConverterEClass, YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH);
+		createEAttribute(yQuantityToStringConverterEClass, YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH);
+		createEAttribute(yQuantityToStringConverterEClass, YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME);
+
+		yNumericToUomoConverterEClass = createEClass(YNUMERIC_TO_UOMO_CONVERTER);
+
+		yDecimalToUomoConverterEClass = createEClass(YDECIMAL_TO_UOMO_CONVERTER);
+
+		ySimpleDecimalConverterEClass = createEClass(YSIMPLE_DECIMAL_CONVERTER);
+		createEAttribute(ySimpleDecimalConverterEClass, YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		CoreModelPackage theCoreModelPackage = (CoreModelPackage)EPackage.Registry.INSTANCE.getEPackage(CoreModelPackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		yObjectToStringConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		yCustomDecimalConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		yNumericToResourceConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		yStringToResourceConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		yPriceToStringConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		yQuantityToStringConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		yNumericToUomoConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		yDecimalToUomoConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+		ySimpleDecimalConverterEClass.getESuperTypes().add(theCoreModelPackage.getYConverter());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(yObjectToStringConverterEClass, YObjectToStringConverter.class, "YObjectToStringConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(yCustomDecimalConverterEClass, YCustomDecimalConverter.class, "YCustomDecimalConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYCustomDecimalConverter_BaseUnit(), ecorePackage.getEString(), "baseUnit", null, 0, 1, YCustomDecimalConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yNumericToResourceConverterEClass, YNumericToResourceConverter.class, "YNumericToResourceConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYNumericToResourceConverter_Configs(), this.getYNumericToResourceConfig(), null, "configs", null, 0, -1, YNumericToResourceConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yStringToResourceConverterEClass, YStringToResourceConverter.class, "YStringToResourceConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYStringToResourceConverter_Configs(), this.getYStringToResourceConfig(), null, "configs", null, 0, -1, YStringToResourceConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yNumericToResourceConfigEClass, YNumericToResourceConfig.class, "YNumericToResourceConfig", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYNumericToResourceConfig_Value(), ecorePackage.getEDouble(), "value", null, 0, 1, YNumericToResourceConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYNumericToResourceConfig_Compare(), theCoreModelPackage.getYCompare(), "compare", null, 0, 1, YNumericToResourceConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYNumericToResourceConfig_ResourceThemePath(), ecorePackage.getEString(), "resourceThemePath", null, 0, 1, YNumericToResourceConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yStringToResourceConfigEClass, YStringToResourceConfig.class, "YStringToResourceConfig", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYStringToResourceConfig_Value(), ecorePackage.getEString(), "value", null, 0, 1, YStringToResourceConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYStringToResourceConfig_Compare(), theCoreModelPackage.getYCompare(), "compare", null, 0, 1, YStringToResourceConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYStringToResourceConfig_ResourceThemePath(), ecorePackage.getEString(), "resourceThemePath", null, 0, 1, YStringToResourceConfig.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yPriceToStringConverterEClass, YPriceToStringConverter.class, "YPriceToStringConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYPriceToStringConverter_ValuePropertyPath(), ecorePackage.getEString(), "valuePropertyPath", null, 1, 1, YPriceToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPriceToStringConverter_CurrencyPropertyPath(), ecorePackage.getEString(), "currencyPropertyPath", null, 1, 1, YPriceToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPriceToStringConverter_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, YPriceToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		EGenericType g1 = createEGenericType(ecorePackage.getEJavaClass());
+		EGenericType g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getYPriceToStringConverter_Type(), g1, "type", null, 0, 1, YPriceToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yQuantityToStringConverterEClass, YQuantityToStringConverter.class, "YQuantityToStringConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYQuantityToStringConverter_AmountPropertyPath(), ecorePackage.getEString(), "amountPropertyPath", null, 1, 1, YQuantityToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYQuantityToStringConverter_UomPropertyPath(), ecorePackage.getEString(), "uomPropertyPath", null, 1, 1, YQuantityToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYQuantityToStringConverter_UomCodeRelativePropertyPath(), ecorePackage.getEString(), "uomCodeRelativePropertyPath", null, 1, 1, YQuantityToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYQuantityToStringConverter_QuantityTypeQualifiedName(), ecorePackage.getEString(), "quantityTypeQualifiedName", null, 0, 1, YQuantityToStringConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yNumericToUomoConverterEClass, YNumericToUomoConverter.class, "YNumericToUomoConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(yDecimalToUomoConverterEClass, YDecimalToUomoConverter.class, "YDecimalToUomoConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(ySimpleDecimalConverterEClass, YSimpleDecimalConverter.class, "YSimpleDecimalConverter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYSimpleDecimalConverter_NumberFormatPattern(), ecorePackage.getEString(), "numberFormatPattern", null, 0, 1, YSimpleDecimalConverter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YCustomDecimalConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YCustomDecimalConverterImpl.java
new file mode 100644
index 0000000..86b563d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YCustomDecimalConverterImpl.java
@@ -0,0 +1,427 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YCustom Decimal Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YCustomDecimalConverterImpl#getBaseUnit <em>Base Unit</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YCustomDecimalConverterImpl extends MinimalEObjectImpl.Container implements YCustomDecimalConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getBaseUnit() <em>Base Unit</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getBaseUnit()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String BASE_UNIT_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getBaseUnit() <em>Base Unit</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getBaseUnit()
+	 * @generated
+	 * @ordered
+	 */
+	protected String baseUnit = BASE_UNIT_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YCustomDecimalConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YCUSTOM_DECIMAL_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getBaseUnit()
+	 *         <em>Base Unit</em>}' attribute
+	 * @generated
+	 */
+	public String getBaseUnit() {
+		return baseUnit;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newBaseUnit
+	 *            the new cached value of the '{@link #getBaseUnit()
+	 *            <em>Base Unit</em>}' attribute
+	 * @generated
+	 */
+	public void setBaseUnit(String newBaseUnit) {
+		String oldBaseUnit = baseUnit;
+		baseUnit = newBaseUnit;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT, oldBaseUnit, baseUnit));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT:
+				return getBaseUnit();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT:
+				setBaseUnit((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT:
+				setBaseUnit(BASE_UNIT_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER__BASE_UNIT:
+				return BASE_UNIT_EDEFAULT == null ? baseUnit != null : !BASE_UNIT_EDEFAULT.equals(baseUnit);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", baseUnit: ");
+		result.append(baseUnit);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YDecimalToUomoConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YDecimalToUomoConverterImpl.java
new file mode 100644
index 0000000..0ce364f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YDecimalToUomoConverterImpl.java
@@ -0,0 +1,368 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YDecimal To Uomo Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YDecimalToUomoConverterImpl#getProperties <em>Properties</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YDecimalToUomoConverterImpl extends MinimalEObjectImpl.Container implements YDecimalToUomoConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YDecimalToUomoConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YDECIMAL_TO_UOMO_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToResourceConfigImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToResourceConfigImpl.java
new file mode 100644
index 0000000..b7a2ab8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToResourceConfigImpl.java
@@ -0,0 +1,321 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.YCompare;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YNumeric To Resource Config</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConfigImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConfigImpl#getCompare <em>Compare</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConfigImpl#getResourceThemePath <em>Resource Theme Path</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YNumericToResourceConfigImpl extends MinimalEObjectImpl.Container implements YNumericToResourceConfig {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double VALUE_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected double value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getCompare() <em>Compare</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCompare()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final YCompare COMPARE_EDEFAULT = YCompare.EQUAL;
+
+	/**
+	 * The cached value of the '{@link #getCompare() <em>Compare</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCompare()
+	 * @generated
+	 * @ordered
+	 */
+	protected YCompare compare = COMPARE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getResourceThemePath() <em>Resource Theme Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getResourceThemePath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String RESOURCE_THEME_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getResourceThemePath() <em>Resource Theme Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getResourceThemePath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String resourceThemePath = RESOURCE_THEME_PATH_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YNumericToResourceConfigImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YNUMERIC_TO_RESOURCE_CONFIG;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValue() <em>Value</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public double getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValue
+	 *            the new cached value of the '{@link #getValue()
+	 *            <em>Value</em>}' attribute
+	 * @generated
+	 */
+	public void setValue(double newValue) {
+		double oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCompare() <em>Compare</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public YCompare getCompare() {
+		return compare;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCompare
+	 *            the new cached value of the '{@link #getCompare()
+	 *            <em>Compare</em>}' attribute
+	 * @generated
+	 */
+	public void setCompare(YCompare newCompare) {
+		YCompare oldCompare = compare;
+		compare = newCompare == null ? COMPARE_EDEFAULT : newCompare;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__COMPARE, oldCompare, compare));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getResourceThemePath()
+	 *         <em>Resource Theme Path</em>}' attribute
+	 * @generated
+	 */
+	public String getResourceThemePath() {
+		return resourceThemePath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newResourceThemePath
+	 *            the new cached value of the '{@link #getResourceThemePath()
+	 *            <em>Resource Theme Path</em>}' attribute
+	 * @generated
+	 */
+	public void setResourceThemePath(String newResourceThemePath) {
+		String oldResourceThemePath = resourceThemePath;
+		resourceThemePath = newResourceThemePath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH, oldResourceThemePath, resourceThemePath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__VALUE:
+				return getValue();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__COMPARE:
+				return getCompare();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				return getResourceThemePath();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__VALUE:
+				setValue((Double)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__COMPARE:
+				setCompare((YCompare)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				setResourceThemePath((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__COMPARE:
+				setCompare(COMPARE_EDEFAULT);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				setResourceThemePath(RESOURCE_THEME_PATH_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__VALUE:
+				return value != VALUE_EDEFAULT;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__COMPARE:
+				return compare != COMPARE_EDEFAULT;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				return RESOURCE_THEME_PATH_EDEFAULT == null ? resourceThemePath != null : !RESOURCE_THEME_PATH_EDEFAULT.equals(resourceThemePath);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(", compare: ");
+		result.append(compare);
+		result.append(", resourceThemePath: ");
+		result.append(resourceThemePath);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToResourceConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToResourceConverterImpl.java
new file mode 100644
index 0000000..518f433
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToResourceConverterImpl.java
@@ -0,0 +1,408 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YNumeric To Resource Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToResourceConverterImpl#getConfigs <em>Configs</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YNumericToResourceConverterImpl extends MinimalEObjectImpl.Container implements YNumericToResourceConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getConfigs() <em>Configs</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getConfigs()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YNumericToResourceConfig> configs;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YNumericToResourceConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YNUMERIC_TO_RESOURCE_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getConfigs() <em>Configs</em>}'
+	 *         containment reference list
+	 * @generated
+	 */
+	public EList<YNumericToResourceConfig> getConfigs() {
+		if (configs == null) {
+			configs = new EObjectContainmentEList<YNumericToResourceConfig>(YNumericToResourceConfig.class, this, YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS);
+		}
+		return configs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS:
+				return ((InternalEList<?>)getConfigs()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS:
+				return getConfigs();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS:
+				getConfigs().clear();
+				getConfigs().addAll((Collection<? extends YNumericToResourceConfig>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS:
+				getConfigs().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER__CONFIGS:
+				return configs != null && !configs.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToUomoConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToUomoConverterImpl.java
new file mode 100644
index 0000000..409f95b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YNumericToUomoConverterImpl.java
@@ -0,0 +1,368 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YNumeric To Uomo Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YNumericToUomoConverterImpl#getProperties <em>Properties</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YNumericToUomoConverterImpl extends MinimalEObjectImpl.Container implements YNumericToUomoConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YNumericToUomoConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YNUMERIC_TO_UOMO_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YObjectToStringConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YObjectToStringConverterImpl.java
new file mode 100644
index 0000000..dbc81ca
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YObjectToStringConverterImpl.java
@@ -0,0 +1,368 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YObject To String Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YObjectToStringConverterImpl#getProperties <em>Properties</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YObjectToStringConverterImpl extends MinimalEObjectImpl.Container implements YObjectToStringConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YObjectToStringConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YOBJECT_TO_STRING_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YOBJECT_TO_STRING_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YOBJECT_TO_STRING_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YOBJECT_TO_STRING_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YOBJECT_TO_STRING_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YPriceToStringConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YPriceToStringConverterImpl.java
new file mode 100644
index 0000000..1474123
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YPriceToStringConverterImpl.java
@@ -0,0 +1,595 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YPrice To String Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getValuePropertyPath <em>Value Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getCurrencyPropertyPath <em>Currency Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YPriceToStringConverterImpl#getType <em>Type</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YPriceToStringConverterImpl extends MinimalEObjectImpl.Container implements YPriceToStringConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getValuePropertyPath() <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValuePropertyPath() <em>Value Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValuePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String valuePropertyPath = VALUE_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getCurrencyPropertyPath() <em>Currency Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCurrencyPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String CURRENCY_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getCurrencyPropertyPath() <em>Currency Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCurrencyPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String currencyPropertyPath = CURRENCY_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YPriceToStringConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YPRICE_TO_STRING_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YPRICE_TO_STRING_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YPRICE_TO_STRING_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YPRICE_TO_STRING_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YPRICE_TO_STRING_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValuePropertyPath()
+	 *         <em>Value Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getValuePropertyPath() {
+		return valuePropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValuePropertyPath
+	 *            the new cached value of the '{@link #getValuePropertyPath()
+	 *            <em>Value Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setValuePropertyPath(String newValuePropertyPath) {
+		String oldValuePropertyPath = valuePropertyPath;
+		valuePropertyPath = newValuePropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH, oldValuePropertyPath, valuePropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCurrencyPropertyPath()
+	 *         <em>Currency Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getCurrencyPropertyPath() {
+		return currencyPropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCurrencyPropertyPath
+	 *            the new cached value of the '
+	 *            {@link #getCurrencyPropertyPath()
+	 *            <em>Currency Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setCurrencyPropertyPath(String newCurrencyPropertyPath) {
+		String oldCurrencyPropertyPath = currencyPropertyPath;
+		currencyPropertyPath = newCurrencyPropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH, oldCurrencyPropertyPath, currencyPropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTypeQualifiedName()
+	 *         <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTypeQualifiedName
+	 *            the new cached value of the '{@link #getTypeQualifiedName()
+	 *            <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getType() <em>Type</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newType
+	 *            the new cached value of the '{@link #getType() <em>Type</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH:
+				return getValuePropertyPath();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH:
+				return getCurrencyPropertyPath();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME:
+				return getTypeQualifiedName();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE:
+				return getType();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH:
+				setValuePropertyPath((String)newValue);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH:
+				setCurrencyPropertyPath((String)newValue);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName((String)newValue);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE:
+				setType((Class<?>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH:
+				setValuePropertyPath(VALUE_PROPERTY_PATH_EDEFAULT);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH:
+				setCurrencyPropertyPath(CURRENCY_PROPERTY_PATH_EDEFAULT);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE:
+				setType((Class<?>)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__VALUE_PROPERTY_PATH:
+				return VALUE_PROPERTY_PATH_EDEFAULT == null ? valuePropertyPath != null : !VALUE_PROPERTY_PATH_EDEFAULT.equals(valuePropertyPath);
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__CURRENCY_PROPERTY_PATH:
+				return CURRENCY_PROPERTY_PATH_EDEFAULT == null ? currencyPropertyPath != null : !CURRENCY_PROPERTY_PATH_EDEFAULT.equals(currencyPropertyPath);
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE_QUALIFIED_NAME:
+				return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER__TYPE:
+				return type != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", valuePropertyPath: ");
+		result.append(valuePropertyPath);
+		result.append(", currencyPropertyPath: ");
+		result.append(currencyPropertyPath);
+		result.append(", typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(", type: ");
+		result.append(type);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YQuantityToStringConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YQuantityToStringConverterImpl.java
new file mode 100644
index 0000000..3b005fd
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YQuantityToStringConverterImpl.java
@@ -0,0 +1,607 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YQuantity To String Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getAmountPropertyPath <em>Amount Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getUomPropertyPath <em>Uom Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getUomCodeRelativePropertyPath <em>Uom Code Relative Property Path</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YQuantityToStringConverterImpl#getQuantityTypeQualifiedName <em>Quantity Type Qualified Name</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YQuantityToStringConverterImpl extends MinimalEObjectImpl.Container implements YQuantityToStringConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getAmountPropertyPath() <em>Amount Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAmountPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String AMOUNT_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getAmountPropertyPath() <em>Amount Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAmountPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String amountPropertyPath = AMOUNT_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getUomPropertyPath() <em>Uom Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUomPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String UOM_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getUomPropertyPath() <em>Uom Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUomPropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String uomPropertyPath = UOM_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getUomCodeRelativePropertyPath() <em>Uom Code Relative Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUomCodeRelativePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String UOM_CODE_RELATIVE_PROPERTY_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getUomCodeRelativePropertyPath() <em>Uom Code Relative Property Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUomCodeRelativePropertyPath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String uomCodeRelativePropertyPath = UOM_CODE_RELATIVE_PROPERTY_PATH_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getQuantityTypeQualifiedName() <em>Quantity Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getQuantityTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String QUANTITY_TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getQuantityTypeQualifiedName() <em>Quantity Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getQuantityTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String quantityTypeQualifiedName = QUANTITY_TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YQuantityToStringConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YQUANTITY_TO_STRING_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getAmountPropertyPath()
+	 *         <em>Amount Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getAmountPropertyPath() {
+		return amountPropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newAmountPropertyPath
+	 *            the new cached value of the '{@link #getAmountPropertyPath()
+	 *            <em>Amount Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setAmountPropertyPath(String newAmountPropertyPath) {
+		String oldAmountPropertyPath = amountPropertyPath;
+		amountPropertyPath = newAmountPropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH, oldAmountPropertyPath, amountPropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getUomPropertyPath()
+	 *         <em>Uom Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getUomPropertyPath() {
+		return uomPropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newUomPropertyPath
+	 *            the new cached value of the '{@link #getUomPropertyPath()
+	 *            <em>Uom Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setUomPropertyPath(String newUomPropertyPath) {
+		String oldUomPropertyPath = uomPropertyPath;
+		uomPropertyPath = newUomPropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH, oldUomPropertyPath, uomPropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '
+	 *         {@link #getUomCodeRelativePropertyPath()
+	 *         <em>Uom Code Relative Property Path</em>}' attribute
+	 * @generated
+	 */
+	public String getUomCodeRelativePropertyPath() {
+		return uomCodeRelativePropertyPath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newUomCodeRelativePropertyPath
+	 *            the new cached value of the '
+	 *            {@link #getUomCodeRelativePropertyPath()
+	 *            <em>Uom Code Relative Property Path</em>}' attribute
+	 * @generated
+	 */
+	public void setUomCodeRelativePropertyPath(String newUomCodeRelativePropertyPath) {
+		String oldUomCodeRelativePropertyPath = uomCodeRelativePropertyPath;
+		uomCodeRelativePropertyPath = newUomCodeRelativePropertyPath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH, oldUomCodeRelativePropertyPath, uomCodeRelativePropertyPath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getQuantityTypeQualifiedName()
+	 *         <em>Quantity Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public String getQuantityTypeQualifiedName() {
+		return quantityTypeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newQuantityTypeQualifiedName
+	 *            the new cached value of the '
+	 *            {@link #getQuantityTypeQualifiedName()
+	 *            <em>Quantity Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public void setQuantityTypeQualifiedName(String newQuantityTypeQualifiedName) {
+		String oldQuantityTypeQualifiedName = quantityTypeQualifiedName;
+		quantityTypeQualifiedName = newQuantityTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME, oldQuantityTypeQualifiedName, quantityTypeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH:
+				return getAmountPropertyPath();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH:
+				return getUomPropertyPath();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH:
+				return getUomCodeRelativePropertyPath();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME:
+				return getQuantityTypeQualifiedName();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH:
+				setAmountPropertyPath((String)newValue);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH:
+				setUomPropertyPath((String)newValue);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH:
+				setUomCodeRelativePropertyPath((String)newValue);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME:
+				setQuantityTypeQualifiedName((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH:
+				setAmountPropertyPath(AMOUNT_PROPERTY_PATH_EDEFAULT);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH:
+				setUomPropertyPath(UOM_PROPERTY_PATH_EDEFAULT);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH:
+				setUomCodeRelativePropertyPath(UOM_CODE_RELATIVE_PROPERTY_PATH_EDEFAULT);
+				return;
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME:
+				setQuantityTypeQualifiedName(QUANTITY_TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__AMOUNT_PROPERTY_PATH:
+				return AMOUNT_PROPERTY_PATH_EDEFAULT == null ? amountPropertyPath != null : !AMOUNT_PROPERTY_PATH_EDEFAULT.equals(amountPropertyPath);
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_PROPERTY_PATH:
+				return UOM_PROPERTY_PATH_EDEFAULT == null ? uomPropertyPath != null : !UOM_PROPERTY_PATH_EDEFAULT.equals(uomPropertyPath);
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__UOM_CODE_RELATIVE_PROPERTY_PATH:
+				return UOM_CODE_RELATIVE_PROPERTY_PATH_EDEFAULT == null ? uomCodeRelativePropertyPath != null : !UOM_CODE_RELATIVE_PROPERTY_PATH_EDEFAULT.equals(uomCodeRelativePropertyPath);
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER__QUANTITY_TYPE_QUALIFIED_NAME:
+				return QUANTITY_TYPE_QUALIFIED_NAME_EDEFAULT == null ? quantityTypeQualifiedName != null : !QUANTITY_TYPE_QUALIFIED_NAME_EDEFAULT.equals(quantityTypeQualifiedName);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", amountPropertyPath: ");
+		result.append(amountPropertyPath);
+		result.append(", uomPropertyPath: ");
+		result.append(uomPropertyPath);
+		result.append(", uomCodeRelativePropertyPath: ");
+		result.append(uomCodeRelativePropertyPath);
+		result.append(", quantityTypeQualifiedName: ");
+		result.append(quantityTypeQualifiedName);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YSimpleDecimalConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YSimpleDecimalConverterImpl.java
new file mode 100644
index 0000000..2f2bb74
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YSimpleDecimalConverterImpl.java
@@ -0,0 +1,427 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YSimple Decimal Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YSimpleDecimalConverterImpl#getNumberFormatPattern <em>Number Format Pattern</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YSimpleDecimalConverterImpl extends MinimalEObjectImpl.Container implements YSimpleDecimalConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getNumberFormatPattern() <em>Number Format Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormatPattern()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NUMBER_FORMAT_PATTERN_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getNumberFormatPattern() <em>Number Format Pattern</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNumberFormatPattern()
+	 * @generated
+	 * @ordered
+	 */
+	protected String numberFormatPattern = NUMBER_FORMAT_PATTERN_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YSimpleDecimalConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YSIMPLE_DECIMAL_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNumberFormatPattern()
+	 *         <em>Number Format Pattern</em>}' attribute
+	 * @generated
+	 */
+	public String getNumberFormatPattern() {
+		return numberFormatPattern;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNumberFormatPattern
+	 *            the new cached value of the '{@link #getNumberFormatPattern()
+	 *            <em>Number Format Pattern</em>}' attribute
+	 * @generated
+	 */
+	public void setNumberFormatPattern(String newNumberFormatPattern) {
+		String oldNumberFormatPattern = numberFormatPattern;
+		numberFormatPattern = newNumberFormatPattern;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN, oldNumberFormatPattern, numberFormatPattern));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN:
+				return getNumberFormatPattern();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN:
+				setNumberFormatPattern((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN:
+				setNumberFormatPattern(NUMBER_FORMAT_PATTERN_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER__NUMBER_FORMAT_PATTERN:
+				return NUMBER_FORMAT_PATTERN_EDEFAULT == null ? numberFormatPattern != null : !NUMBER_FORMAT_PATTERN_EDEFAULT.equals(numberFormatPattern);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", numberFormatPattern: ");
+		result.append(numberFormatPattern);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YStringToResourceConfigImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YStringToResourceConfigImpl.java
new file mode 100644
index 0000000..d8ec47f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YStringToResourceConfigImpl.java
@@ -0,0 +1,321 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.YCompare;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YString To Resource Config</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConfigImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConfigImpl#getCompare <em>Compare</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConfigImpl#getResourceThemePath <em>Resource Theme Path</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YStringToResourceConfigImpl extends MinimalEObjectImpl.Container implements YStringToResourceConfig {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected String value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getCompare() <em>Compare</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCompare()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final YCompare COMPARE_EDEFAULT = YCompare.EQUAL;
+
+	/**
+	 * The cached value of the '{@link #getCompare() <em>Compare</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCompare()
+	 * @generated
+	 * @ordered
+	 */
+	protected YCompare compare = COMPARE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getResourceThemePath() <em>Resource Theme Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getResourceThemePath()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String RESOURCE_THEME_PATH_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getResourceThemePath() <em>Resource Theme Path</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getResourceThemePath()
+	 * @generated
+	 * @ordered
+	 */
+	protected String resourceThemePath = RESOURCE_THEME_PATH_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YStringToResourceConfigImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YSTRING_TO_RESOURCE_CONFIG;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValue() <em>Value</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValue
+	 *            the new cached value of the '{@link #getValue()
+	 *            <em>Value</em>}' attribute
+	 * @generated
+	 */
+	public void setValue(String newValue) {
+		String oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCompare() <em>Compare</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public YCompare getCompare() {
+		return compare;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCompare
+	 *            the new cached value of the '{@link #getCompare()
+	 *            <em>Compare</em>}' attribute
+	 * @generated
+	 */
+	public void setCompare(YCompare newCompare) {
+		YCompare oldCompare = compare;
+		compare = newCompare == null ? COMPARE_EDEFAULT : newCompare;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__COMPARE, oldCompare, compare));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getResourceThemePath()
+	 *         <em>Resource Theme Path</em>}' attribute
+	 * @generated
+	 */
+	public String getResourceThemePath() {
+		return resourceThemePath;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newResourceThemePath
+	 *            the new cached value of the '{@link #getResourceThemePath()
+	 *            <em>Resource Theme Path</em>}' attribute
+	 * @generated
+	 */
+	public void setResourceThemePath(String newResourceThemePath) {
+		String oldResourceThemePath = resourceThemePath;
+		resourceThemePath = newResourceThemePath;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH, oldResourceThemePath, resourceThemePath));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__VALUE:
+				return getValue();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__COMPARE:
+				return getCompare();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				return getResourceThemePath();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__VALUE:
+				setValue((String)newValue);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__COMPARE:
+				setCompare((YCompare)newValue);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				setResourceThemePath((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__COMPARE:
+				setCompare(COMPARE_EDEFAULT);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				setResourceThemePath(RESOURCE_THEME_PATH_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__COMPARE:
+				return compare != COMPARE_EDEFAULT;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG__RESOURCE_THEME_PATH:
+				return RESOURCE_THEME_PATH_EDEFAULT == null ? resourceThemePath != null : !RESOURCE_THEME_PATH_EDEFAULT.equals(resourceThemePath);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(", compare: ");
+		result.append(compare);
+		result.append(", resourceThemePath: ");
+		result.append(resourceThemePath);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YStringToResourceConverterImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YStringToResourceConverterImpl.java
new file mode 100644
index 0000000..0ef0337
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/impl/YStringToResourceConverterImpl.java
@@ -0,0 +1,408 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YString To Resource Converter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.converter.impl.YStringToResourceConverterImpl#getConfigs <em>Configs</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YStringToResourceConverterImpl extends MinimalEObjectImpl.Container implements YStringToResourceConverter {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getConfigs() <em>Configs</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getConfigs()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YStringToResourceConfig> configs;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YStringToResourceConverterImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YConverterPackage.Literals.YSTRING_TO_RESOURCE_CONVERTER;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getConfigs() <em>Configs</em>}'
+	 *         containment reference list
+	 * @generated
+	 */
+	public EList<YStringToResourceConfig> getConfigs() {
+		if (configs == null) {
+			configs = new EObjectContainmentEList<YStringToResourceConfig>(YStringToResourceConfig.class, this, YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS);
+		}
+		return configs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS:
+				return ((InternalEList<?>)getConfigs()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__TAGS:
+				return getTags();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__ID:
+				return getId();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__NAME:
+				return getName();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS:
+				return getConfigs();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__ID:
+				setId((String)newValue);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__NAME:
+				setName((String)newValue);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS:
+				getConfigs().clear();
+				getConfigs().addAll((Collection<? extends YStringToResourceConfig>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__TAGS:
+				getTags().clear();
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS:
+				getConfigs().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER__CONFIGS:
+				return configs != null && !configs.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/util/YConverterAdapterFactory.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/util/YConverterAdapterFactory.java
new file mode 100644
index 0000000..ac8e379
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/util/YConverterAdapterFactory.java
@@ -0,0 +1,384 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage
+ * @generated
+ */
+public class YConverterAdapterFactory extends AdapterFactoryImpl {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static YConverterPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YConverterAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = YConverterPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc --> This implementation returns <code>true</code> if
+	 * the object is either the model's package or is an instance object of the
+	 * model. <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YConverterSwitch<Adapter> modelSwitch =
+		new YConverterSwitch<Adapter>() {
+			@Override
+			public Adapter caseYObjectToStringConverter(YObjectToStringConverter object) {
+				return createYObjectToStringConverterAdapter();
+			}
+			@Override
+			public Adapter caseYCustomDecimalConverter(YCustomDecimalConverter object) {
+				return createYCustomDecimalConverterAdapter();
+			}
+			@Override
+			public Adapter caseYNumericToResourceConverter(YNumericToResourceConverter object) {
+				return createYNumericToResourceConverterAdapter();
+			}
+			@Override
+			public Adapter caseYStringToResourceConverter(YStringToResourceConverter object) {
+				return createYStringToResourceConverterAdapter();
+			}
+			@Override
+			public Adapter caseYNumericToResourceConfig(YNumericToResourceConfig object) {
+				return createYNumericToResourceConfigAdapter();
+			}
+			@Override
+			public Adapter caseYStringToResourceConfig(YStringToResourceConfig object) {
+				return createYStringToResourceConfigAdapter();
+			}
+			@Override
+			public Adapter caseYPriceToStringConverter(YPriceToStringConverter object) {
+				return createYPriceToStringConverterAdapter();
+			}
+			@Override
+			public Adapter caseYQuantityToStringConverter(YQuantityToStringConverter object) {
+				return createYQuantityToStringConverterAdapter();
+			}
+			@Override
+			public Adapter caseYNumericToUomoConverter(YNumericToUomoConverter object) {
+				return createYNumericToUomoConverterAdapter();
+			}
+			@Override
+			public Adapter caseYDecimalToUomoConverter(YDecimalToUomoConverter object) {
+				return createYDecimalToUomoConverterAdapter();
+			}
+			@Override
+			public Adapter caseYSimpleDecimalConverter(YSimpleDecimalConverter object) {
+				return createYSimpleDecimalConverterAdapter();
+			}
+			@Override
+			public Adapter caseYTaggable(YTaggable object) {
+				return createYTaggableAdapter();
+			}
+			@Override
+			public Adapter caseYElement(YElement object) {
+				return createYElementAdapter();
+			}
+			@Override
+			public Adapter caseYConverter(YConverter object) {
+				return createYConverterAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter <em>YObject To String Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter
+	 * @generated
+	 */
+	public Adapter createYObjectToStringConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter <em>YCustom Decimal Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter
+	 * @generated
+	 */
+	public Adapter createYCustomDecimalConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter <em>YNumeric To Resource Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter
+	 * @generated
+	 */
+	public Adapter createYNumericToResourceConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter <em>YString To Resource Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter
+	 * @generated
+	 */
+	public Adapter createYStringToResourceConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig <em>YNumeric To Resource Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig
+	 * @generated
+	 */
+	public Adapter createYNumericToResourceConfigAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig <em>YString To Resource Config</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig
+	 * @generated
+	 */
+	public Adapter createYStringToResourceConfigAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter <em>YNumeric To Uomo Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter
+	 * @generated
+	 */
+	public Adapter createYNumericToUomoConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter <em>YDecimal To Uomo Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter
+	 * @generated
+	 */
+	public Adapter createYDecimalToUomoConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter <em>YSimple Decimal Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter
+	 * @generated
+	 */
+	public Adapter createYSimpleDecimalConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YTaggable <em>YTaggable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YTaggable
+	 * @generated
+	 */
+	public Adapter createYTaggableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter <em>YPrice To String Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter
+	 * @generated
+	 */
+	public Adapter createYPriceToStringConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter <em>YQuantity To String Converter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter
+	 * @generated
+	 */
+	public Adapter createYQuantityToStringConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YElement <em>YElement</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YElement
+	 * @generated
+	 */
+	public Adapter createYElementAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YConverter <em>YConverter</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YConverter
+	 * @generated
+	 */
+	public Adapter createYConverterAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/util/YConverterSwitch.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/util/YConverterSwitch.java
new file mode 100644
index 0000000..22d8d79
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/converter/util/YConverterSwitch.java
@@ -0,0 +1,421 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.converter.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.osbp.ecview.core.common.model.core.YConverter;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YCustomDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YDecimalToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToResourceConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YNumericToUomoConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YObjectToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YPriceToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YQuantityToStringConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YSimpleDecimalConverter;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConfig;
+import org.eclipse.osbp.ecview.extension.model.converter.YStringToResourceConverter;
+
+/**
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance
+ * hierarchy. It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the
+ * inheritance hierarchy until a non-null result is returned, which is the
+ * result of the switch. <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage
+ * @generated
+ */
+public class YConverterSwitch<T> extends Switch<T> {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected static YConverterPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YConverterSwitch() {
+		if (modelPackage == null) {
+			modelPackage = YConverterPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param ePackage
+	 *            the e package
+	 * @return whether this is a switch for the given package.
+	 * @parameter ePackage the package in question.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case YConverterPackage.YOBJECT_TO_STRING_CONVERTER: {
+				YObjectToStringConverter yObjectToStringConverter = (YObjectToStringConverter)theEObject;
+				T result = caseYObjectToStringConverter(yObjectToStringConverter);
+				if (result == null) result = caseYConverter(yObjectToStringConverter);
+				if (result == null) result = caseYElement(yObjectToStringConverter);
+				if (result == null) result = caseYTaggable(yObjectToStringConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YCUSTOM_DECIMAL_CONVERTER: {
+				YCustomDecimalConverter yCustomDecimalConverter = (YCustomDecimalConverter)theEObject;
+				T result = caseYCustomDecimalConverter(yCustomDecimalConverter);
+				if (result == null) result = caseYConverter(yCustomDecimalConverter);
+				if (result == null) result = caseYElement(yCustomDecimalConverter);
+				if (result == null) result = caseYTaggable(yCustomDecimalConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONVERTER: {
+				YNumericToResourceConverter yNumericToResourceConverter = (YNumericToResourceConverter)theEObject;
+				T result = caseYNumericToResourceConverter(yNumericToResourceConverter);
+				if (result == null) result = caseYConverter(yNumericToResourceConverter);
+				if (result == null) result = caseYElement(yNumericToResourceConverter);
+				if (result == null) result = caseYTaggable(yNumericToResourceConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONVERTER: {
+				YStringToResourceConverter yStringToResourceConverter = (YStringToResourceConverter)theEObject;
+				T result = caseYStringToResourceConverter(yStringToResourceConverter);
+				if (result == null) result = caseYConverter(yStringToResourceConverter);
+				if (result == null) result = caseYElement(yStringToResourceConverter);
+				if (result == null) result = caseYTaggable(yStringToResourceConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YNUMERIC_TO_RESOURCE_CONFIG: {
+				YNumericToResourceConfig yNumericToResourceConfig = (YNumericToResourceConfig)theEObject;
+				T result = caseYNumericToResourceConfig(yNumericToResourceConfig);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YSTRING_TO_RESOURCE_CONFIG: {
+				YStringToResourceConfig yStringToResourceConfig = (YStringToResourceConfig)theEObject;
+				T result = caseYStringToResourceConfig(yStringToResourceConfig);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YPRICE_TO_STRING_CONVERTER: {
+				YPriceToStringConverter yPriceToStringConverter = (YPriceToStringConverter)theEObject;
+				T result = caseYPriceToStringConverter(yPriceToStringConverter);
+				if (result == null) result = caseYConverter(yPriceToStringConverter);
+				if (result == null) result = caseYElement(yPriceToStringConverter);
+				if (result == null) result = caseYTaggable(yPriceToStringConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YQUANTITY_TO_STRING_CONVERTER: {
+				YQuantityToStringConverter yQuantityToStringConverter = (YQuantityToStringConverter)theEObject;
+				T result = caseYQuantityToStringConverter(yQuantityToStringConverter);
+				if (result == null) result = caseYConverter(yQuantityToStringConverter);
+				if (result == null) result = caseYElement(yQuantityToStringConverter);
+				if (result == null) result = caseYTaggable(yQuantityToStringConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YNUMERIC_TO_UOMO_CONVERTER: {
+				YNumericToUomoConverter yNumericToUomoConverter = (YNumericToUomoConverter)theEObject;
+				T result = caseYNumericToUomoConverter(yNumericToUomoConverter);
+				if (result == null) result = caseYConverter(yNumericToUomoConverter);
+				if (result == null) result = caseYElement(yNumericToUomoConverter);
+				if (result == null) result = caseYTaggable(yNumericToUomoConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YDECIMAL_TO_UOMO_CONVERTER: {
+				YDecimalToUomoConverter yDecimalToUomoConverter = (YDecimalToUomoConverter)theEObject;
+				T result = caseYDecimalToUomoConverter(yDecimalToUomoConverter);
+				if (result == null) result = caseYConverter(yDecimalToUomoConverter);
+				if (result == null) result = caseYElement(yDecimalToUomoConverter);
+				if (result == null) result = caseYTaggable(yDecimalToUomoConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YConverterPackage.YSIMPLE_DECIMAL_CONVERTER: {
+				YSimpleDecimalConverter ySimpleDecimalConverter = (YSimpleDecimalConverter)theEObject;
+				T result = caseYSimpleDecimalConverter(ySimpleDecimalConverter);
+				if (result == null) result = caseYConverter(ySimpleDecimalConverter);
+				if (result == null) result = caseYElement(ySimpleDecimalConverter);
+				if (result == null) result = caseYTaggable(ySimpleDecimalConverter);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YObject To String Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YObject To String Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYObjectToStringConverter(YObjectToStringConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YCustom Decimal Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YCustom Decimal Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYCustomDecimalConverter(YCustomDecimalConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YNumeric To Resource Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YNumeric To Resource Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYNumericToResourceConverter(YNumericToResourceConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YString To Resource Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YString To Resource Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYStringToResourceConverter(YStringToResourceConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YNumeric To Resource Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YNumeric To Resource Config</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYNumericToResourceConfig(YNumericToResourceConfig object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YString To Resource Config</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YString To Resource Config</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYStringToResourceConfig(YStringToResourceConfig object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YNumeric To Uomo Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YNumeric To Uomo Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYNumericToUomoConverter(YNumericToUomoConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YDecimal To Uomo Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YDecimal To Uomo Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYDecimalToUomoConverter(YDecimalToUomoConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSimple Decimal Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSimple Decimal Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSimpleDecimalConverter(YSimpleDecimalConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTaggable(YTaggable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YPrice To String Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YPrice To String Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYPriceToStringConverter(YPriceToStringConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YQuantity To String Converter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YQuantity To String Converter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYQuantityToStringConverter(YQuantityToStringConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYElement(YElement object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YConverter</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YConverter</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYConverter(YConverter object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YBlobUploadComponentImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YBlobUploadComponentImpl.java
new file mode 100644
index 0000000..003d8ba
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YBlobUploadComponentImpl.java
@@ -0,0 +1,592 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YBlob Upload Component</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl#getDisplayResolutionId <em>Display Resolution Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl#isFirmlyLinked <em>Firmly Linked</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YBlobUploadComponentImpl#isUniqueNameEnabled <em>Unique Name Enabled</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YBlobUploadComponentImpl extends YInputImpl implements YBlobUploadComponent {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected String value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getDisplayResolutionId() <em>Display Resolution Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDisplayResolutionId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int DISPLAY_RESOLUTION_ID_EDEFAULT = 0;
+
+	/**
+	 * The cached value of the '{@link #getDisplayResolutionId() <em>Display Resolution Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDisplayResolutionId()
+	 * @generated
+	 * @ordered
+	 */
+	protected int displayResolutionId = DISPLAY_RESOLUTION_ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isFirmlyLinked() <em>Firmly Linked</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isFirmlyLinked()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean FIRMLY_LINKED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isFirmlyLinked() <em>Firmly Linked</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isFirmlyLinked()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean firmlyLinked = FIRMLY_LINKED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isUniqueNameEnabled() <em>Unique Name Enabled</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUniqueNameEnabled()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean UNIQUE_NAME_ENABLED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isUniqueNameEnabled() <em>Unique Name Enabled</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUniqueNameEnabled()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean uniqueNameEnabled = UNIQUE_NAME_ENABLED_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YBlobUploadComponentImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YBLOB_UPLOAD_COMPONENT;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValueBindingEndpoint()
+	 *         <em>Value Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValueBindingEndpoint
+	 *            the new value binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValueBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getValueBindingEndpoint()
+	 *            <em>Value Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValue() <em>Value</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValue
+	 *            the new cached value of the '{@link #getValue()
+	 *            <em>Value</em>}' attribute
+	 * @generated
+	 */
+	public void setValue(String newValue) {
+		String oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDisplayResolutionId()
+	 *         <em>Display Resolution Id</em>}' attribute
+	 * @generated
+	 */
+	public int getDisplayResolutionId() {
+		return displayResolutionId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDisplayResolutionId
+	 *            the new cached value of the '{@link #getDisplayResolutionId()
+	 *            <em>Display Resolution Id</em>}' attribute
+	 * @generated
+	 */
+	public void setDisplayResolutionId(int newDisplayResolutionId) {
+		int oldDisplayResolutionId = displayResolutionId;
+		displayResolutionId = newDisplayResolutionId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID, oldDisplayResolutionId, displayResolutionId));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isFirmlyLinked() {
+		return firmlyLinked;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setFirmlyLinked(boolean newFirmlyLinked) {
+		boolean oldFirmlyLinked = firmlyLinked;
+		firmlyLinked = newFirmlyLinked;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED, oldFirmlyLinked, firmlyLinked));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isUniqueNameEnabled() {
+		return uniqueNameEnabled;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setUniqueNameEnabled(boolean newUniqueNameEnabled) {
+		boolean oldUniqueNameEnabled = uniqueNameEnabled;
+		uniqueNameEnabled = newUniqueNameEnabled;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED, oldUniqueNameEnabled, uniqueNameEnabled));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint createValueEndpointGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Creates a new instance of value endpoint with a reference to that
+	 * embeddable.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated NOT
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		YEmbeddableValueEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableValueEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE:
+				return getValue();
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID:
+				return getDisplayResolutionId();
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED:
+				return isFirmlyLinked();
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED:
+				return isUniqueNameEnabled();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE:
+				setValue((String)newValue);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID:
+				setDisplayResolutionId((Integer)newValue);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED:
+				setFirmlyLinked((Boolean)newValue);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED:
+				setUniqueNameEnabled((Boolean)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID:
+				setDisplayResolutionId(DISPLAY_RESOLUTION_ID_EDEFAULT);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED:
+				setFirmlyLinked(FIRMLY_LINKED_EDEFAULT);
+				return;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED:
+				setUniqueNameEnabled(UNIQUE_NAME_ENABLED_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID:
+				return displayResolutionId != DISPLAY_RESOLUTION_ID_EDEFAULT;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED:
+				return firmlyLinked != FIRMLY_LINKED_EDEFAULT;
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED:
+				return uniqueNameEnabled != UNIQUE_NAME_ENABLED_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param derivedFeatureID
+	 *            the derived feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param baseFeatureID
+	 *            the base feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YBLOB_UPLOAD_COMPONENT__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(", displayResolutionId: ");
+		result.append(displayResolutionId);
+		result.append(", firmlyLinked: ");
+		result.append(firmlyLinked);
+		result.append(", uniqueNameEnabled: ");
+		result.append(uniqueNameEnabled);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YCollectionSuspectImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YCollectionSuspectImpl.java
new file mode 100644
index 0000000..590965f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YCollectionSuspectImpl.java
@@ -0,0 +1,191 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.extension.model.YCollectionSuspect;
+import org.eclipse.osbp.ecview.extension.model.YColumnInfo;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YCollection Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YCollectionSuspectImpl#getColumns <em>Columns</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YCollectionSuspectImpl extends YTypedSuspectImpl implements YCollectionSuspect {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getColumns() <em>Columns</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getColumns()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YColumnInfo> columns;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YCollectionSuspectImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YCOLLECTION_SUSPECT;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getColumns() <em>Columns</em>}'
+	 *         containment reference list
+	 * @generated
+	 */
+	public EList<YColumnInfo> getColumns() {
+		if (columns == null) {
+			columns = new EObjectContainmentEList<YColumnInfo>(YColumnInfo.class, this, YECviewPackage.YCOLLECTION_SUSPECT__COLUMNS);
+		}
+		return columns;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YCOLLECTION_SUSPECT__COLUMNS:
+				return ((InternalEList<?>)getColumns()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YCOLLECTION_SUSPECT__COLUMNS:
+				return getColumns();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YCOLLECTION_SUSPECT__COLUMNS:
+				getColumns().clear();
+				getColumns().addAll((Collection<? extends YColumnInfo>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCOLLECTION_SUSPECT__COLUMNS:
+				getColumns().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCOLLECTION_SUSPECT__COLUMNS:
+				return columns != null && !columns.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YColumnInfoImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YColumnInfoImpl.java
new file mode 100644
index 0000000..f27db7d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YColumnInfoImpl.java
@@ -0,0 +1,435 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.YColumnInfo;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YColumn Info</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YColumnInfoImpl#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YColumnInfoImpl extends MinimalEObjectImpl.Container implements YColumnInfo {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_I1_8N_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String labelI18nKey = LABEL_I1_8N_KEY_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YColumnInfoImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YCOLUMN_INFO;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCOLUMN_INFO__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getType() <em>Type</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newType
+	 *            the new cached value of the '{@link #getType() <em>Type</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCOLUMN_INFO__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTypeQualifiedName()
+	 *         <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTypeQualifiedName
+	 *            the new cached value of the '{@link #getTypeQualifiedName()
+	 *            <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCOLUMN_INFO__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YECviewPackage.YCOLUMN_INFO__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabelI18nKey()
+	 *         <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public String getLabelI18nKey() {
+		return labelI18nKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabelI18nKey
+	 *            the new cached value of the '{@link #getLabelI18nKey()
+	 *            <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public void setLabelI18nKey(String newLabelI18nKey) {
+		String oldLabelI18nKey = labelI18nKey;
+		labelI18nKey = newLabelI18nKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCOLUMN_INFO__LABEL_I1_8N_KEY, oldLabelI18nKey, labelI18nKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YCOLUMN_INFO__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YCOLUMN_INFO__NAME:
+				return getName();
+			case YECviewPackage.YCOLUMN_INFO__TYPE:
+				return getType();
+			case YECviewPackage.YCOLUMN_INFO__TYPE_QUALIFIED_NAME:
+				return getTypeQualifiedName();
+			case YECviewPackage.YCOLUMN_INFO__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YECviewPackage.YCOLUMN_INFO__LABEL_I1_8N_KEY:
+				return getLabelI18nKey();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YCOLUMN_INFO__NAME:
+				setName((String)newValue);
+				return;
+			case YECviewPackage.YCOLUMN_INFO__TYPE:
+				setType((Class<?>)newValue);
+				return;
+			case YECviewPackage.YCOLUMN_INFO__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName((String)newValue);
+				return;
+			case YECviewPackage.YCOLUMN_INFO__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YECviewPackage.YCOLUMN_INFO__LABEL_I1_8N_KEY:
+				setLabelI18nKey((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCOLUMN_INFO__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YCOLUMN_INFO__TYPE:
+				setType((Class<?>)null);
+				return;
+			case YECviewPackage.YCOLUMN_INFO__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YCOLUMN_INFO__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YECviewPackage.YCOLUMN_INFO__LABEL_I1_8N_KEY:
+				setLabelI18nKey(LABEL_I1_8N_KEY_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCOLUMN_INFO__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YECviewPackage.YCOLUMN_INFO__TYPE:
+				return type != null;
+			case YECviewPackage.YCOLUMN_INFO__TYPE_QUALIFIED_NAME:
+				return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+			case YECviewPackage.YCOLUMN_INFO__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YECviewPackage.YCOLUMN_INFO__LABEL_I1_8N_KEY:
+				return LABEL_I1_8N_KEY_EDEFAULT == null ? labelI18nKey != null : !LABEL_I1_8N_KEY_EDEFAULT.equals(labelI18nKey);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (name: ");
+		result.append(name);
+		result.append(", type: ");
+		result.append(type);
+		result.append(", typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(", labelI18nKey: ");
+		result.append(labelI18nKey);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YContentSensitiveLayoutImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YContentSensitiveLayoutImpl.java
new file mode 100644
index 0000000..e524f4a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YContentSensitiveLayoutImpl.java
@@ -0,0 +1,276 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YMarginable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSpacingable;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YLayoutImpl;
+import org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YContent Sensitive Layout</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YContentSensitiveLayoutImpl#isSpacing <em>Spacing</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YContentSensitiveLayoutImpl#isMargin <em>Margin</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YContentSensitiveLayoutImpl extends YLayoutImpl implements YContentSensitiveLayout {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #isSpacing() <em>Spacing</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSpacing()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean SPACING_EDEFAULT = true;
+	/**
+	 * The cached value of the '{@link #isSpacing() <em>Spacing</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSpacing()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean spacing = SPACING_EDEFAULT;
+	/**
+	 * The default value of the '{@link #isMargin() <em>Margin</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isMargin()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean MARGIN_EDEFAULT = true;
+	/**
+	 * The cached value of the '{@link #isMargin() <em>Margin</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isMargin()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean margin = MARGIN_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YContentSensitiveLayoutImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YCONTENT_SENSITIVE_LAYOUT;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSpacing() {
+		return spacing;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setSpacing(boolean newSpacing) {
+		boolean oldSpacing = spacing;
+		spacing = newSpacing;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING, oldSpacing, spacing));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isMargin() {
+		return margin;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMargin(boolean newMargin) {
+		boolean oldMargin = margin;
+		margin = newMargin;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN, oldMargin, margin));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING:
+				return isSpacing();
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN:
+				return isMargin();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING:
+				setSpacing((Boolean)newValue);
+				return;
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN:
+				setMargin((Boolean)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING:
+				setSpacing(SPACING_EDEFAULT);
+				return;
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN:
+				setMargin(MARGIN_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING:
+				return spacing != SPACING_EDEFAULT;
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN:
+				return margin != MARGIN_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YSpacingable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING: return CoreModelPackage.YSPACINGABLE__SPACING;
+				default: return -1;
+			}
+		}
+		if (baseClass == YMarginable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN: return CoreModelPackage.YMARGINABLE__MARGIN;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YSpacingable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YSPACINGABLE__SPACING: return YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__SPACING;
+				default: return -1;
+			}
+		}
+		if (baseClass == YMarginable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YMARGINABLE__MARGIN: return YECviewPackage.YCONTENT_SENSITIVE_LAYOUT__MARGIN;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (spacing: ");
+		result.append(spacing);
+		result.append(", margin: ");
+		result.append(margin);
+		result.append(')');
+		return result.toString();
+	}
+
+} //YContentSensitiveLayoutImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YCustomDecimalFieldImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YCustomDecimalFieldImpl.java
new file mode 100644
index 0000000..0d7d847
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YCustomDecimalFieldImpl.java
@@ -0,0 +1,615 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YDecimalDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YCustomDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YCustom Decimal Field</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl#getDatatype <em>Datatype</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YCustomDecimalFieldImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YCustomDecimalFieldImpl extends YInputImpl implements YCustomDecimalField {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getDatatype() <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatatype()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDecimalDatatype datatype;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double VALUE_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected double value = VALUE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YCustomDecimalFieldImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YCUSTOM_DECIMAL_FIELD;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValueBindingEndpoint()
+	 *         <em>Value Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValueBindingEndpoint
+	 *            the new value binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValueBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getValueBindingEndpoint()
+	 *            <em>Value Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDatatype() <em>Datatype</em>}
+	 *         ' reference
+	 * @generated
+	 */
+	public YDecimalDatatype getDatatype() {
+		if (datatype != null && datatype.eIsProxy()) {
+			InternalEObject oldDatatype = (InternalEObject)datatype;
+			datatype = (YDecimalDatatype)eResolveProxy(oldDatatype);
+			if (datatype != oldDatatype) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATATYPE, oldDatatype, datatype));
+			}
+		}
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y decimal datatype
+	 * @generated
+	 */
+	public YDecimalDatatype basicGetDatatype() {
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDatatype
+	 *            the new cached value of the '{@link #getDatatype()
+	 *            <em>Datatype</em>}' reference
+	 * @generated
+	 */
+	public void setDatatype(YDecimalDatatype newDatatype) {
+		YDecimalDatatype oldDatatype = datatype;
+		datatype = newDatatype;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATATYPE, oldDatatype, datatype));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDatadescription()
+	 *         <em>Datadescription</em>}' reference
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y datadescription
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDatadescription
+	 *            the new cached value of the '{@link #getDatadescription()
+	 *            <em>Datadescription</em>}' reference
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValue() <em>Value</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public double getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValue
+	 *            the new cached value of the '{@link #getValue()
+	 *            <em>Value</em>}' attribute
+	 * @generated
+	 */
+	public void setValue(double newValue) {
+		double oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint createValueEndpointGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Creates a new instance of value endpoint with a reference to that
+	 * embeddable.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated NOT
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		YEmbeddableValueEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableValueEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATATYPE:
+				if (resolve) return getDatatype();
+				return basicGetDatatype();
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE:
+				return getValue();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATATYPE:
+				setDatatype((YDecimalDatatype)newValue);
+				return;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE:
+				setValue((Double)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATATYPE:
+				setDatatype((YDecimalDatatype)null);
+				return;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATATYPE:
+				return datatype != null;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE:
+				return value != VALUE_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param derivedFeatureID
+	 *            the derived feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param baseFeatureID
+	 *            the base feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YCUSTOM_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDefaultLayoutingStrategyImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDefaultLayoutingStrategyImpl.java
new file mode 100644
index 0000000..fb0baa9
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDefaultLayoutingStrategyImpl.java
@@ -0,0 +1,58 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YDefault Layouting Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * </p>
+ *
+ * @generated
+ */
+public class YDefaultLayoutingStrategyImpl extends YLayoutingStrategyImpl implements YDefaultLayoutingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YDefaultLayoutingStrategyImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YDEFAULT_LAYOUTING_STRATEGY;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDelegatingFocusingStrategyImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDelegatingFocusingStrategyImpl.java
new file mode 100644
index 0000000..fb1b3ac
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDelegatingFocusingStrategyImpl.java
@@ -0,0 +1,201 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YDelegating Focusing Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YDelegatingFocusingStrategyImpl#getDelegateStrategyId <em>Delegate Strategy Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YDelegatingFocusingStrategyImpl extends YFocusingStrategyImpl implements YDelegatingFocusingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #getDelegateStrategyId() <em>Delegate Strategy Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateStrategyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DELEGATE_STRATEGY_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDelegateStrategyId() <em>Delegate Strategy Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateStrategyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String delegateStrategyId = DELEGATE_STRATEGY_ID_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YDelegatingFocusingStrategyImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YDELEGATING_FOCUSING_STRATEGY;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDelegateStrategyId()
+	 *         <em>Delegate Strategy Id</em>}' attribute
+	 * @generated
+	 */
+	public String getDelegateStrategyId() {
+		return delegateStrategyId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDelegateStrategyId
+	 *            the new cached value of the '{@link #getDelegateStrategyId()
+	 *            <em>Delegate Strategy Id</em>}' attribute
+	 * @generated
+	 */
+	public void setDelegateStrategyId(String newDelegateStrategyId) {
+		String oldDelegateStrategyId = delegateStrategyId;
+		delegateStrategyId = newDelegateStrategyId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID, oldDelegateStrategyId, delegateStrategyId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID:
+				return getDelegateStrategyId();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID:
+				setDelegateStrategyId((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID:
+				setDelegateStrategyId(DELEGATE_STRATEGY_ID_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID:
+				return DELEGATE_STRATEGY_ID_EDEFAULT == null ? delegateStrategyId != null : !DELEGATE_STRATEGY_ID_EDEFAULT.equals(delegateStrategyId);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (delegateStrategyId: ");
+		result.append(delegateStrategyId);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDelegatingLayoutingStrategyImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDelegatingLayoutingStrategyImpl.java
new file mode 100644
index 0000000..2d0936b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YDelegatingLayoutingStrategyImpl.java
@@ -0,0 +1,201 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YDelegating Layouting Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YDelegatingLayoutingStrategyImpl#getDelegateStrategyId <em>Delegate Strategy Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YDelegatingLayoutingStrategyImpl extends YLayoutingStrategyImpl implements YDelegatingLayoutingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #getDelegateStrategyId() <em>Delegate Strategy Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateStrategyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DELEGATE_STRATEGY_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDelegateStrategyId() <em>Delegate Strategy Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDelegateStrategyId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String delegateStrategyId = DELEGATE_STRATEGY_ID_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YDelegatingLayoutingStrategyImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YDELEGATING_LAYOUTING_STRATEGY;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDelegateStrategyId()
+	 *         <em>Delegate Strategy Id</em>}' attribute
+	 * @generated
+	 */
+	public String getDelegateStrategyId() {
+		return delegateStrategyId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDelegateStrategyId
+	 *            the new cached value of the '{@link #getDelegateStrategyId()
+	 *            <em>Delegate Strategy Id</em>}' attribute
+	 * @generated
+	 */
+	public void setDelegateStrategyId(String newDelegateStrategyId) {
+		String oldDelegateStrategyId = delegateStrategyId;
+		delegateStrategyId = newDelegateStrategyId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID, oldDelegateStrategyId, delegateStrategyId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID:
+				return getDelegateStrategyId();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID:
+				setDelegateStrategyId((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID:
+				setDelegateStrategyId(DELEGATE_STRATEGY_ID_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID:
+				return DELEGATE_STRATEGY_ID_EDEFAULT == null ? delegateStrategyId != null : !DELEGATE_STRATEGY_ID_EDEFAULT.equals(delegateStrategyId);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (delegateStrategyId: ");
+		result.append(delegateStrategyId);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewFactoryImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewFactoryImpl.java
new file mode 100644
index 0000000..7c7c123
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewFactoryImpl.java
@@ -0,0 +1,484 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent;
+import org.eclipse.osbp.ecview.extension.model.YCollectionSuspect;
+import org.eclipse.osbp.ecview.extension.model.YColumnInfo;
+import org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout;
+import org.eclipse.osbp.ecview.extension.model.YCustomDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YIconComboBox;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedNumericField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YPairComboBox;
+import org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YQuantityTextField;
+import org.eclipse.osbp.ecview.extension.model.YRichTextArea;
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+import org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect;
+import org.eclipse.osbp.ecview.extension.model.YTypedSuspect;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YECviewFactoryImpl extends EFactoryImpl implements YECviewFactory {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	public static YECviewFactory init() {
+		try {
+			YECviewFactory theYECviewFactory = (YECviewFactory)EPackage.Registry.INSTANCE.getEFactory(YECviewPackage.eNS_URI);
+			if (theYECviewFactory != null) {
+				return theYECviewFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new YECviewFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YECviewFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param eClass
+	 *            the e class
+	 * @return the e object
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case YECviewPackage.YSTRATEGY_LAYOUT: return createYStrategyLayout();
+			case YECviewPackage.YLAYOUTING_STRATEGY: return createYLayoutingStrategy();
+			case YECviewPackage.YDEFAULT_LAYOUTING_STRATEGY: return createYDefaultLayoutingStrategy();
+			case YECviewPackage.YFOCUSING_STRATEGY: return createYFocusingStrategy();
+			case YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY: return createYDelegatingLayoutingStrategy();
+			case YECviewPackage.YDELEGATING_FOCUSING_STRATEGY: return createYDelegatingFocusingStrategy();
+			case YECviewPackage.YSUSPECT: return createYSuspect();
+			case YECviewPackage.YTYPED_SUSPECT: return createYTypedSuspect();
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT: return createYTypedCompoundSuspect();
+			case YECviewPackage.YSUB_TYPE_BASE_SUSPECT: return createYSubTypeBaseSuspect();
+			case YECviewPackage.YSUB_TYPE_SUSPECT: return createYSubTypeSuspect();
+			case YECviewPackage.YLAYOUTING_INFO: return createYLayoutingInfo();
+			case YECviewPackage.YSUSPECT_INFO: return createYSuspectInfo();
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT: return createYBlobUploadComponent();
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD: return createYCustomDecimalField();
+			case YECviewPackage.YICON_COMBO_BOX: return createYIconComboBox();
+			case YECviewPackage.YQUANTITY_TEXT_FIELD: return createYQuantityTextField();
+			case YECviewPackage.YCOLLECTION_SUSPECT: return createYCollectionSuspect();
+			case YECviewPackage.YCOLUMN_INFO: return createYColumnInfo();
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT: return createYContentSensitiveLayout();
+			case YECviewPackage.YRICH_TEXT_AREA: return createYRichTextArea();
+			case YECviewPackage.YMASKED_TEXT_FIELD: return createYMaskedTextField();
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD: return createYPrefixedMaskedTextField();
+			case YECviewPackage.YMASKED_NUMERIC_FIELD: return createYMaskedNumericField();
+			case YECviewPackage.YMASKED_DECIMAL_FIELD: return createYMaskedDecimalField();
+			case YECviewPackage.YPAIR_COMBO_BOX: return createYPairComboBox();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object createFromString(EDataType eDataType, String initialValue) {
+		switch (eDataType.getClassifierID()) {
+			case YECviewPackage.NUMBER:
+				return createNumberFromString(eDataType, initialValue);
+			default:
+				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String convertToString(EDataType eDataType, Object instanceValue) {
+		switch (eDataType.getClassifierID()) {
+			case YECviewPackage.NUMBER:
+				return convertNumberToString(eDataType, instanceValue);
+			default:
+				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout
+	 * @generated
+	 */
+	public YStrategyLayout createYStrategyLayout() {
+		YStrategyLayoutImpl yStrategyLayout = new YStrategyLayoutImpl();
+		return yStrategyLayout;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting strategy
+	 * @generated
+	 */
+	public YLayoutingStrategy createYLayoutingStrategy() {
+		YLayoutingStrategyImpl yLayoutingStrategy = new YLayoutingStrategyImpl();
+		return yLayoutingStrategy;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y default layouting strategy
+	 * @generated
+	 */
+	public YDefaultLayoutingStrategy createYDefaultLayoutingStrategy() {
+		YDefaultLayoutingStrategyImpl yDefaultLayoutingStrategy = new YDefaultLayoutingStrategyImpl();
+		return yDefaultLayoutingStrategy;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y focusing strategy
+	 * @generated
+	 */
+	public YFocusingStrategy createYFocusingStrategy() {
+		YFocusingStrategyImpl yFocusingStrategy = new YFocusingStrategyImpl();
+		return yFocusingStrategy;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y delegating layouting strategy
+	 * @generated
+	 */
+	public YDelegatingLayoutingStrategy createYDelegatingLayoutingStrategy() {
+		YDelegatingLayoutingStrategyImpl yDelegatingLayoutingStrategy = new YDelegatingLayoutingStrategyImpl();
+		return yDelegatingLayoutingStrategy;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y delegating focusing strategy
+	 * @generated
+	 */
+	public YDelegatingFocusingStrategy createYDelegatingFocusingStrategy() {
+		YDelegatingFocusingStrategyImpl yDelegatingFocusingStrategy = new YDelegatingFocusingStrategyImpl();
+		return yDelegatingFocusingStrategy;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect
+	 * @generated
+	 */
+	public YSuspect createYSuspect() {
+		YSuspectImpl ySuspect = new YSuspectImpl();
+		return ySuspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting info
+	 * @generated
+	 */
+	public YLayoutingInfo createYLayoutingInfo() {
+		YLayoutingInfoImpl yLayoutingInfo = new YLayoutingInfoImpl();
+		return yLayoutingInfo;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info
+	 * @generated
+	 */
+	public YSuspectInfo createYSuspectInfo() {
+		YSuspectInfoImpl ySuspectInfo = new YSuspectInfoImpl();
+		return ySuspectInfo;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y blob upload component
+	 * @generated
+	 */
+	public YBlobUploadComponent createYBlobUploadComponent() {
+		YBlobUploadComponentImpl yBlobUploadComponent = new YBlobUploadComponentImpl();
+		return yBlobUploadComponent;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y typed suspect
+	 * @generated
+	 */
+	public YTypedSuspect createYTypedSuspect() {
+		YTypedSuspectImpl yTypedSuspect = new YTypedSuspectImpl();
+		return yTypedSuspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y typed compound suspect
+	 * @generated
+	 */
+	public YTypedCompoundSuspect createYTypedCompoundSuspect() {
+		YTypedCompoundSuspectImpl yTypedCompoundSuspect = new YTypedCompoundSuspectImpl();
+		return yTypedCompoundSuspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YSubTypeBaseSuspect createYSubTypeBaseSuspect() {
+		YSubTypeBaseSuspectImpl ySubTypeBaseSuspect = new YSubTypeBaseSuspectImpl();
+		return ySubTypeBaseSuspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YSubTypeSuspect createYSubTypeSuspect() {
+		YSubTypeSuspectImpl ySubTypeSuspect = new YSubTypeSuspectImpl();
+		return ySubTypeSuspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal field
+	 * @generated
+	 */
+	public YCustomDecimalField createYCustomDecimalField() {
+		YCustomDecimalFieldImpl yCustomDecimalField = new YCustomDecimalFieldImpl();
+		return yCustomDecimalField;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box
+	 * @generated
+	 */
+	public YIconComboBox createYIconComboBox() {
+		YIconComboBoxImpl yIconComboBox = new YIconComboBoxImpl();
+		return yIconComboBox;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity text field
+	 * @generated
+	 */
+	public YQuantityTextField createYQuantityTextField() {
+		YQuantityTextFieldImpl yQuantityTextField = new YQuantityTextFieldImpl();
+		return yQuantityTextField;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y collection suspect
+	 * @generated
+	 */
+	public YCollectionSuspect createYCollectionSuspect() {
+		YCollectionSuspectImpl yCollectionSuspect = new YCollectionSuspectImpl();
+		return yCollectionSuspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y column info
+	 * @generated
+	 */
+	public YColumnInfo createYColumnInfo() {
+		YColumnInfoImpl yColumnInfo = new YColumnInfoImpl();
+		return yColumnInfo;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YContentSensitiveLayout createYContentSensitiveLayout() {
+		YContentSensitiveLayoutImpl yContentSensitiveLayout = new YContentSensitiveLayoutImpl();
+		return yContentSensitiveLayout;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YRichTextArea createYRichTextArea() {
+		YRichTextAreaImpl yRichTextArea = new YRichTextAreaImpl();
+		return yRichTextArea;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YMaskedTextField createYMaskedTextField() {
+		YMaskedTextFieldImpl yMaskedTextField = new YMaskedTextFieldImpl();
+		return yMaskedTextField;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YPrefixedMaskedTextField createYPrefixedMaskedTextField() {
+		YPrefixedMaskedTextFieldImpl yPrefixedMaskedTextField = new YPrefixedMaskedTextFieldImpl();
+		return yPrefixedMaskedTextField;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YMaskedNumericField createYMaskedNumericField() {
+		YMaskedNumericFieldImpl yMaskedNumericField = new YMaskedNumericFieldImpl();
+		return yMaskedNumericField;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YMaskedDecimalField createYMaskedDecimalField() {
+		YMaskedDecimalFieldImpl yMaskedDecimalField = new YMaskedDecimalFieldImpl();
+		return yMaskedDecimalField;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Number createNumberFromString(EDataType eDataType, String initialValue) {
+		return (Number)super.createFromString(eDataType, initialValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String convertNumberToString(EDataType eDataType, Object instanceValue) {
+		return super.convertToString(eDataType, instanceValue);
+	}
+	
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YPairComboBox createYPairComboBox() {
+		YPairComboBoxImpl yPairComboBox = new YPairComboBoxImpl();
+		return yPairComboBox;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the YE cview package
+	 * @generated
+	 */
+	public YECviewPackage getYECviewPackage() {
+		return (YECviewPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the package
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static YECviewPackage getPackage() {
+		return YECviewPackage.eINSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewPackageImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewPackageImpl.java
new file mode 100644
index 0000000..2afe837
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewPackageImpl.java
@@ -0,0 +1,1863 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EGenericType;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+import org.eclipse.osbp.ecview.core.common.model.binding.BindingPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.DatatypesPackage;
+import org.eclipse.osbp.ecview.core.common.model.visibility.VisibilityPackage;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent;
+import org.eclipse.osbp.ecview.extension.model.YCustomDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YIconComboBox;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+import org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect;
+import org.eclipse.osbp.ecview.extension.model.YTypedSuspect;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+import org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityPackageImpl;
+import org.eclipse.xtext.common.types.TypesPackage;
+//lunifera@80.156.28.28/osbpgit/org.eclipse.osbp.ecview.extension.git
+import org.eclipse.osbp.ecview.extension.model.YCollectionSuspect;
+import org.eclipse.osbp.ecview.extension.model.YColumnInfo;
+import org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout;
+import org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedNumericField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YPairComboBox;
+import org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YQuantityTextField;
+import org.eclipse.osbp.ecview.extension.model.YRichTextArea;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YECviewPackageImpl extends EPackageImpl implements YECviewPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yStrategyLayoutEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yLayoutingStrategyEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yDefaultLayoutingStrategyEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yFocusingStrategyEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yDelegatingLayoutingStrategyEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yDelegatingFocusingStrategyEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass ySuspectEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yLayoutingInfoEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass ySuspectInfoEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yBlobUploadComponentEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yTypedSuspectEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yTypedCompoundSuspectEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass ySubTypeBaseSuspectEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass ySubTypeSuspectEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yCustomDecimalFieldEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yIconComboBoxEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yQuantityTextFieldEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yCollectionSuspectEClass = null;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yColumnInfoEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass yContentSensitiveLayoutEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass yRichTextAreaEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass yMaskedTextFieldEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass yPrefixedMaskedTextFieldEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass yMaskedNumericFieldEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass yMaskedDecimalFieldEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EDataType numberEDataType = null;
+	
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	
+	private EClass yPairComboBoxEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private YECviewPackageImpl() {
+		super(eNS_URI, YECviewFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model,
+	 * and for any others upon which it depends.
+	 * 
+	 * <p>
+	 * This method is used to initialize {@link YECviewPackage#eINSTANCE} when
+	 * that field is accessed. Clients should not invoke it directly. Instead,
+	 * they should simply access that field to obtain the package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the YE cview package
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static YECviewPackage init() {
+		if (isInited) return (YECviewPackage)EPackage.Registry.INSTANCE.getEPackage(YECviewPackage.eNS_URI);
+
+		// Obtain or create and register package
+		YECviewPackageImpl theYECviewPackage = (YECviewPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof YECviewPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new YECviewPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		ExtDatatypesPackage.eINSTANCE.eClass();
+		ExtensionModelPackage.eINSTANCE.eClass();
+		TypesPackage.eINSTANCE.eClass();
+
+		// Obtain or create and register interdependencies
+		YConverterPackageImpl theYConverterPackage = (YConverterPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(YConverterPackage.eNS_URI) instanceof YConverterPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(YConverterPackage.eNS_URI) : YConverterPackage.eINSTANCE);
+		YVisibilityPackageImpl theYVisibilityPackage = (YVisibilityPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(YVisibilityPackage.eNS_URI) instanceof YVisibilityPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(YVisibilityPackage.eNS_URI) : YVisibilityPackage.eINSTANCE);
+
+		// Create package meta-data objects
+		theYECviewPackage.createPackageContents();
+		theYConverterPackage.createPackageContents();
+		theYVisibilityPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theYECviewPackage.initializePackageContents();
+		theYConverterPackage.initializePackageContents();
+		theYVisibilityPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theYECviewPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(YECviewPackage.eNS_URI, theYECviewPackage);
+		return theYECviewPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout
+	 * @generated
+	 */
+	public EClass getYStrategyLayout() {
+		return yStrategyLayoutEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout_ layouting strategy
+	 * @generated
+	 */
+	public EReference getYStrategyLayout_LayoutingStrategy() {
+		return (EReference)yStrategyLayoutEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout_ focusing strategies
+	 * @generated
+	 */
+	public EReference getYStrategyLayout_FocusingStrategies() {
+		return (EReference)yStrategyLayoutEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout_ suspects
+	 * @generated
+	 */
+	public EReference getYStrategyLayout_Suspects() {
+		return (EReference)yStrategyLayoutEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout_ layouting info
+	 * @generated
+	 */
+	public EReference getYStrategyLayout_LayoutingInfo() {
+		return (EReference)yStrategyLayoutEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout_ default focusing enhancer id
+	 * @generated
+	 */
+	public EAttribute getYStrategyLayout_DefaultFocusingEnhancerId() {
+		return (EAttribute)yStrategyLayoutEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting strategy
+	 * @generated
+	 */
+	public EClass getYLayoutingStrategy() {
+		return yLayoutingStrategyEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting strategy_ trigger
+	 * @generated
+	 */
+	public EAttribute getYLayoutingStrategy_Trigger() {
+		return (EAttribute)yLayoutingStrategyEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y default layouting strategy
+	 * @generated
+	 */
+	public EClass getYDefaultLayoutingStrategy() {
+		return yDefaultLayoutingStrategyEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y focusing strategy
+	 * @generated
+	 */
+	public EClass getYFocusingStrategy() {
+		return yFocusingStrategyEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y focusing strategy_ key stroke definition
+	 * @generated
+	 */
+	public EReference getYFocusingStrategy_KeyStrokeDefinition() {
+		return (EReference)yFocusingStrategyEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y focusing strategy_ temp stroke definition
+	 * @generated
+	 */
+	public EReference getYFocusingStrategy_TempStrokeDefinition() {
+		return (EReference)yFocusingStrategyEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y delegating layouting strategy
+	 * @generated
+	 */
+	public EClass getYDelegatingLayoutingStrategy() {
+		return yDelegatingLayoutingStrategyEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y delegating layouting strategy_ delegate strategy id
+	 * @generated
+	 */
+	public EAttribute getYDelegatingLayoutingStrategy_DelegateStrategyId() {
+		return (EAttribute)yDelegatingLayoutingStrategyEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y delegating focusing strategy
+	 * @generated
+	 */
+	public EClass getYDelegatingFocusingStrategy() {
+		return yDelegatingFocusingStrategyEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y delegating focusing strategy_ delegate strategy id
+	 * @generated
+	 */
+	public EAttribute getYDelegatingFocusingStrategy_DelegateStrategyId() {
+		return (EAttribute)yDelegatingFocusingStrategyEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect
+	 * @generated
+	 */
+	public EClass getYSuspect() {
+		return ySuspectEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ label i18n key
+	 * @generated
+	 */
+	public EAttribute getYSuspect_LabelI18nKey() {
+		return (EAttribute)ySuspectEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ image i18n key
+	 * @generated
+	 */
+	public EAttribute getYSuspect_ImageI18nKey() {
+		return (EAttribute)ySuspectEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ value binding endpoints
+	 * @generated
+	 */
+	public EReference getYSuspect_ValueBindingEndpoints() {
+		return (EReference)ySuspectEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ visibility processors
+	 * @generated
+	 */
+	public EReference getYSuspect_VisibilityProcessors() {
+		return (EReference)ySuspectEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ commands
+	 * @generated
+	 */
+	public EReference getYSuspect_Commands() {
+		return (EReference)ySuspectEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ assoc newiated elements
+	 * @generated
+	 */
+	public EReference getYSuspect_AssocNewiatedElements() {
+		return (EReference)ySuspectEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ associated bindings
+	 * @generated
+	 */
+	public EReference getYSuspect_AssociatedBindings() {
+		return (EReference)ySuspectEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect_ label
+	 * @generated
+	 */
+	public EAttribute getYSuspect_Label() {
+		return (EAttribute)ySuspectEClass.getEStructuralFeatures().get(7);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting info
+	 * @generated
+	 */
+	public EClass getYLayoutingInfo() {
+		return yLayoutingInfoEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting info_ layout
+	 * @generated
+	 */
+	public EReference getYLayoutingInfo_Layout() {
+		return (EReference)yLayoutingInfoEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting info_ content
+	 * @generated
+	 */
+	public EReference getYLayoutingInfo_Content() {
+		return (EReference)yLayoutingInfoEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting info_ active suspect infos
+	 * @generated
+	 */
+	public EReference getYLayoutingInfo_ActiveSuspectInfos() {
+		return (EReference)yLayoutingInfoEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y layouting info_ first focus
+	 * @generated
+	 */
+	public EReference getYLayoutingInfo_FirstFocus() {
+		return (EReference)yLayoutingInfoEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info
+	 * @generated
+	 */
+	public EClass getYSuspectInfo() {
+		return ySuspectInfoEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info_ suspect
+	 * @generated
+	 */
+	public EReference getYSuspectInfo_Suspect() {
+		return (EReference)ySuspectInfoEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info_ bindings
+	 * @generated
+	 */
+	public EReference getYSuspectInfo_Bindings() {
+		return (EReference)ySuspectInfoEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info_ next focus
+	 * @generated
+	 */
+	public EReference getYSuspectInfo_NextFocus() {
+		return (EReference)ySuspectInfoEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info_ previous focus
+	 * @generated
+	 */
+	public EReference getYSuspectInfo_PreviousFocus() {
+		return (EReference)ySuspectInfoEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info_ target
+	 * @generated
+	 */
+	public EReference getYSuspectInfo_Target() {
+		return (EReference)ySuspectInfoEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYSuspectInfo_VisibilityProcessors() {
+		return (EReference)ySuspectInfoEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y blob upload component
+	 * @generated
+	 */
+	public EClass getYBlobUploadComponent() {
+		return yBlobUploadComponentEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y blob upload component_ value
+	 * @generated
+	 */
+	public EAttribute getYBlobUploadComponent_Value() {
+		return (EAttribute)yBlobUploadComponentEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y blob upload component_ display resolution id
+	 * @generated
+	 */
+	public EAttribute getYBlobUploadComponent_DisplayResolutionId() {
+		return (EAttribute)yBlobUploadComponentEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYBlobUploadComponent_FirmlyLinked() {
+		return (EAttribute)yBlobUploadComponentEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYBlobUploadComponent_UniqueNameEnabled() {
+		return (EAttribute)yBlobUploadComponentEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y typed suspect
+	 * @generated
+	 */
+	public EClass getYTypedSuspect() {
+		return yTypedSuspectEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y typed suspect_ type qualified name
+	 * @generated
+	 */
+	public EAttribute getYTypedSuspect_TypeQualifiedName() {
+		return (EAttribute)yTypedSuspectEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y typed suspect_ type
+	 * @generated
+	 */
+	public EAttribute getYTypedSuspect_Type() {
+		return (EAttribute)yTypedSuspectEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y typed compound suspect
+	 * @generated
+	 */
+	public EClass getYTypedCompoundSuspect() {
+		return yTypedCompoundSuspectEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y typed compound suspect_ children
+	 * @generated
+	 */
+	public EReference getYTypedCompoundSuspect_Children() {
+		return (EReference)yTypedCompoundSuspectEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYSubTypeBaseSuspect() {
+		return ySubTypeBaseSuspectEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYSubTypeSuspect() {
+		return ySubTypeSuspectEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYSubTypeSuspect_BeanSlot() {
+		return (EReference)ySubTypeSuspectEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal field
+	 * @generated
+	 */
+	public EClass getYCustomDecimalField() {
+		return yCustomDecimalFieldEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal field_ datatype
+	 * @generated
+	 */
+	public EReference getYCustomDecimalField_Datatype() {
+		return (EReference)yCustomDecimalFieldEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal field_ datadescription
+	 * @generated
+	 */
+	public EReference getYCustomDecimalField_Datadescription() {
+		return (EReference)yCustomDecimalFieldEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y custom decimal field_ value
+	 * @generated
+	 */
+	public EAttribute getYCustomDecimalField_Value() {
+		return (EAttribute)yCustomDecimalFieldEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box
+	 * @generated
+	 */
+	public EClass getYIconComboBox() {
+		return yIconComboBoxEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ datadescription
+	 * @generated
+	 */
+	public EReference getYIconComboBox_Datadescription() {
+		return (EReference)yIconComboBoxEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ datatype
+	 * @generated
+	 */
+	public EReference getYIconComboBox_Datatype() {
+		return (EReference)yIconComboBoxEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ selection
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_Selection() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ type
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_Type() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ emf ns uri
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_EmfNsURI() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ type qualified name
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_TypeQualifiedName() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ caption property
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_CaptionProperty() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ image property
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_ImageProperty() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(7);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ description property
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_DescriptionProperty() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(8);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y icon combo box_ description
+	 * @generated
+	 */
+	public EAttribute getYIconComboBox_Description() {
+		return (EAttribute)yIconComboBoxEClass.getEStructuralFeatures().get(9);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity text field
+	 * @generated
+	 */
+	public EClass getYQuantityTextField() {
+		return yQuantityTextFieldEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity text field_ datadescription
+	 * @generated
+	 */
+	public EReference getYQuantityTextField_Datadescription() {
+		return (EReference)yQuantityTextFieldEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y quantity text field_ value
+	 * @generated
+	 */
+	public EAttribute getYQuantityTextField_Value() {
+		return (EAttribute)yQuantityTextFieldEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y collection suspect
+	 * @generated
+	 */
+	public EClass getYCollectionSuspect() {
+		return yCollectionSuspectEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y collection suspect_ columns
+	 * @generated
+	 */
+	public EReference getYCollectionSuspect_Columns() {
+		return (EReference)yCollectionSuspectEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y column info
+	 * @generated
+	 */
+	public EClass getYColumnInfo() {
+		return yColumnInfoEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y column info_ name
+	 * @generated
+	 */
+	public EAttribute getYColumnInfo_Name() {
+		return (EAttribute)yColumnInfoEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y column info_ type
+	 * @generated
+	 */
+	public EAttribute getYColumnInfo_Type() {
+		return (EAttribute)yColumnInfoEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y column info_ type qualified name
+	 * @generated
+	 */
+	public EAttribute getYColumnInfo_TypeQualifiedName() {
+		return (EAttribute)yColumnInfoEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y column info_ properties
+	 * @generated
+	 */
+	public EReference getYColumnInfo_Properties() {
+		return (EReference)yColumnInfoEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y column info_ label i18n key
+	 * @generated
+	 */
+	public EAttribute getYColumnInfo_LabelI18nKey() {
+		return (EAttribute)yColumnInfoEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYContentSensitiveLayout() {
+		return yContentSensitiveLayoutEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYRichTextArea() {
+		return yRichTextAreaEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYRichTextArea_Datadescription() {
+		return (EReference)yRichTextAreaEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYRichTextArea_BlobValue() {
+		return (EAttribute)yRichTextAreaEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYRichTextArea_Value() {
+		return (EAttribute)yRichTextAreaEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYRichTextArea_UseBlob() {
+		return (EAttribute)yRichTextAreaEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYMaskedTextField() {
+		return yMaskedTextFieldEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYMaskedTextField_Datadescription() {
+		return (EReference)yMaskedTextFieldEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedTextField_Value() {
+		return (EAttribute)yMaskedTextFieldEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedTextField_Mask() {
+		return (EAttribute)yMaskedTextFieldEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYPrefixedMaskedTextField() {
+		return yPrefixedMaskedTextFieldEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYPrefixedMaskedTextField_Datadescription() {
+		return (EReference)yPrefixedMaskedTextFieldEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPrefixedMaskedTextField_Value() {
+		return (EAttribute)yPrefixedMaskedTextFieldEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPrefixedMaskedTextField_Mask() {
+		return (EAttribute)yPrefixedMaskedTextFieldEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYPrefixedMaskedTextField_Prefixes() {
+		return (EReference)yPrefixedMaskedTextFieldEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYMaskedNumericField() {
+		return yMaskedNumericFieldEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYMaskedNumericField_Datadescription() {
+		return (EReference)yMaskedNumericFieldEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedNumericField_Value() {
+		return (EAttribute)yMaskedNumericFieldEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedNumericField_Mask() {
+		return (EAttribute)yMaskedNumericFieldEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYMaskedDecimalField() {
+		return yMaskedDecimalFieldEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYMaskedDecimalField_Datadescription() {
+		return (EReference)yMaskedDecimalFieldEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedDecimalField_Value() {
+		return (EAttribute)yMaskedDecimalFieldEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedDecimalField_Mask() {
+		return (EAttribute)yMaskedDecimalFieldEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedDecimalField_DecimalSeparator() {
+		return (EAttribute)yMaskedDecimalFieldEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYMaskedDecimalField_GroupingSeparator() {
+		return (EAttribute)yMaskedDecimalFieldEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EDataType getNumber() {
+		return numberEDataType;
+	}
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+
+	public EClass getYPairComboBox() {
+		return yPairComboBoxEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYPairComboBox_Datadescription() {
+		return (EReference)yPairComboBoxEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYPairComboBox_Datatype() {
+		return (EReference)yPairComboBoxEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_Selection() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_Collection() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_Type() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_EmfNsURI() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_TypeQualifiedName() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_CaptionProperty() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(7);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_ImageProperty() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(8);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_DescriptionProperty() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(9);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYPairComboBox_Description() {
+		return (EAttribute)yPairComboBoxEClass.getEStructuralFeatures().get(10);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the YE cview factory
+	 * @generated
+	 */
+	public YECviewFactory getYECviewFactory() {
+		return (YECviewFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		yStrategyLayoutEClass = createEClass(YSTRATEGY_LAYOUT);
+		createEReference(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY);
+		createEReference(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES);
+		createEReference(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__SUSPECTS);
+		createEReference(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__LAYOUTING_INFO);
+		createEAttribute(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID);
+
+		yLayoutingStrategyEClass = createEClass(YLAYOUTING_STRATEGY);
+		createEAttribute(yLayoutingStrategyEClass, YLAYOUTING_STRATEGY__TRIGGER);
+
+		yDefaultLayoutingStrategyEClass = createEClass(YDEFAULT_LAYOUTING_STRATEGY);
+
+		yFocusingStrategyEClass = createEClass(YFOCUSING_STRATEGY);
+		createEReference(yFocusingStrategyEClass, YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION);
+		createEReference(yFocusingStrategyEClass, YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION);
+
+		yDelegatingLayoutingStrategyEClass = createEClass(YDELEGATING_LAYOUTING_STRATEGY);
+		createEAttribute(yDelegatingLayoutingStrategyEClass, YDELEGATING_LAYOUTING_STRATEGY__DELEGATE_STRATEGY_ID);
+
+		yDelegatingFocusingStrategyEClass = createEClass(YDELEGATING_FOCUSING_STRATEGY);
+		createEAttribute(yDelegatingFocusingStrategyEClass, YDELEGATING_FOCUSING_STRATEGY__DELEGATE_STRATEGY_ID);
+
+		ySuspectEClass = createEClass(YSUSPECT);
+		createEAttribute(ySuspectEClass, YSUSPECT__LABEL_I1_8N_KEY);
+		createEAttribute(ySuspectEClass, YSUSPECT__IMAGE_I1_8N_KEY);
+		createEReference(ySuspectEClass, YSUSPECT__VALUE_BINDING_ENDPOINTS);
+		createEReference(ySuspectEClass, YSUSPECT__VISIBILITY_PROCESSORS);
+		createEReference(ySuspectEClass, YSUSPECT__COMMANDS);
+		createEReference(ySuspectEClass, YSUSPECT__ASSOC_NEWIATED_ELEMENTS);
+		createEReference(ySuspectEClass, YSUSPECT__ASSOCIATED_BINDINGS);
+		createEAttribute(ySuspectEClass, YSUSPECT__LABEL);
+
+		yTypedSuspectEClass = createEClass(YTYPED_SUSPECT);
+		createEAttribute(yTypedSuspectEClass, YTYPED_SUSPECT__TYPE_QUALIFIED_NAME);
+		createEAttribute(yTypedSuspectEClass, YTYPED_SUSPECT__TYPE);
+
+		yTypedCompoundSuspectEClass = createEClass(YTYPED_COMPOUND_SUSPECT);
+		createEReference(yTypedCompoundSuspectEClass, YTYPED_COMPOUND_SUSPECT__CHILDREN);
+
+		ySubTypeBaseSuspectEClass = createEClass(YSUB_TYPE_BASE_SUSPECT);
+
+		ySubTypeSuspectEClass = createEClass(YSUB_TYPE_SUSPECT);
+		createEReference(ySubTypeSuspectEClass, YSUB_TYPE_SUSPECT__BEAN_SLOT);
+
+		yLayoutingInfoEClass = createEClass(YLAYOUTING_INFO);
+		createEReference(yLayoutingInfoEClass, YLAYOUTING_INFO__LAYOUT);
+		createEReference(yLayoutingInfoEClass, YLAYOUTING_INFO__CONTENT);
+		createEReference(yLayoutingInfoEClass, YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS);
+		createEReference(yLayoutingInfoEClass, YLAYOUTING_INFO__FIRST_FOCUS);
+
+		ySuspectInfoEClass = createEClass(YSUSPECT_INFO);
+		createEReference(ySuspectInfoEClass, YSUSPECT_INFO__SUSPECT);
+		createEReference(ySuspectInfoEClass, YSUSPECT_INFO__BINDINGS);
+		createEReference(ySuspectInfoEClass, YSUSPECT_INFO__NEXT_FOCUS);
+		createEReference(ySuspectInfoEClass, YSUSPECT_INFO__PREVIOUS_FOCUS);
+		createEReference(ySuspectInfoEClass, YSUSPECT_INFO__TARGET);
+		createEReference(ySuspectInfoEClass, YSUSPECT_INFO__VISIBILITY_PROCESSORS);
+
+		yBlobUploadComponentEClass = createEClass(YBLOB_UPLOAD_COMPONENT);
+		createEAttribute(yBlobUploadComponentEClass, YBLOB_UPLOAD_COMPONENT__VALUE);
+		createEAttribute(yBlobUploadComponentEClass, YBLOB_UPLOAD_COMPONENT__DISPLAY_RESOLUTION_ID);
+		createEAttribute(yBlobUploadComponentEClass, YBLOB_UPLOAD_COMPONENT__FIRMLY_LINKED);
+		createEAttribute(yBlobUploadComponentEClass, YBLOB_UPLOAD_COMPONENT__UNIQUE_NAME_ENABLED);
+
+		yCustomDecimalFieldEClass = createEClass(YCUSTOM_DECIMAL_FIELD);
+		createEReference(yCustomDecimalFieldEClass, YCUSTOM_DECIMAL_FIELD__DATATYPE);
+		createEReference(yCustomDecimalFieldEClass, YCUSTOM_DECIMAL_FIELD__DATADESCRIPTION);
+		createEAttribute(yCustomDecimalFieldEClass, YCUSTOM_DECIMAL_FIELD__VALUE);
+
+		yIconComboBoxEClass = createEClass(YICON_COMBO_BOX);
+		createEReference(yIconComboBoxEClass, YICON_COMBO_BOX__DATADESCRIPTION);
+		createEReference(yIconComboBoxEClass, YICON_COMBO_BOX__DATATYPE);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__SELECTION);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__TYPE);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__EMF_NS_URI);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__TYPE_QUALIFIED_NAME);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__CAPTION_PROPERTY);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__IMAGE_PROPERTY);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__DESCRIPTION_PROPERTY);
+		createEAttribute(yIconComboBoxEClass, YICON_COMBO_BOX__DESCRIPTION);
+
+		yQuantityTextFieldEClass = createEClass(YQUANTITY_TEXT_FIELD);
+		createEReference(yQuantityTextFieldEClass, YQUANTITY_TEXT_FIELD__DATADESCRIPTION);
+		createEAttribute(yQuantityTextFieldEClass, YQUANTITY_TEXT_FIELD__VALUE);
+
+		yCollectionSuspectEClass = createEClass(YCOLLECTION_SUSPECT);
+		createEReference(yCollectionSuspectEClass, YCOLLECTION_SUSPECT__COLUMNS);
+
+		yColumnInfoEClass = createEClass(YCOLUMN_INFO);
+		createEAttribute(yColumnInfoEClass, YCOLUMN_INFO__NAME);
+		createEAttribute(yColumnInfoEClass, YCOLUMN_INFO__TYPE);
+		createEAttribute(yColumnInfoEClass, YCOLUMN_INFO__TYPE_QUALIFIED_NAME);
+		createEReference(yColumnInfoEClass, YCOLUMN_INFO__PROPERTIES);
+		createEAttribute(yColumnInfoEClass, YCOLUMN_INFO__LABEL_I1_8N_KEY);
+
+		yContentSensitiveLayoutEClass = createEClass(YCONTENT_SENSITIVE_LAYOUT);
+
+		yRichTextAreaEClass = createEClass(YRICH_TEXT_AREA);
+		createEReference(yRichTextAreaEClass, YRICH_TEXT_AREA__DATADESCRIPTION);
+		createEAttribute(yRichTextAreaEClass, YRICH_TEXT_AREA__BLOB_VALUE);
+		createEAttribute(yRichTextAreaEClass, YRICH_TEXT_AREA__VALUE);
+		createEAttribute(yRichTextAreaEClass, YRICH_TEXT_AREA__USE_BLOB);
+
+		yMaskedTextFieldEClass = createEClass(YMASKED_TEXT_FIELD);
+		createEReference(yMaskedTextFieldEClass, YMASKED_TEXT_FIELD__DATADESCRIPTION);
+		createEAttribute(yMaskedTextFieldEClass, YMASKED_TEXT_FIELD__VALUE);
+		createEAttribute(yMaskedTextFieldEClass, YMASKED_TEXT_FIELD__MASK);
+
+		yPrefixedMaskedTextFieldEClass = createEClass(YPREFIXED_MASKED_TEXT_FIELD);
+		createEReference(yPrefixedMaskedTextFieldEClass, YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION);
+		createEAttribute(yPrefixedMaskedTextFieldEClass, YPREFIXED_MASKED_TEXT_FIELD__VALUE);
+		createEAttribute(yPrefixedMaskedTextFieldEClass, YPREFIXED_MASKED_TEXT_FIELD__MASK);
+		createEReference(yPrefixedMaskedTextFieldEClass, YPREFIXED_MASKED_TEXT_FIELD__PREFIXES);
+
+		yMaskedNumericFieldEClass = createEClass(YMASKED_NUMERIC_FIELD);
+		createEReference(yMaskedNumericFieldEClass, YMASKED_NUMERIC_FIELD__DATADESCRIPTION);
+		createEAttribute(yMaskedNumericFieldEClass, YMASKED_NUMERIC_FIELD__VALUE);
+		createEAttribute(yMaskedNumericFieldEClass, YMASKED_NUMERIC_FIELD__MASK);
+
+		yMaskedDecimalFieldEClass = createEClass(YMASKED_DECIMAL_FIELD);
+		createEReference(yMaskedDecimalFieldEClass, YMASKED_DECIMAL_FIELD__DATADESCRIPTION);
+		createEAttribute(yMaskedDecimalFieldEClass, YMASKED_DECIMAL_FIELD__VALUE);
+		createEAttribute(yMaskedDecimalFieldEClass, YMASKED_DECIMAL_FIELD__MASK);
+		createEAttribute(yMaskedDecimalFieldEClass, YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR);
+		createEAttribute(yMaskedDecimalFieldEClass, YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR);
+
+		yPairComboBoxEClass = createEClass(YPAIR_COMBO_BOX);
+		createEReference(yPairComboBoxEClass, YPAIR_COMBO_BOX__DATADESCRIPTION);
+		createEReference(yPairComboBoxEClass, YPAIR_COMBO_BOX__DATATYPE);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__SELECTION);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__COLLECTION);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__TYPE);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__EMF_NS_URI);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__CAPTION_PROPERTY);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__IMAGE_PROPERTY);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY);
+		createEAttribute(yPairComboBoxEClass, YPAIR_COMBO_BOX__DESCRIPTION);
+
+		// Create data types
+		numberEDataType = createEDataType(NUMBER);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		YConverterPackage theYConverterPackage = (YConverterPackage)EPackage.Registry.INSTANCE.getEPackage(YConverterPackage.eNS_URI);
+		YVisibilityPackage theYVisibilityPackage = (YVisibilityPackage)EPackage.Registry.INSTANCE.getEPackage(YVisibilityPackage.eNS_URI);
+		CoreModelPackage theCoreModelPackage = (CoreModelPackage)EPackage.Registry.INSTANCE.getEPackage(CoreModelPackage.eNS_URI);
+		BindingPackage theBindingPackage = (BindingPackage)EPackage.Registry.INSTANCE.getEPackage(BindingPackage.eNS_URI);
+		VisibilityPackage theVisibilityPackage = (VisibilityPackage)EPackage.Registry.INSTANCE.getEPackage(VisibilityPackage.eNS_URI);
+		ExtensionModelPackage theExtensionModelPackage = (ExtensionModelPackage)EPackage.Registry.INSTANCE.getEPackage(ExtensionModelPackage.eNS_URI);
+		ExtDatatypesPackage theExtDatatypesPackage = (ExtDatatypesPackage)EPackage.Registry.INSTANCE.getEPackage(ExtDatatypesPackage.eNS_URI);
+		DatatypesPackage theDatatypesPackage = (DatatypesPackage)EPackage.Registry.INSTANCE.getEPackage(DatatypesPackage.eNS_URI);
+
+		// Add subpackages
+		getESubpackages().add(theYConverterPackage);
+		getESubpackages().add(theYVisibilityPackage);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		yStrategyLayoutEClass.getESuperTypes().add(theCoreModelPackage.getYEmbeddable());
+		yLayoutingStrategyEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		yDefaultLayoutingStrategyEClass.getESuperTypes().add(this.getYLayoutingStrategy());
+		yFocusingStrategyEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		yDelegatingLayoutingStrategyEClass.getESuperTypes().add(this.getYLayoutingStrategy());
+		yDelegatingFocusingStrategyEClass.getESuperTypes().add(this.getYFocusingStrategy());
+		ySuspectEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		ySuspectEClass.getESuperTypes().add(theCoreModelPackage.getYAuthorizationable());
+		yTypedSuspectEClass.getESuperTypes().add(this.getYSuspect());
+		yTypedCompoundSuspectEClass.getESuperTypes().add(this.getYTypedSuspect());
+		ySubTypeBaseSuspectEClass.getESuperTypes().add(this.getYTypedCompoundSuspect());
+		ySubTypeSuspectEClass.getESuperTypes().add(this.getYTypedCompoundSuspect());
+		yLayoutingInfoEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		ySuspectInfoEClass.getESuperTypes().add(theCoreModelPackage.getYElement());
+		yBlobUploadComponentEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yBlobUploadComponentEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yCustomDecimalFieldEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yCustomDecimalFieldEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yIconComboBoxEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yIconComboBoxEClass.getESuperTypes().add(theCoreModelPackage.getYCollectionBindable());
+		yIconComboBoxEClass.getESuperTypes().add(theCoreModelPackage.getYSelectionBindable());
+		yIconComboBoxEClass.getESuperTypes().add(theExtensionModelPackage.getYBeanServiceConsumer());
+		yQuantityTextFieldEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yQuantityTextFieldEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yCollectionSuspectEClass.getESuperTypes().add(this.getYTypedSuspect());
+		yContentSensitiveLayoutEClass.getESuperTypes().add(theCoreModelPackage.getYLayout());
+		yContentSensitiveLayoutEClass.getESuperTypes().add(theCoreModelPackage.getYSpacingable());
+		yContentSensitiveLayoutEClass.getESuperTypes().add(theCoreModelPackage.getYMarginable());
+		yRichTextAreaEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yRichTextAreaEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yMaskedTextFieldEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yMaskedTextFieldEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yPrefixedMaskedTextFieldEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yPrefixedMaskedTextFieldEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yMaskedNumericFieldEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yMaskedNumericFieldEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yMaskedDecimalFieldEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yMaskedDecimalFieldEClass.getESuperTypes().add(theCoreModelPackage.getYValueBindable());
+		yPairComboBoxEClass.getESuperTypes().add(theExtensionModelPackage.getYInput());
+		yPairComboBoxEClass.getESuperTypes().add(theCoreModelPackage.getYCollectionBindable());
+		yPairComboBoxEClass.getESuperTypes().add(theCoreModelPackage.getYSelectionBindable());
+		yPairComboBoxEClass.getESuperTypes().add(theExtensionModelPackage.getYBeanServiceConsumer());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(yStrategyLayoutEClass, YStrategyLayout.class, "YStrategyLayout", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYStrategyLayout_LayoutingStrategy(), this.getYLayoutingStrategy(), null, "layoutingStrategy", null, 0, 1, YStrategyLayout.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYStrategyLayout_FocusingStrategies(), this.getYFocusingStrategy(), null, "focusingStrategies", null, 0, -1, YStrategyLayout.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYStrategyLayout_Suspects(), this.getYSuspect(), null, "suspects", null, 0, -1, YStrategyLayout.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYStrategyLayout_LayoutingInfo(), this.getYLayoutingInfo(), null, "layoutingInfo", null, 0, 1, YStrategyLayout.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYStrategyLayout_DefaultFocusingEnhancerId(), ecorePackage.getEString(), "defaultFocusingEnhancerId", null, 0, 1, YStrategyLayout.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yLayoutingStrategyEClass, YLayoutingStrategy.class, "YLayoutingStrategy", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYLayoutingStrategy_Trigger(), ecorePackage.getEJavaObject(), "trigger", null, 0, 1, YLayoutingStrategy.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		addEOperation(yLayoutingStrategyEClass, theCoreModelPackage.getYView(), "getView", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(yDefaultLayoutingStrategyEClass, YDefaultLayoutingStrategy.class, "YDefaultLayoutingStrategy", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(yFocusingStrategyEClass, YFocusingStrategy.class, "YFocusingStrategy", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYFocusingStrategy_KeyStrokeDefinition(), theCoreModelPackage.getYKeyStrokeDefinition(), null, "keyStrokeDefinition", null, 0, 1, YFocusingStrategy.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYFocusingStrategy_TempStrokeDefinition(), theCoreModelPackage.getYKeyStrokeDefinition(), null, "tempStrokeDefinition", null, 0, 1, YFocusingStrategy.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		addEOperation(yFocusingStrategyEClass, theCoreModelPackage.getYView(), "getView", 0, 1, IS_UNIQUE, IS_ORDERED);
+
+		initEClass(yDelegatingLayoutingStrategyEClass, YDelegatingLayoutingStrategy.class, "YDelegatingLayoutingStrategy", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYDelegatingLayoutingStrategy_DelegateStrategyId(), ecorePackage.getEString(), "delegateStrategyId", null, 1, 1, YDelegatingLayoutingStrategy.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yDelegatingFocusingStrategyEClass, YDelegatingFocusingStrategy.class, "YDelegatingFocusingStrategy", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYDelegatingFocusingStrategy_DelegateStrategyId(), ecorePackage.getEString(), "delegateStrategyId", null, 1, 1, YDelegatingFocusingStrategy.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(ySuspectEClass, YSuspect.class, "YSuspect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYSuspect_LabelI18nKey(), ecorePackage.getEString(), "labelI18nKey", null, 0, 1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYSuspect_ImageI18nKey(), ecorePackage.getEString(), "imageI18nKey", null, 0, 1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspect_ValueBindingEndpoints(), theBindingPackage.getYBindingEndpoint(), null, "valueBindingEndpoints", null, 0, -1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspect_VisibilityProcessors(), theVisibilityPackage.getYVisibilityProcessor(), null, "visibilityProcessors", null, 0, -1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspect_Commands(), theCoreModelPackage.getYCommand(), null, "commands", null, 0, -1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspect_AssocNewiatedElements(), theCoreModelPackage.getYEmbeddable(), null, "assocNewiatedElements", null, 0, -1, YSuspect.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspect_AssociatedBindings(), theBindingPackage.getYBinding(), null, "associatedBindings", null, 0, -1, YSuspect.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYSuspect_Label(), ecorePackage.getEString(), "label", null, 0, 1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yTypedSuspectEClass, YTypedSuspect.class, "YTypedSuspect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYTypedSuspect_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, YTypedSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		EGenericType g1 = createEGenericType(ecorePackage.getEJavaClass());
+		EGenericType g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getYTypedSuspect_Type(), g1, "type", null, 0, 1, YTypedSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yTypedCompoundSuspectEClass, YTypedCompoundSuspect.class, "YTypedCompoundSuspect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYTypedCompoundSuspect_Children(), this.getYSuspect(), null, "children", null, 0, -1, YTypedCompoundSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(ySubTypeBaseSuspectEClass, YSubTypeBaseSuspect.class, "YSubTypeBaseSuspect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(ySubTypeSuspectEClass, YSubTypeSuspect.class, "YSubTypeSuspect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYSubTypeSuspect_BeanSlot(), theCoreModelPackage.getYBeanSlot(), null, "beanSlot", null, 1, 1, YSubTypeSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yLayoutingInfoEClass, YLayoutingInfo.class, "YLayoutingInfo", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYLayoutingInfo_Layout(), this.getYStrategyLayout(), null, "layout", null, 0, 1, YLayoutingInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYLayoutingInfo_Content(), theCoreModelPackage.getYEmbeddable(), null, "content", null, 0, 1, YLayoutingInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYLayoutingInfo_ActiveSuspectInfos(), this.getYSuspectInfo(), null, "activeSuspectInfos", null, 0, -1, YLayoutingInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYLayoutingInfo_FirstFocus(), this.getYSuspectInfo(), null, "firstFocus", null, 0, 1, YLayoutingInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(ySuspectInfoEClass, YSuspectInfo.class, "YSuspectInfo", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYSuspectInfo_Suspect(), this.getYSuspect(), null, "suspect", null, 0, 1, YSuspectInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspectInfo_Bindings(), theBindingPackage.getYBinding(), null, "bindings", null, 0, -1, YSuspectInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspectInfo_NextFocus(), this.getYSuspectInfo(), this.getYSuspectInfo_PreviousFocus(), "nextFocus", null, 0, 1, YSuspectInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspectInfo_PreviousFocus(), this.getYSuspectInfo(), this.getYSuspectInfo_NextFocus(), "previousFocus", null, 0, 1, YSuspectInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspectInfo_Target(), theCoreModelPackage.getYEmbeddable(), null, "target", null, 0, 1, YSuspectInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSuspectInfo_VisibilityProcessors(), theVisibilityPackage.getYVisibilityProcessor(), null, "visibilityProcessors", null, 0, -1, YSuspectInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yBlobUploadComponentEClass, YBlobUploadComponent.class, "YBlobUploadComponent", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYBlobUploadComponent_Value(), ecorePackage.getEString(), "value", null, 0, 1, YBlobUploadComponent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYBlobUploadComponent_DisplayResolutionId(), ecorePackage.getEInt(), "displayResolutionId", null, 0, 1, YBlobUploadComponent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYBlobUploadComponent_FirmlyLinked(), ecorePackage.getEBoolean(), "firmlyLinked", null, 0, 1, YBlobUploadComponent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYBlobUploadComponent_UniqueNameEnabled(), ecorePackage.getEBoolean(), "uniqueNameEnabled", null, 0, 1, YBlobUploadComponent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yCustomDecimalFieldEClass, YCustomDecimalField.class, "YCustomDecimalField", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYCustomDecimalField_Datatype(), theExtDatatypesPackage.getYDecimalDatatype(), null, "datatype", null, 0, 1, YCustomDecimalField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYCustomDecimalField_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YCustomDecimalField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYCustomDecimalField_Value(), ecorePackage.getEDouble(), "value", null, 0, 1, YCustomDecimalField.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yIconComboBoxEClass, YIconComboBox.class, "YIconComboBox", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYIconComboBox_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYIconComboBox_Datatype(), theExtDatatypesPackage.getYComboBoxDatatype(), null, "datatype", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYIconComboBox_Selection(), ecorePackage.getEJavaObject(), "selection", null, 0, 1, YIconComboBox.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEJavaClass());
+		g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getYIconComboBox_Type(), g1, "type", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYIconComboBox_EmfNsURI(), ecorePackage.getEString(), "emfNsURI", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYIconComboBox_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYIconComboBox_CaptionProperty(), ecorePackage.getEString(), "captionProperty", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYIconComboBox_ImageProperty(), ecorePackage.getEString(), "imageProperty", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYIconComboBox_DescriptionProperty(), ecorePackage.getEString(), "descriptionProperty", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYIconComboBox_Description(), ecorePackage.getEString(), "description", null, 0, 1, YIconComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yQuantityTextFieldEClass, YQuantityTextField.class, "YQuantityTextField", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYQuantityTextField_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YQuantityTextField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYQuantityTextField_Value(), ecorePackage.getEJavaObject(), "value", null, 0, 1, YQuantityTextField.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yCollectionSuspectEClass, YCollectionSuspect.class, "YCollectionSuspect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYCollectionSuspect_Columns(), this.getYColumnInfo(), null, "columns", null, 0, -1, YCollectionSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yColumnInfoEClass, YColumnInfo.class, "YColumnInfo", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYColumnInfo_Name(), ecorePackage.getEString(), "name", null, 0, 1, YColumnInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEJavaClass());
+		g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getYColumnInfo_Type(), g1, "type", null, 0, 1, YColumnInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYColumnInfo_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, YColumnInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYColumnInfo_Properties(), theCoreModelPackage.getYStringToStringMap(), null, "properties", null, 0, -1, YColumnInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYColumnInfo_LabelI18nKey(), ecorePackage.getEString(), "labelI18nKey", null, 0, 1, YColumnInfo.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yContentSensitiveLayoutEClass, YContentSensitiveLayout.class, "YContentSensitiveLayout", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(yRichTextAreaEClass, YRichTextArea.class, "YRichTextArea", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYRichTextArea_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YRichTextArea.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYRichTextArea_BlobValue(), ecorePackage.getEByteArray(), "blobValue", null, 0, 1, YRichTextArea.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYRichTextArea_Value(), ecorePackage.getEString(), "value", null, 0, 1, YRichTextArea.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYRichTextArea_UseBlob(), ecorePackage.getEBoolean(), "useBlob", "false", 0, 1, YRichTextArea.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yMaskedTextFieldEClass, YMaskedTextField.class, "YMaskedTextField", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYMaskedTextField_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YMaskedTextField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedTextField_Value(), ecorePackage.getEString(), "value", null, 0, 1, YMaskedTextField.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedTextField_Mask(), ecorePackage.getEString(), "mask", "", 0, 1, YMaskedTextField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yPrefixedMaskedTextFieldEClass, YPrefixedMaskedTextField.class, "YPrefixedMaskedTextField", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYPrefixedMaskedTextField_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YPrefixedMaskedTextField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPrefixedMaskedTextField_Value(), ecorePackage.getEString(), "value", null, 0, 1, YPrefixedMaskedTextField.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPrefixedMaskedTextField_Mask(), ecorePackage.getEString(), "mask", "", 0, 1, YPrefixedMaskedTextField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYPrefixedMaskedTextField_Prefixes(), theCoreModelPackage.getYStringToStringMap(), null, "prefixes", null, 0, -1, YPrefixedMaskedTextField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yMaskedNumericFieldEClass, YMaskedNumericField.class, "YMaskedNumericField", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYMaskedNumericField_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YMaskedNumericField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedNumericField_Value(), this.getNumber(), "value", null, 0, 1, YMaskedNumericField.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedNumericField_Mask(), ecorePackage.getEString(), "mask", "", 0, 1, YMaskedNumericField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yMaskedDecimalFieldEClass, YMaskedDecimalField.class, "YMaskedDecimalField", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYMaskedDecimalField_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YMaskedDecimalField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedDecimalField_Value(), this.getNumber(), "value", null, 0, 1, YMaskedDecimalField.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedDecimalField_Mask(), ecorePackage.getEString(), "mask", "", 0, 1, YMaskedDecimalField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedDecimalField_DecimalSeparator(), ecorePackage.getECharacterObject(), "decimalSeparator", "null", 0, 1, YMaskedDecimalField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYMaskedDecimalField_GroupingSeparator(), ecorePackage.getECharacterObject(), "groupingSeparator", "null", 0, 1, YMaskedDecimalField.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(yPairComboBoxEClass, YPairComboBox.class, "YPairComboBox", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getYPairComboBox_Datadescription(), theDatatypesPackage.getYDatadescription(), null, "datadescription", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYPairComboBox_Datatype(), theExtDatatypesPackage.getYComboBoxDatatype(), null, "datatype", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_Selection(), ecorePackage.getEJavaObject(), "selection", null, 0, 1, YPairComboBox.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_Collection(), ecorePackage.getEJavaObject(), "collection", null, 0, -1, YPairComboBox.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		g1 = createEGenericType(ecorePackage.getEJavaClass());
+		g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getYPairComboBox_Type(), g1, "type", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_EmfNsURI(), ecorePackage.getEString(), "emfNsURI", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_CaptionProperty(), ecorePackage.getEString(), "captionProperty", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_ImageProperty(), ecorePackage.getEString(), "imageProperty", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_DescriptionProperty(), ecorePackage.getEString(), "descriptionProperty", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYPairComboBox_Description(), ecorePackage.getEString(), "description", null, 0, 1, YPairComboBox.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		// Initialize data types
+		initEDataType(numberEDataType, Number.class, "Number", IS_SERIALIZABLE, !IS_GENERATED_INSTANCE_CLASS);
+
+		// Create resource
+		createResource(eNS_URI);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YFocusingStrategyImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YFocusingStrategyImpl.java
new file mode 100644
index 0000000..f41c43b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YFocusingStrategyImpl.java
@@ -0,0 +1,568 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YKeyStrokeDefinition;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YFocusing Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl#getKeyStrokeDefinition <em>Key Stroke Definition</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YFocusingStrategyImpl#getTempStrokeDefinition <em>Temp Stroke Definition</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YFocusingStrategyImpl extends MinimalEObjectImpl.Container implements YFocusingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getKeyStrokeDefinition() <em>Key Stroke Definition</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getKeyStrokeDefinition()
+	 * @generated
+	 * @ordered
+	 */
+	protected YKeyStrokeDefinition keyStrokeDefinition;
+
+	/**
+	 * The cached value of the '{@link #getTempStrokeDefinition() <em>Temp Stroke Definition</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTempStrokeDefinition()
+	 * @generated
+	 * @ordered
+	 */
+	protected YKeyStrokeDefinition tempStrokeDefinition;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YFocusingStrategyImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YFOCUSING_STRATEGY;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YFOCUSING_STRATEGY__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YFOCUSING_STRATEGY__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YECviewPackage.YFOCUSING_STRATEGY__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YECviewPackage.YFOCUSING_STRATEGY__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getKeyStrokeDefinition()
+	 *         <em>Key Stroke Definition</em>}' containment reference
+	 * @generated
+	 */
+	public YKeyStrokeDefinition getKeyStrokeDefinition() {
+		return keyStrokeDefinition;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newKeyStrokeDefinition
+	 *            the new key stroke definition
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetKeyStrokeDefinition(YKeyStrokeDefinition newKeyStrokeDefinition, NotificationChain msgs) {
+		YKeyStrokeDefinition oldKeyStrokeDefinition = keyStrokeDefinition;
+		keyStrokeDefinition = newKeyStrokeDefinition;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION, oldKeyStrokeDefinition, newKeyStrokeDefinition);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newKeyStrokeDefinition
+	 *            the new cached value of the '{@link #getKeyStrokeDefinition()
+	 *            <em>Key Stroke Definition</em>}' containment reference
+	 * @generated
+	 */
+	public void setKeyStrokeDefinition(YKeyStrokeDefinition newKeyStrokeDefinition) {
+		if (newKeyStrokeDefinition != keyStrokeDefinition) {
+			NotificationChain msgs = null;
+			if (keyStrokeDefinition != null)
+				msgs = ((InternalEObject)keyStrokeDefinition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION, null, msgs);
+			if (newKeyStrokeDefinition != null)
+				msgs = ((InternalEObject)newKeyStrokeDefinition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION, null, msgs);
+			msgs = basicSetKeyStrokeDefinition(newKeyStrokeDefinition, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION, newKeyStrokeDefinition, newKeyStrokeDefinition));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTempStrokeDefinition()
+	 *         <em>Temp Stroke Definition</em>}' containment reference
+	 * @generated
+	 */
+	public YKeyStrokeDefinition getTempStrokeDefinition() {
+		return tempStrokeDefinition;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTempStrokeDefinition
+	 *            the new temp stroke definition
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetTempStrokeDefinition(YKeyStrokeDefinition newTempStrokeDefinition, NotificationChain msgs) {
+		YKeyStrokeDefinition oldTempStrokeDefinition = tempStrokeDefinition;
+		tempStrokeDefinition = newTempStrokeDefinition;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION, oldTempStrokeDefinition, newTempStrokeDefinition);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTempStrokeDefinition
+	 *            the new cached value of the '
+	 *            {@link #getTempStrokeDefinition()
+	 *            <em>Temp Stroke Definition</em>}' containment reference
+	 * @generated
+	 */
+	public void setTempStrokeDefinition(YKeyStrokeDefinition newTempStrokeDefinition) {
+		if (newTempStrokeDefinition != tempStrokeDefinition) {
+			NotificationChain msgs = null;
+			if (tempStrokeDefinition != null)
+				msgs = ((InternalEObject)tempStrokeDefinition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION, null, msgs);
+			if (newTempStrokeDefinition != null)
+				msgs = ((InternalEObject)newTempStrokeDefinition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION, null, msgs);
+			msgs = basicSetTempStrokeDefinition(newTempStrokeDefinition, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION, newTempStrokeDefinition, newTempStrokeDefinition));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the view gen
+	 * @generated
+	 */
+	public YView getViewGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+	
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 * @generated NOT
+	 */
+	public YView getView() {
+		return findViewGeneric(eContainer());
+	}
+	
+	/**
+	 * Find view generic.
+	 *
+	 * @param container
+	 *            the container
+	 * @return the y view
+	 */
+	protected YView findViewGeneric(EObject container) {
+		if (container == null) {
+			return null;
+		}
+		if (container instanceof YView) {
+			return (YView) container;
+		} else if (container instanceof YLayout) {
+			return ((YLayout) container).getView();
+		} else {
+			EObject parent = container.eContainer();
+			return findViewGeneric(parent);
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YFOCUSING_STRATEGY__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION:
+				return basicSetKeyStrokeDefinition(null, msgs);
+			case YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION:
+				return basicSetTempStrokeDefinition(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YFOCUSING_STRATEGY__TAGS:
+				return getTags();
+			case YECviewPackage.YFOCUSING_STRATEGY__ID:
+				return getId();
+			case YECviewPackage.YFOCUSING_STRATEGY__NAME:
+				return getName();
+			case YECviewPackage.YFOCUSING_STRATEGY__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION:
+				return getKeyStrokeDefinition();
+			case YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION:
+				return getTempStrokeDefinition();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YFOCUSING_STRATEGY__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__ID:
+				setId((String)newValue);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__NAME:
+				setName((String)newValue);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION:
+				setKeyStrokeDefinition((YKeyStrokeDefinition)newValue);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION:
+				setTempStrokeDefinition((YKeyStrokeDefinition)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YFOCUSING_STRATEGY__TAGS:
+				getTags().clear();
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION:
+				setKeyStrokeDefinition((YKeyStrokeDefinition)null);
+				return;
+			case YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION:
+				setTempStrokeDefinition((YKeyStrokeDefinition)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YFOCUSING_STRATEGY__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YECviewPackage.YFOCUSING_STRATEGY__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YECviewPackage.YFOCUSING_STRATEGY__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YECviewPackage.YFOCUSING_STRATEGY__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YECviewPackage.YFOCUSING_STRATEGY__KEY_STROKE_DEFINITION:
+				return keyStrokeDefinition != null;
+			case YECviewPackage.YFOCUSING_STRATEGY__TEMP_STROKE_DEFINITION:
+				return tempStrokeDefinition != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YIconComboBoxImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YIconComboBoxImpl.java
new file mode 100644
index 0000000..657d1b2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YIconComboBoxImpl.java
@@ -0,0 +1,1233 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableCollectionEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableSelectionEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YComboBoxDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YIconComboBox;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YIcon Combo Box</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getCollectionBindingEndpoint <em>Collection Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getSelectionBindingEndpoint <em>Selection Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#isUseBeanService <em>Use Bean Service</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getDatatype <em>Datatype</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getSelection <em>Selection</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getEmfNsURI <em>Emf Ns URI</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getCaptionProperty <em>Caption Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getImageProperty <em>Image Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getDescriptionProperty <em>Description Property</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YIconComboBoxImpl#getDescription <em>Description</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YIconComboBoxImpl extends YInputImpl implements YIconComboBox {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getCollectionBindingEndpoint() <em>Collection Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCollectionBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableCollectionEndpoint collectionBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getSelectionBindingEndpoint() <em>Selection Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSelectionBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableSelectionEndpoint selectionBindingEndpoint;
+
+	/**
+	 * The default value of the '{@link #isUseBeanService() <em>Use Bean Service</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseBeanService()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean USE_BEAN_SERVICE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isUseBeanService() <em>Use Bean Service</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseBeanService()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean useBeanService = USE_BEAN_SERVICE_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The cached value of the '{@link #getDatatype() <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatatype()
+	 * @generated
+	 * @ordered
+	 */
+	protected YComboBoxDatatype datatype;
+
+	/**
+	 * The default value of the '{@link #getSelection() <em>Selection</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSelection()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Object SELECTION_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getSelection() <em>Selection</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSelection()
+	 * @generated
+	 * @ordered
+	 */
+	protected Object selection = SELECTION_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * The default value of the '{@link #getEmfNsURI() <em>Emf Ns URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEmfNsURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String EMF_NS_URI_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getEmfNsURI() <em>Emf Ns URI</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getEmfNsURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected String emfNsURI = EMF_NS_URI_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getCaptionProperty() <em>Caption Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCaptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String CAPTION_PROPERTY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getCaptionProperty() <em>Caption Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCaptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected String captionProperty = CAPTION_PROPERTY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getImageProperty() <em>Image Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getImageProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String IMAGE_PROPERTY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getImageProperty() <em>Image Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getImageProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected String imageProperty = IMAGE_PROPERTY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getDescriptionProperty() <em>Description Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDescriptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DESCRIPTION_PROPERTY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDescriptionProperty() <em>Description Property</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDescriptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected String descriptionProperty = DESCRIPTION_PROPERTY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getDescription() <em>Description</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DESCRIPTION_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDescription() <em>Description</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected String description = DESCRIPTION_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YIconComboBoxImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YICON_COMBO_BOX;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCollectionBindingEndpoint()
+	 *         <em>Collection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint getCollectionBindingEndpoint() {
+		if (collectionBindingEndpoint != null && collectionBindingEndpoint.eIsProxy()) {
+			InternalEObject oldCollectionBindingEndpoint = (InternalEObject)collectionBindingEndpoint;
+			collectionBindingEndpoint = (YEmbeddableCollectionEndpoint)eResolveProxy(oldCollectionBindingEndpoint);
+			if (collectionBindingEndpoint != oldCollectionBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT, oldCollectionBindingEndpoint, collectionBindingEndpoint));
+			}
+		}
+		return collectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable collection endpoint
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint basicGetCollectionBindingEndpoint() {
+		return collectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCollectionBindingEndpoint
+	 *            the new collection binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetCollectionBindingEndpoint(YEmbeddableCollectionEndpoint newCollectionBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableCollectionEndpoint oldCollectionBindingEndpoint = collectionBindingEndpoint;
+		collectionBindingEndpoint = newCollectionBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT, oldCollectionBindingEndpoint, newCollectionBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCollectionBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getCollectionBindingEndpoint()
+	 *            <em>Collection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setCollectionBindingEndpoint(YEmbeddableCollectionEndpoint newCollectionBindingEndpoint) {
+		if (newCollectionBindingEndpoint != collectionBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (collectionBindingEndpoint != null)
+				msgs = ((InternalEObject)collectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT, YEmbeddableCollectionEndpoint.class, msgs);
+			if (newCollectionBindingEndpoint != null)
+				msgs = ((InternalEObject)newCollectionBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT, YEmbeddableCollectionEndpoint.class, msgs);
+			msgs = basicSetCollectionBindingEndpoint(newCollectionBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT, newCollectionBindingEndpoint, newCollectionBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSelectionBindingEndpoint()
+	 *         <em>Selection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint getSelectionBindingEndpoint() {
+		if (selectionBindingEndpoint != null && selectionBindingEndpoint.eIsProxy()) {
+			InternalEObject oldSelectionBindingEndpoint = (InternalEObject)selectionBindingEndpoint;
+			selectionBindingEndpoint = (YEmbeddableSelectionEndpoint)eResolveProxy(oldSelectionBindingEndpoint);
+			if (selectionBindingEndpoint != oldSelectionBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT, oldSelectionBindingEndpoint, selectionBindingEndpoint));
+			}
+		}
+		return selectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable selection endpoint
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint basicGetSelectionBindingEndpoint() {
+		return selectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelectionBindingEndpoint
+	 *            the new selection binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetSelectionBindingEndpoint(YEmbeddableSelectionEndpoint newSelectionBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableSelectionEndpoint oldSelectionBindingEndpoint = selectionBindingEndpoint;
+		selectionBindingEndpoint = newSelectionBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT, oldSelectionBindingEndpoint, newSelectionBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelectionBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getSelectionBindingEndpoint()
+	 *            <em>Selection Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setSelectionBindingEndpoint(YEmbeddableSelectionEndpoint newSelectionBindingEndpoint) {
+		if (newSelectionBindingEndpoint != selectionBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (selectionBindingEndpoint != null)
+				msgs = ((InternalEObject)selectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT, YEmbeddableSelectionEndpoint.class, msgs);
+			if (newSelectionBindingEndpoint != null)
+				msgs = ((InternalEObject)newSelectionBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT, YEmbeddableSelectionEndpoint.class, msgs);
+			msgs = basicSetSelectionBindingEndpoint(newSelectionBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT, newSelectionBindingEndpoint, newSelectionBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #isUseBeanService()
+	 *         <em>Use Bean Service</em>}' attribute
+	 * @generated
+	 */
+	public boolean isUseBeanService() {
+		return useBeanService;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newUseBeanService
+	 *            the new cached value of the '{@link #isUseBeanService()
+	 *            <em>Use Bean Service</em>}' attribute
+	 * @generated
+	 */
+	public void setUseBeanService(boolean newUseBeanService) {
+		boolean oldUseBeanService = useBeanService;
+		useBeanService = newUseBeanService;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE, oldUseBeanService, useBeanService));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDatadescription()
+	 *         <em>Datadescription</em>}' reference
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YICON_COMBO_BOX__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y datadescription
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDatadescription
+	 *            the new cached value of the '{@link #getDatadescription()
+	 *            <em>Datadescription</em>}' reference
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDatatype() <em>Datatype</em>}
+	 *         ' reference
+	 * @generated
+	 */
+	public YComboBoxDatatype getDatatype() {
+		if (datatype != null && datatype.eIsProxy()) {
+			InternalEObject oldDatatype = (InternalEObject)datatype;
+			datatype = (YComboBoxDatatype)eResolveProxy(oldDatatype);
+			if (datatype != oldDatatype) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YICON_COMBO_BOX__DATATYPE, oldDatatype, datatype));
+			}
+		}
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y combo box datatype
+	 * @generated
+	 */
+	public YComboBoxDatatype basicGetDatatype() {
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDatatype
+	 *            the new cached value of the '{@link #getDatatype()
+	 *            <em>Datatype</em>}' reference
+	 * @generated
+	 */
+	public void setDatatype(YComboBoxDatatype newDatatype) {
+		YComboBoxDatatype oldDatatype = datatype;
+		datatype = newDatatype;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__DATATYPE, oldDatatype, datatype));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSelection()
+	 *         <em>Selection</em>}' attribute
+	 * @generated
+	 */
+	public Object getSelection() {
+		return selection;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSelection
+	 *            the new cached value of the '{@link #getSelection()
+	 *            <em>Selection</em>}' attribute
+	 * @generated
+	 */
+	public void setSelection(Object newSelection) {
+		Object oldSelection = selection;
+		selection = newSelection;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__SELECTION, oldSelection, selection));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getType() <em>Type</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newType
+	 *            the new cached value of the '{@link #getType() <em>Type</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getEmfNsURI()
+	 *         <em>Emf Ns URI</em>}' attribute
+	 * @generated
+	 */
+	public String getEmfNsURI() {
+		return emfNsURI;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newEmfNsURI
+	 *            the new cached value of the '{@link #getEmfNsURI()
+	 *            <em>Emf Ns URI</em>}' attribute
+	 * @generated
+	 */
+	public void setEmfNsURI(String newEmfNsURI) {
+		String oldEmfNsURI = emfNsURI;
+		emfNsURI = newEmfNsURI;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__EMF_NS_URI, oldEmfNsURI, emfNsURI));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTypeQualifiedName()
+	 *         <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTypeQualifiedName
+	 *            the new cached value of the '{@link #getTypeQualifiedName()
+	 *            <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCaptionProperty()
+	 *         <em>Caption Property</em>}' attribute
+	 * @generated
+	 */
+	public String getCaptionProperty() {
+		return captionProperty;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newCaptionProperty
+	 *            the new cached value of the '{@link #getCaptionProperty()
+	 *            <em>Caption Property</em>}' attribute
+	 * @generated
+	 */
+	public void setCaptionProperty(String newCaptionProperty) {
+		String oldCaptionProperty = captionProperty;
+		captionProperty = newCaptionProperty;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__CAPTION_PROPERTY, oldCaptionProperty, captionProperty));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getImageProperty()
+	 *         <em>Image Property</em>}' attribute
+	 * @generated
+	 */
+	public String getImageProperty() {
+		return imageProperty;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newImageProperty
+	 *            the new cached value of the '{@link #getImageProperty()
+	 *            <em>Image Property</em>}' attribute
+	 * @generated
+	 */
+	public void setImageProperty(String newImageProperty) {
+		String oldImageProperty = imageProperty;
+		imageProperty = newImageProperty;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__IMAGE_PROPERTY, oldImageProperty, imageProperty));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDescriptionProperty()
+	 *         <em>Description Property</em>}' attribute
+	 * @generated
+	 */
+	public String getDescriptionProperty() {
+		return descriptionProperty;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDescriptionProperty
+	 *            the new cached value of the '{@link #getDescriptionProperty()
+	 *            <em>Description Property</em>}' attribute
+	 * @generated
+	 */
+	public void setDescriptionProperty(String newDescriptionProperty) {
+		String oldDescriptionProperty = descriptionProperty;
+		descriptionProperty = newDescriptionProperty;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__DESCRIPTION_PROPERTY, oldDescriptionProperty, descriptionProperty));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDescription()
+	 *         <em>Description</em>}' attribute
+	 * @generated
+	 */
+	public String getDescription() {
+		return description;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDescription
+	 *            the new cached value of the '{@link #getDescription()
+	 *            <em>Description</em>}' attribute
+	 * @generated
+	 */
+	public void setDescription(String newDescription) {
+		String oldDescription = description;
+		description = newDescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YICON_COMBO_BOX__DESCRIPTION, oldDescription, description));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable selection endpoint
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint createSelectionEndpointGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable collection endpoint
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint createCollectionEndpointGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Creates a new instance of selection endpoint with a reference to that
+	 * embeddable.
+	 *
+	 * @return the y embeddable selection endpoint
+	 * @generated NOT
+	 */
+	public YEmbeddableSelectionEndpoint createSelectionEndpoint() {
+		YEmbeddableSelectionEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableSelectionEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * Creates a new instance of collection endpoint with a reference to that
+	 * embeddable.
+	 *
+	 * @return the y embeddable collection endpoint
+	 * @generated NOT
+	 */
+	public YEmbeddableCollectionEndpoint createCollectionEndpoint() {
+		YEmbeddableCollectionEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableCollectionEndpoint();
+		ep.setElement(this);
+		return ep;
+
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+				if (collectionBindingEndpoint != null)
+					msgs = ((InternalEObject)collectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT, YEmbeddableCollectionEndpoint.class, msgs);
+				return basicSetCollectionBindingEndpoint((YEmbeddableCollectionEndpoint)otherEnd, msgs);
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+				if (selectionBindingEndpoint != null)
+					msgs = ((InternalEObject)selectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT, YEmbeddableSelectionEndpoint.class, msgs);
+				return basicSetSelectionBindingEndpoint((YEmbeddableSelectionEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+				return basicSetCollectionBindingEndpoint(null, msgs);
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+				return basicSetSelectionBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+				if (resolve) return getCollectionBindingEndpoint();
+				return basicGetCollectionBindingEndpoint();
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+				if (resolve) return getSelectionBindingEndpoint();
+				return basicGetSelectionBindingEndpoint();
+			case YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE:
+				return isUseBeanService();
+			case YECviewPackage.YICON_COMBO_BOX__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YICON_COMBO_BOX__DATATYPE:
+				if (resolve) return getDatatype();
+				return basicGetDatatype();
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION:
+				return getSelection();
+			case YECviewPackage.YICON_COMBO_BOX__TYPE:
+				return getType();
+			case YECviewPackage.YICON_COMBO_BOX__EMF_NS_URI:
+				return getEmfNsURI();
+			case YECviewPackage.YICON_COMBO_BOX__TYPE_QUALIFIED_NAME:
+				return getTypeQualifiedName();
+			case YECviewPackage.YICON_COMBO_BOX__CAPTION_PROPERTY:
+				return getCaptionProperty();
+			case YECviewPackage.YICON_COMBO_BOX__IMAGE_PROPERTY:
+				return getImageProperty();
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION_PROPERTY:
+				return getDescriptionProperty();
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION:
+				return getDescription();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+				setCollectionBindingEndpoint((YEmbeddableCollectionEndpoint)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+				setSelectionBindingEndpoint((YEmbeddableSelectionEndpoint)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE:
+				setUseBeanService((Boolean)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DATATYPE:
+				setDatatype((YComboBoxDatatype)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION:
+				setSelection(newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__TYPE:
+				setType((Class<?>)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__EMF_NS_URI:
+				setEmfNsURI((String)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName((String)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__CAPTION_PROPERTY:
+				setCaptionProperty((String)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__IMAGE_PROPERTY:
+				setImageProperty((String)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION_PROPERTY:
+				setDescriptionProperty((String)newValue);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION:
+				setDescription((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+				setCollectionBindingEndpoint((YEmbeddableCollectionEndpoint)null);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+				setSelectionBindingEndpoint((YEmbeddableSelectionEndpoint)null);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE:
+				setUseBeanService(USE_BEAN_SERVICE_EDEFAULT);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DATATYPE:
+				setDatatype((YComboBoxDatatype)null);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION:
+				setSelection(SELECTION_EDEFAULT);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__TYPE:
+				setType((Class<?>)null);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__EMF_NS_URI:
+				setEmfNsURI(EMF_NS_URI_EDEFAULT);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__CAPTION_PROPERTY:
+				setCaptionProperty(CAPTION_PROPERTY_EDEFAULT);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__IMAGE_PROPERTY:
+				setImageProperty(IMAGE_PROPERTY_EDEFAULT);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION_PROPERTY:
+				setDescriptionProperty(DESCRIPTION_PROPERTY_EDEFAULT);
+				return;
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION:
+				setDescription(DESCRIPTION_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+				return collectionBindingEndpoint != null;
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+				return selectionBindingEndpoint != null;
+			case YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE:
+				return useBeanService != USE_BEAN_SERVICE_EDEFAULT;
+			case YECviewPackage.YICON_COMBO_BOX__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YICON_COMBO_BOX__DATATYPE:
+				return datatype != null;
+			case YECviewPackage.YICON_COMBO_BOX__SELECTION:
+				return SELECTION_EDEFAULT == null ? selection != null : !SELECTION_EDEFAULT.equals(selection);
+			case YECviewPackage.YICON_COMBO_BOX__TYPE:
+				return type != null;
+			case YECviewPackage.YICON_COMBO_BOX__EMF_NS_URI:
+				return EMF_NS_URI_EDEFAULT == null ? emfNsURI != null : !EMF_NS_URI_EDEFAULT.equals(emfNsURI);
+			case YECviewPackage.YICON_COMBO_BOX__TYPE_QUALIFIED_NAME:
+				return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+			case YECviewPackage.YICON_COMBO_BOX__CAPTION_PROPERTY:
+				return CAPTION_PROPERTY_EDEFAULT == null ? captionProperty != null : !CAPTION_PROPERTY_EDEFAULT.equals(captionProperty);
+			case YECviewPackage.YICON_COMBO_BOX__IMAGE_PROPERTY:
+				return IMAGE_PROPERTY_EDEFAULT == null ? imageProperty != null : !IMAGE_PROPERTY_EDEFAULT.equals(imageProperty);
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION_PROPERTY:
+				return DESCRIPTION_PROPERTY_EDEFAULT == null ? descriptionProperty != null : !DESCRIPTION_PROPERTY_EDEFAULT.equals(descriptionProperty);
+			case YECviewPackage.YICON_COMBO_BOX__DESCRIPTION:
+				return DESCRIPTION_EDEFAULT == null ? description != null : !DESCRIPTION_EDEFAULT.equals(description);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param derivedFeatureID
+	 *            the derived feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YCollectionBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT: return CoreModelPackage.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YSelectionBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT: return CoreModelPackage.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YBeanServiceConsumer.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE: return ExtensionModelPackage.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param baseFeatureID
+	 *            the base feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YCollectionBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT: return YECviewPackage.YICON_COMBO_BOX__COLLECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YSelectionBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT: return YECviewPackage.YICON_COMBO_BOX__SELECTION_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		if (baseClass == YBeanServiceConsumer.class) {
+			switch (baseFeatureID) {
+				case ExtensionModelPackage.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE: return YECviewPackage.YICON_COMBO_BOX__USE_BEAN_SERVICE;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (useBeanService: ");
+		result.append(useBeanService);
+		result.append(", selection: ");
+		result.append(selection);
+		result.append(", type: ");
+		result.append(type);
+		result.append(", emfNsURI: ");
+		result.append(emfNsURI);
+		result.append(", typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(", captionProperty: ");
+		result.append(captionProperty);
+		result.append(", imageProperty: ");
+		result.append(imageProperty);
+		result.append(", descriptionProperty: ");
+		result.append(descriptionProperty);
+		result.append(", description: ");
+		result.append(description);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YLayoutingInfoImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YLayoutingInfoImpl.java
new file mode 100644
index 0000000..4f176c3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YLayoutingInfoImpl.java
@@ -0,0 +1,670 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YLayouting Info</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getLayout <em>Layout</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getContent <em>Content</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getActiveSuspectInfos <em>Active Suspect Infos</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl#getFirstFocus <em>First Focus</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YLayoutingInfoImpl extends MinimalEObjectImpl.Container implements YLayoutingInfo {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getLayout() <em>Layout</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLayout()
+	 * @generated
+	 * @ordered
+	 */
+	protected YStrategyLayout layout;
+
+	/**
+	 * The cached value of the '{@link #getContent() <em>Content</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getContent()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddable content;
+
+	/**
+	 * The cached value of the '{@link #getActiveSuspectInfos() <em>Active Suspect Infos</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getActiveSuspectInfos()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YSuspectInfo> activeSuspectInfos;
+
+	/**
+	 * The cached value of the '{@link #getFirstFocus() <em>First Focus</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getFirstFocus()
+	 * @generated
+	 * @ordered
+	 */
+	protected YSuspectInfo firstFocus;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YLayoutingInfoImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YLAYOUTING_INFO;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_INFO__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_INFO__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YECviewPackage.YLAYOUTING_INFO__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YECviewPackage.YLAYOUTING_INFO__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLayout() <em>Layout</em>}'
+	 *         reference
+	 * @generated
+	 */
+	public YStrategyLayout getLayout() {
+		if (layout != null && layout.eIsProxy()) {
+			InternalEObject oldLayout = (InternalEObject)layout;
+			layout = (YStrategyLayout)eResolveProxy(oldLayout);
+			if (layout != oldLayout) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YLAYOUTING_INFO__LAYOUT, oldLayout, layout));
+			}
+		}
+		return layout;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y strategy layout
+	 * @generated
+	 */
+	public YStrategyLayout basicGetLayout() {
+		return layout;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLayout
+	 *            the new cached value of the '{@link #getLayout()
+	 *            <em>Layout</em>}' reference
+	 * @generated
+	 */
+	public void setLayout(YStrategyLayout newLayout) {
+		YStrategyLayout oldLayout = layout;
+		layout = newLayout;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_INFO__LAYOUT, oldLayout, layout));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getContent() <em>Content</em>}'
+	 *         containment reference
+	 * @generated
+	 */
+	public YEmbeddable getContent() {
+		return content;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newContent
+	 *            the new content
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetContent(YEmbeddable newContent, NotificationChain msgs) {
+		YEmbeddable oldContent = content;
+		content = newContent;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_INFO__CONTENT, oldContent, newContent);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newContent
+	 *            the new cached value of the '{@link #getContent()
+	 *            <em>Content</em>}' containment reference
+	 * @generated
+	 */
+	public void setContent(YEmbeddable newContent) {
+		if (newContent != content) {
+			NotificationChain msgs = null;
+			if (content != null)
+				msgs = ((InternalEObject)content).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YLAYOUTING_INFO__CONTENT, null, msgs);
+			if (newContent != null)
+				msgs = ((InternalEObject)newContent).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YLAYOUTING_INFO__CONTENT, null, msgs);
+			msgs = basicSetContent(newContent, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_INFO__CONTENT, newContent, newContent));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getActiveSuspectInfos()
+	 *         <em>Active Suspect Infos</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<YSuspectInfo> getActiveSuspectInfos() {
+		if (activeSuspectInfos == null) {
+			activeSuspectInfos = new EObjectContainmentEList<YSuspectInfo>(YSuspectInfo.class, this, YECviewPackage.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS);
+		}
+		return activeSuspectInfos;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getFirstFocus()
+	 *         <em>First Focus</em>}' reference
+	 * @generated
+	 */
+	public YSuspectInfo getFirstFocus() {
+		if (firstFocus != null && firstFocus.eIsProxy()) {
+			InternalEObject oldFirstFocus = (InternalEObject)firstFocus;
+			firstFocus = (YSuspectInfo)eResolveProxy(oldFirstFocus);
+			if (firstFocus != oldFirstFocus) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YLAYOUTING_INFO__FIRST_FOCUS, oldFirstFocus, firstFocus));
+			}
+		}
+		return firstFocus;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info
+	 * @generated
+	 */
+	public YSuspectInfo basicGetFirstFocus() {
+		return firstFocus;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newFirstFocus
+	 *            the new cached value of the '{@link #getFirstFocus()
+	 *            <em>First Focus</em>}' reference
+	 * @generated
+	 */
+	public void setFirstFocus(YSuspectInfo newFirstFocus) {
+		YSuspectInfo oldFirstFocus = firstFocus;
+		firstFocus = newFirstFocus;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_INFO__FIRST_FOCUS, oldFirstFocus, firstFocus));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_INFO__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YLAYOUTING_INFO__CONTENT:
+				return basicSetContent(null, msgs);
+			case YECviewPackage.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS:
+				return ((InternalEList<?>)getActiveSuspectInfos()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_INFO__TAGS:
+				return getTags();
+			case YECviewPackage.YLAYOUTING_INFO__ID:
+				return getId();
+			case YECviewPackage.YLAYOUTING_INFO__NAME:
+				return getName();
+			case YECviewPackage.YLAYOUTING_INFO__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YECviewPackage.YLAYOUTING_INFO__LAYOUT:
+				if (resolve) return getLayout();
+				return basicGetLayout();
+			case YECviewPackage.YLAYOUTING_INFO__CONTENT:
+				return getContent();
+			case YECviewPackage.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS:
+				return getActiveSuspectInfos();
+			case YECviewPackage.YLAYOUTING_INFO__FIRST_FOCUS:
+				if (resolve) return getFirstFocus();
+				return basicGetFirstFocus();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_INFO__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__ID:
+				setId((String)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__NAME:
+				setName((String)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__LAYOUT:
+				setLayout((YStrategyLayout)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__CONTENT:
+				setContent((YEmbeddable)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS:
+				getActiveSuspectInfos().clear();
+				getActiveSuspectInfos().addAll((Collection<? extends YSuspectInfo>)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__FIRST_FOCUS:
+				setFirstFocus((YSuspectInfo)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_INFO__TAGS:
+				getTags().clear();
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__LAYOUT:
+				setLayout((YStrategyLayout)null);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__CONTENT:
+				setContent((YEmbeddable)null);
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS:
+				getActiveSuspectInfos().clear();
+				return;
+			case YECviewPackage.YLAYOUTING_INFO__FIRST_FOCUS:
+				setFirstFocus((YSuspectInfo)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_INFO__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YECviewPackage.YLAYOUTING_INFO__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YECviewPackage.YLAYOUTING_INFO__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YECviewPackage.YLAYOUTING_INFO__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YECviewPackage.YLAYOUTING_INFO__LAYOUT:
+				return layout != null;
+			case YECviewPackage.YLAYOUTING_INFO__CONTENT:
+				return content != null;
+			case YECviewPackage.YLAYOUTING_INFO__ACTIVE_SUSPECT_INFOS:
+				return activeSuspectInfos != null && !activeSuspectInfos.isEmpty();
+			case YECviewPackage.YLAYOUTING_INFO__FIRST_FOCUS:
+				return firstFocus != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+	/**
+	 * Creates the suspect info.
+	 *
+	 * @param suspect
+	 *            the suspect
+	 * @return the y suspect info
+	 * @generated NOT
+	 */
+	@Override
+	public YSuspectInfo createSuspectInfo(YSuspect suspect) {
+		YSuspectInfo result = YECviewFactory.eINSTANCE.createYSuspectInfo();
+		result.setSuspect(suspect);
+		return result;
+	}
+	
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 * @generated NOT
+	 */
+	public YView getView() {
+		return findViewGeneric(getLayout());
+	}
+	
+	/**
+	 * Find view generic.
+	 *
+	 * @param container
+	 *            the container
+	 * @return the y view
+	 * @generated NOT
+	 */
+	protected YView findViewGeneric(EObject container) {
+		if (container == null) {
+			return null;
+		}
+		if (container instanceof YView) {
+			return (YView) container;
+		} else if (container instanceof YLayout) {
+			return ((YLayout) container).getView();
+		} else {
+			EObject parent = container.eContainer();
+			return findViewGeneric(parent);
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YLayoutingStrategyImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YLayoutingStrategyImpl.java
new file mode 100644
index 0000000..0f3782a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YLayoutingStrategyImpl.java
@@ -0,0 +1,474 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YLayouting Strategy</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl#getTrigger <em>Trigger</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YLayoutingStrategyImpl extends MinimalEObjectImpl.Container implements YLayoutingStrategy {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getTrigger() <em>Trigger</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTrigger()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Object TRIGGER_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTrigger() <em>Trigger</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTrigger()
+	 * @generated
+	 * @ordered
+	 */
+	protected Object trigger = TRIGGER_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YLayoutingStrategyImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YLAYOUTING_STRATEGY;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_STRATEGY__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_STRATEGY__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YECviewPackage.YLAYOUTING_STRATEGY__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YECviewPackage.YLAYOUTING_STRATEGY__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTrigger() <em>Trigger</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Object getTrigger() {
+		return trigger;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTrigger
+	 *            the new cached value of the '{@link #getTrigger()
+	 *            <em>Trigger</em>}' attribute
+	 * @generated
+	 */
+	public void setTrigger(Object newTrigger) {
+		Object oldTrigger = trigger;
+		trigger = newTrigger;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YLAYOUTING_STRATEGY__TRIGGER, oldTrigger, trigger));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the view gen
+	 * @generated
+	 */
+	public YView getViewGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+	
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 * @generated NOT
+	 */
+	public YView getView() {
+		return findViewGeneric(eContainer());
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_STRATEGY__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * Find view generic.
+	 *
+	 * @param container
+	 *            the container
+	 * @return the y view
+	 * @generated NOT
+	 */
+	protected YView findViewGeneric(EObject container) {
+		if (container == null) {
+			return null;
+		}
+		if (container instanceof YView) {
+			return (YView) container;
+		} else if (container instanceof YLayout) {
+			return ((YLayout) container).getView();
+		} else {
+			EObject parent = container.eContainer();
+			return findViewGeneric(parent);
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_STRATEGY__TAGS:
+				return getTags();
+			case YECviewPackage.YLAYOUTING_STRATEGY__ID:
+				return getId();
+			case YECviewPackage.YLAYOUTING_STRATEGY__NAME:
+				return getName();
+			case YECviewPackage.YLAYOUTING_STRATEGY__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YECviewPackage.YLAYOUTING_STRATEGY__TRIGGER:
+				return getTrigger();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_STRATEGY__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__ID:
+				setId((String)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__NAME:
+				setName((String)newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__TRIGGER:
+				setTrigger(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_STRATEGY__TAGS:
+				getTags().clear();
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YECviewPackage.YLAYOUTING_STRATEGY__TRIGGER:
+				setTrigger(TRIGGER_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YLAYOUTING_STRATEGY__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YECviewPackage.YLAYOUTING_STRATEGY__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YECviewPackage.YLAYOUTING_STRATEGY__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YECviewPackage.YLAYOUTING_STRATEGY__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YECviewPackage.YLAYOUTING_STRATEGY__TRIGGER:
+				return TRIGGER_EDEFAULT == null ? trigger != null : !TRIGGER_EDEFAULT.equals(trigger);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", trigger: ");
+		result.append(trigger);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedDecimalFieldImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedDecimalFieldImpl.java
new file mode 100644
index 0000000..28d529f
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedDecimalFieldImpl.java
@@ -0,0 +1,620 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YMasked Decimal Field</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl#getMask <em>Mask</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl#getDecimalSeparator <em>Decimal Separator</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedDecimalFieldImpl#getGroupingSeparator <em>Grouping Separator</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YMaskedDecimalFieldImpl extends YInputImpl implements YMaskedDecimalField {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Number VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected Number value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String MASK_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected String mask = MASK_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getDecimalSeparator() <em>Decimal Separator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDecimalSeparator()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Character DECIMAL_SEPARATOR_EDEFAULT = new Character('n');
+
+	/**
+	 * The cached value of the '{@link #getDecimalSeparator() <em>Decimal Separator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDecimalSeparator()
+	 * @generated
+	 * @ordered
+	 */
+	protected Character decimalSeparator = DECIMAL_SEPARATOR_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getGroupingSeparator() <em>Grouping Separator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGroupingSeparator()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Character GROUPING_SEPARATOR_EDEFAULT = new Character('n');
+
+	/**
+	 * The cached value of the '{@link #getGroupingSeparator() <em>Grouping Separator</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGroupingSeparator()
+	 * @generated
+	 * @ordered
+	 */
+	protected Character groupingSeparator = GROUPING_SEPARATOR_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YMaskedDecimalFieldImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YMASKED_DECIMAL_FIELD;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YMASKED_DECIMAL_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_DECIMAL_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Number getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValue(Number newValue) {
+		Number oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getMask() {
+		return mask;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMask(String newMask) {
+		String oldMask = mask;
+		mask = newMask;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_DECIMAL_FIELD__MASK, oldMask, mask));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Character getDecimalSeparator() {
+		return decimalSeparator;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setDecimalSeparator(Character newDecimalSeparator) {
+		Character oldDecimalSeparator = decimalSeparator;
+		decimalSeparator = newDecimalSeparator;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR, oldDecimalSeparator, decimalSeparator));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Character getGroupingSeparator() {
+		return groupingSeparator;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setGroupingSeparator(Character newGroupingSeparator) {
+		Character oldGroupingSeparator = groupingSeparator;
+		groupingSeparator = newGroupingSeparator;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR, oldGroupingSeparator, groupingSeparator));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		YEmbeddableValueEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableValueEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE:
+				return getValue();
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__MASK:
+				return getMask();
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR:
+				return getDecimalSeparator();
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR:
+				return getGroupingSeparator();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE:
+				setValue((Number)newValue);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__MASK:
+				setMask((String)newValue);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR:
+				setDecimalSeparator((Character)newValue);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR:
+				setGroupingSeparator((Character)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__MASK:
+				setMask(MASK_EDEFAULT);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR:
+				setDecimalSeparator(DECIMAL_SEPARATOR_EDEFAULT);
+				return;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR:
+				setGroupingSeparator(GROUPING_SEPARATOR_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__MASK:
+				return MASK_EDEFAULT == null ? mask != null : !MASK_EDEFAULT.equals(mask);
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__DECIMAL_SEPARATOR:
+				return DECIMAL_SEPARATOR_EDEFAULT == null ? decimalSeparator != null : !DECIMAL_SEPARATOR_EDEFAULT.equals(decimalSeparator);
+			case YECviewPackage.YMASKED_DECIMAL_FIELD__GROUPING_SEPARATOR:
+				return GROUPING_SEPARATOR_EDEFAULT == null ? groupingSeparator != null : !GROUPING_SEPARATOR_EDEFAULT.equals(groupingSeparator);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YMASKED_DECIMAL_FIELD__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(", mask: ");
+		result.append(mask);
+		result.append(", decimalSeparator: ");
+		result.append(decimalSeparator);
+		result.append(", groupingSeparator: ");
+		result.append(groupingSeparator);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+
+} //YMaskedDecimalFieldImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedNumericFieldImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedNumericFieldImpl.java
new file mode 100644
index 0000000..c4d16a6
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedNumericFieldImpl.java
@@ -0,0 +1,513 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YMaskedNumericField;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YMasked Numeric Field</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedNumericFieldImpl#getMask <em>Mask</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YMaskedNumericFieldImpl extends YInputImpl implements YMaskedNumericField {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Number VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected Number value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String MASK_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected String mask = MASK_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YMaskedNumericFieldImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YMASKED_NUMERIC_FIELD;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YMASKED_NUMERIC_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_NUMERIC_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Number getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValue(Number newValue) {
+		Number oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getMask() {
+		return mask;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMask(String newMask) {
+		String oldMask = mask;
+		mask = newMask;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_NUMERIC_FIELD__MASK, oldMask, mask));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		YEmbeddableValueEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableValueEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE:
+				return getValue();
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__MASK:
+				return getMask();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE:
+				setValue((Number)newValue);
+				return;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__MASK:
+				setMask((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__MASK:
+				setMask(MASK_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+			case YECviewPackage.YMASKED_NUMERIC_FIELD__MASK:
+				return MASK_EDEFAULT == null ? mask != null : !MASK_EDEFAULT.equals(mask);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YMASKED_NUMERIC_FIELD__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(", mask: ");
+		result.append(mask);
+		result.append(')');
+		return result.toString();
+	}
+	
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+
+} //YMaskedNumericFieldImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedTextFieldImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedTextFieldImpl.java
new file mode 100644
index 0000000..be85e18
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YMaskedTextFieldImpl.java
@@ -0,0 +1,513 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YMaskedTextField;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YMasked Text Field</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YMaskedTextFieldImpl#getMask <em>Mask</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YMaskedTextFieldImpl extends YInputImpl implements YMaskedTextField {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected String value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String MASK_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected String mask = MASK_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YMaskedTextFieldImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YMASKED_TEXT_FIELD;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YMASKED_TEXT_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_TEXT_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValue(String newValue) {
+		String oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_TEXT_FIELD__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getMask() {
+		return mask;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMask(String newMask) {
+		String oldMask = mask;
+		mask = newMask;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YMASKED_TEXT_FIELD__MASK, oldMask, mask));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		YEmbeddableValueEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableValueEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YMASKED_TEXT_FIELD__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE:
+				return getValue();
+			case YECviewPackage.YMASKED_TEXT_FIELD__MASK:
+				return getMask();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YMASKED_TEXT_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE:
+				setValue((String)newValue);
+				return;
+			case YECviewPackage.YMASKED_TEXT_FIELD__MASK:
+				setMask((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YMASKED_TEXT_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YECviewPackage.YMASKED_TEXT_FIELD__MASK:
+				setMask(MASK_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YMASKED_TEXT_FIELD__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YMASKED_TEXT_FIELD__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+			case YECviewPackage.YMASKED_TEXT_FIELD__MASK:
+				return MASK_EDEFAULT == null ? mask != null : !MASK_EDEFAULT.equals(mask);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YMASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(", mask: ");
+		result.append(mask);
+		result.append(')');
+		return result.toString();
+	}
+
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+	
+} //YMaskedTextFieldImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YPairComboBoxImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YPairComboBoxImpl.java
new file mode 100644
index 0000000..d667a21
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YPairComboBoxImpl.java
@@ -0,0 +1,1155 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableCollectionEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableSelectionEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YComboBoxDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YPairComboBox;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>YPair Combo Box</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getCollectionBindingEndpoint <em>Collection Binding Endpoint</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getSelectionBindingEndpoint <em>Selection Binding Endpoint</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#isUseBeanService <em>Use Bean Service</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getDatadescription <em>Datadescription</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getDatatype <em>Datatype</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getSelection <em>Selection</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getCollection <em>Collection</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getType <em>Type</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getEmfNsURI <em>Emf Ns URI</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getCaptionProperty <em>Caption Property</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getImageProperty <em>Image Property</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getDescriptionProperty <em>Description Property</em>}</li>
+ * <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPairComboBoxImpl#getDescription <em>Description</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YPairComboBoxImpl extends YInputImpl implements YPairComboBox {
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getCollectionBindingEndpoint() <em>Collection Binding Endpoint</em>}' reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getCollectionBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableCollectionEndpoint collectionBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getSelectionBindingEndpoint() <em>Selection Binding Endpoint</em>}' reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getSelectionBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableSelectionEndpoint selectionBindingEndpoint;
+
+	/**
+	 * The default value of the '{@link #isUseBeanService() <em>Use Bean Service</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #isUseBeanService()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean USE_BEAN_SERVICE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isUseBeanService() <em>Use Bean Service</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #isUseBeanService()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean useBeanService = USE_BEAN_SERVICE_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The cached value of the '{@link #getDatatype() <em>Datatype</em>}' reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getDatatype()
+	 * @generated
+	 * @ordered
+	 */
+	protected YComboBoxDatatype datatype;
+
+	/**
+	 * The default value of the '{@link #getSelection() <em>Selection</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getSelection()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Object SELECTION_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getSelection() <em>Selection</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getSelection()
+	 * @generated
+	 * @ordered
+	 */
+	protected Object selection = SELECTION_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getCollection() <em>Collection</em>}' attribute list. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getCollection()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Object> collection;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * The default value of the '{@link #getEmfNsURI() <em>Emf Ns URI</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getEmfNsURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String EMF_NS_URI_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getEmfNsURI() <em>Emf Ns URI</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getEmfNsURI()
+	 * @generated
+	 * @ordered
+	 */
+	protected String emfNsURI = EMF_NS_URI_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getCaptionProperty() <em>Caption Property</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getCaptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String CAPTION_PROPERTY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getCaptionProperty() <em>Caption Property</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getCaptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected String captionProperty = CAPTION_PROPERTY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getImageProperty() <em>Image Property</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getImageProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String IMAGE_PROPERTY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getImageProperty() <em>Image Property</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getImageProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected String imageProperty = IMAGE_PROPERTY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getDescriptionProperty() <em>Description Property</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getDescriptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DESCRIPTION_PROPERTY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDescriptionProperty() <em>Description Property</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getDescriptionProperty()
+	 * @generated
+	 * @ordered
+	 */
+	protected String descriptionProperty = DESCRIPTION_PROPERTY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getDescription() <em>Description</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getDescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DESCRIPTION_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDescription() <em>Description</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #getDescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected String description = DESCRIPTION_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected YPairComboBoxImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YPAIR_COMBO_BOX;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint getCollectionBindingEndpoint() {
+		if (collectionBindingEndpoint != null && collectionBindingEndpoint.eIsProxy()) {
+			InternalEObject oldCollectionBindingEndpoint = (InternalEObject) collectionBindingEndpoint;
+			collectionBindingEndpoint = (YEmbeddableCollectionEndpoint) eResolveProxy(oldCollectionBindingEndpoint);
+			if (collectionBindingEndpoint != oldCollectionBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT, oldCollectionBindingEndpoint,
+							collectionBindingEndpoint));
+			}
+		}
+		return collectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint basicGetCollectionBindingEndpoint() {
+		return collectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public NotificationChain basicSetCollectionBindingEndpoint(YEmbeddableCollectionEndpoint newCollectionBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableCollectionEndpoint oldCollectionBindingEndpoint = collectionBindingEndpoint;
+		collectionBindingEndpoint = newCollectionBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT,
+					oldCollectionBindingEndpoint, newCollectionBindingEndpoint);
+			if (msgs == null)
+				msgs = notification;
+			else
+				msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setCollectionBindingEndpoint(YEmbeddableCollectionEndpoint newCollectionBindingEndpoint) {
+		if (newCollectionBindingEndpoint != collectionBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (collectionBindingEndpoint != null)
+				msgs = ((InternalEObject) collectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT,
+						YEmbeddableCollectionEndpoint.class, msgs);
+			if (newCollectionBindingEndpoint != null)
+				msgs = ((InternalEObject) newCollectionBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT,
+						YEmbeddableCollectionEndpoint.class, msgs);
+			msgs = basicSetCollectionBindingEndpoint(newCollectionBindingEndpoint, msgs);
+			if (msgs != null)
+				msgs.dispatch();
+		} else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT, newCollectionBindingEndpoint,
+					newCollectionBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint getSelectionBindingEndpoint() {
+		if (selectionBindingEndpoint != null && selectionBindingEndpoint.eIsProxy()) {
+			InternalEObject oldSelectionBindingEndpoint = (InternalEObject) selectionBindingEndpoint;
+			selectionBindingEndpoint = (YEmbeddableSelectionEndpoint) eResolveProxy(oldSelectionBindingEndpoint);
+			if (selectionBindingEndpoint != oldSelectionBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT, oldSelectionBindingEndpoint,
+							selectionBindingEndpoint));
+			}
+		}
+		return selectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint basicGetSelectionBindingEndpoint() {
+		return selectionBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public NotificationChain basicSetSelectionBindingEndpoint(YEmbeddableSelectionEndpoint newSelectionBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableSelectionEndpoint oldSelectionBindingEndpoint = selectionBindingEndpoint;
+		selectionBindingEndpoint = newSelectionBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT, oldSelectionBindingEndpoint,
+					newSelectionBindingEndpoint);
+			if (msgs == null)
+				msgs = notification;
+			else
+				msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setSelectionBindingEndpoint(YEmbeddableSelectionEndpoint newSelectionBindingEndpoint) {
+		if (newSelectionBindingEndpoint != selectionBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (selectionBindingEndpoint != null)
+				msgs = ((InternalEObject) selectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT,
+						YEmbeddableSelectionEndpoint.class, msgs);
+			if (newSelectionBindingEndpoint != null)
+				msgs = ((InternalEObject) newSelectionBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT,
+						YEmbeddableSelectionEndpoint.class, msgs);
+			msgs = basicSetSelectionBindingEndpoint(newSelectionBindingEndpoint, msgs);
+			if (msgs != null)
+				msgs.dispatch();
+		} else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT, newSelectionBindingEndpoint,
+					newSelectionBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public boolean isUseBeanService() {
+		return useBeanService;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setUseBeanService(boolean newUseBeanService) {
+		boolean oldUseBeanService = useBeanService;
+		useBeanService = newUseBeanService;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE, oldUseBeanService, useBeanService));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject) datadescription;
+			datadescription = (YDatadescription) eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YPAIR_COMBO_BOX__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YComboBoxDatatype getDatatype() {
+		if (datatype != null && datatype.eIsProxy()) {
+			InternalEObject oldDatatype = (InternalEObject) datatype;
+			datatype = (YComboBoxDatatype) eResolveProxy(oldDatatype);
+			if (datatype != oldDatatype) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YPAIR_COMBO_BOX__DATATYPE, oldDatatype, datatype));
+			}
+		}
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public YComboBoxDatatype basicGetDatatype() {
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setDatatype(YComboBoxDatatype newDatatype) {
+		YComboBoxDatatype oldDatatype = datatype;
+		datatype = newDatatype;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__DATATYPE, oldDatatype, datatype));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public Object getSelection() {
+		return selection;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setSelection(Object newSelection) {
+		Object oldSelection = selection;
+		selection = newSelection;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__SELECTION, oldSelection, selection));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public EList<Object> getCollection() {
+		if (collection == null) {
+			collection = new EDataTypeUniqueEList<Object>(Object.class, this, YECviewPackage.YPAIR_COMBO_BOX__COLLECTION);
+		}
+		return collection;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public String getEmfNsURI() {
+		return emfNsURI;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setEmfNsURI(String newEmfNsURI) {
+		String oldEmfNsURI = emfNsURI;
+		emfNsURI = newEmfNsURI;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__EMF_NS_URI, oldEmfNsURI, emfNsURI));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public String getCaptionProperty() {
+		return captionProperty;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setCaptionProperty(String newCaptionProperty) {
+		String oldCaptionProperty = captionProperty;
+		captionProperty = newCaptionProperty;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__CAPTION_PROPERTY, oldCaptionProperty, captionProperty));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public String getImageProperty() {
+		return imageProperty;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setImageProperty(String newImageProperty) {
+		String oldImageProperty = imageProperty;
+		imageProperty = newImageProperty;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__IMAGE_PROPERTY, oldImageProperty, imageProperty));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public String getDescriptionProperty() {
+		return descriptionProperty;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setDescriptionProperty(String newDescriptionProperty) {
+		String oldDescriptionProperty = descriptionProperty;
+		descriptionProperty = newDescriptionProperty;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY, oldDescriptionProperty, descriptionProperty));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public String getDescription() {
+		return description;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setDescription(String newDescription) {
+		String oldDescription = description;
+		description = newDescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION, oldDescription, description));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable selection endpoint
+	 * @generated
+	 */
+	public YEmbeddableSelectionEndpoint createSelectionEndpointGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable collection endpoint
+	 * @generated
+	 */
+	public YEmbeddableCollectionEndpoint createCollectionEndpointGen() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Creates a new instance of selection endpoint with a reference to that embeddable.
+	 *
+	 * @return the y embeddable selection endpoint
+	 * @generated NOT
+	 */
+	public YEmbeddableSelectionEndpoint createSelectionEndpoint() {
+		YEmbeddableSelectionEndpoint ep = CoreModelFactory.eINSTANCE.createYEmbeddableSelectionEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * Creates a new instance of collection endpoint with a reference to that embeddable.
+	 *
+	 * @return the y embeddable collection endpoint
+	 * @generated NOT
+	 */
+	public YEmbeddableCollectionEndpoint createCollectionEndpoint() {
+		YEmbeddableCollectionEndpoint ep = CoreModelFactory.eINSTANCE.createYEmbeddableCollectionEndpoint();
+		ep.setElement(this);
+		return ep;
+
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+			if (collectionBindingEndpoint != null)
+				msgs = ((InternalEObject) collectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_COLLECTION_ENDPOINT__ELEMENT,
+						YEmbeddableCollectionEndpoint.class, msgs);
+			return basicSetCollectionBindingEndpoint((YEmbeddableCollectionEndpoint) otherEnd, msgs);
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+			if (selectionBindingEndpoint != null)
+				msgs = ((InternalEObject) selectionBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_SELECTION_ENDPOINT__ELEMENT,
+						YEmbeddableSelectionEndpoint.class, msgs);
+			return basicSetSelectionBindingEndpoint((YEmbeddableSelectionEndpoint) otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+			return basicSetCollectionBindingEndpoint(null, msgs);
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+			return basicSetSelectionBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+			if (resolve)
+				return getCollectionBindingEndpoint();
+			return basicGetCollectionBindingEndpoint();
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+			if (resolve)
+				return getSelectionBindingEndpoint();
+			return basicGetSelectionBindingEndpoint();
+		case YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE:
+			return isUseBeanService();
+		case YECviewPackage.YPAIR_COMBO_BOX__DATADESCRIPTION:
+			if (resolve)
+				return getDatadescription();
+			return basicGetDatadescription();
+		case YECviewPackage.YPAIR_COMBO_BOX__DATATYPE:
+			if (resolve)
+				return getDatatype();
+			return basicGetDatatype();
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION:
+			return getSelection();
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION:
+			return getCollection();
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE:
+			return getType();
+		case YECviewPackage.YPAIR_COMBO_BOX__EMF_NS_URI:
+			return getEmfNsURI();
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME:
+			return getTypeQualifiedName();
+		case YECviewPackage.YPAIR_COMBO_BOX__CAPTION_PROPERTY:
+			return getCaptionProperty();
+		case YECviewPackage.YPAIR_COMBO_BOX__IMAGE_PROPERTY:
+			return getImageProperty();
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY:
+			return getDescriptionProperty();
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION:
+			return getDescription();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+			setCollectionBindingEndpoint((YEmbeddableCollectionEndpoint) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+			setSelectionBindingEndpoint((YEmbeddableSelectionEndpoint) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE:
+			setUseBeanService((Boolean) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DATADESCRIPTION:
+			setDatadescription((YDatadescription) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DATATYPE:
+			setDatatype((YComboBoxDatatype) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION:
+			setSelection(newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION:
+			getCollection().clear();
+			getCollection().addAll((Collection<? extends Object>) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE:
+			setType((Class<?>) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__EMF_NS_URI:
+			setEmfNsURI((String) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME:
+			setTypeQualifiedName((String) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__CAPTION_PROPERTY:
+			setCaptionProperty((String) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__IMAGE_PROPERTY:
+			setImageProperty((String) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY:
+			setDescriptionProperty((String) newValue);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION:
+			setDescription((String) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+			setCollectionBindingEndpoint((YEmbeddableCollectionEndpoint) null);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+			setSelectionBindingEndpoint((YEmbeddableSelectionEndpoint) null);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE:
+			setUseBeanService(USE_BEAN_SERVICE_EDEFAULT);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DATADESCRIPTION:
+			setDatadescription((YDatadescription) null);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DATATYPE:
+			setDatatype((YComboBoxDatatype) null);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION:
+			setSelection(SELECTION_EDEFAULT);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION:
+			getCollection().clear();
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE:
+			setType((Class<?>) null);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__EMF_NS_URI:
+			setEmfNsURI(EMF_NS_URI_EDEFAULT);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME:
+			setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__CAPTION_PROPERTY:
+			setCaptionProperty(CAPTION_PROPERTY_EDEFAULT);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__IMAGE_PROPERTY:
+			setImageProperty(IMAGE_PROPERTY_EDEFAULT);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY:
+			setDescriptionProperty(DESCRIPTION_PROPERTY_EDEFAULT);
+			return;
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION:
+			setDescription(DESCRIPTION_EDEFAULT);
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+			return collectionBindingEndpoint != null;
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+			return selectionBindingEndpoint != null;
+		case YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE:
+			return useBeanService != USE_BEAN_SERVICE_EDEFAULT;
+		case YECviewPackage.YPAIR_COMBO_BOX__DATADESCRIPTION:
+			return datadescription != null;
+		case YECviewPackage.YPAIR_COMBO_BOX__DATATYPE:
+			return datatype != null;
+		case YECviewPackage.YPAIR_COMBO_BOX__SELECTION:
+			return SELECTION_EDEFAULT == null ? selection != null : !SELECTION_EDEFAULT.equals(selection);
+		case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION:
+			return collection != null && !collection.isEmpty();
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE:
+			return type != null;
+		case YECviewPackage.YPAIR_COMBO_BOX__EMF_NS_URI:
+			return EMF_NS_URI_EDEFAULT == null ? emfNsURI != null : !EMF_NS_URI_EDEFAULT.equals(emfNsURI);
+		case YECviewPackage.YPAIR_COMBO_BOX__TYPE_QUALIFIED_NAME:
+			return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+		case YECviewPackage.YPAIR_COMBO_BOX__CAPTION_PROPERTY:
+			return CAPTION_PROPERTY_EDEFAULT == null ? captionProperty != null : !CAPTION_PROPERTY_EDEFAULT.equals(captionProperty);
+		case YECviewPackage.YPAIR_COMBO_BOX__IMAGE_PROPERTY:
+			return IMAGE_PROPERTY_EDEFAULT == null ? imageProperty != null : !IMAGE_PROPERTY_EDEFAULT.equals(imageProperty);
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION_PROPERTY:
+			return DESCRIPTION_PROPERTY_EDEFAULT == null ? descriptionProperty != null : !DESCRIPTION_PROPERTY_EDEFAULT.equals(descriptionProperty);
+		case YECviewPackage.YPAIR_COMBO_BOX__DESCRIPTION:
+			return DESCRIPTION_EDEFAULT == null ? description != null : !DESCRIPTION_EDEFAULT.equals(description);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+			default:
+				return -1;
+			}
+		}
+		if (baseClass == YCollectionBindable.class) {
+			switch (derivedFeatureID) {
+			case YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT:
+				return CoreModelPackage.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT;
+			default:
+				return -1;
+			}
+		}
+		if (baseClass == YSelectionBindable.class) {
+			switch (derivedFeatureID) {
+			case YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT:
+				return CoreModelPackage.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT;
+			default:
+				return -1;
+			}
+		}
+		if (baseClass == YBeanServiceConsumer.class) {
+			switch (derivedFeatureID) {
+			case YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE:
+				return ExtensionModelPackage.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE;
+			default:
+				return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+			default:
+				return -1;
+			}
+		}
+		if (baseClass == YCollectionBindable.class) {
+			switch (baseFeatureID) {
+			case CoreModelPackage.YCOLLECTION_BINDABLE__COLLECTION_BINDING_ENDPOINT:
+				return YECviewPackage.YPAIR_COMBO_BOX__COLLECTION_BINDING_ENDPOINT;
+			default:
+				return -1;
+			}
+		}
+		if (baseClass == YSelectionBindable.class) {
+			switch (baseFeatureID) {
+			case CoreModelPackage.YSELECTION_BINDABLE__SELECTION_BINDING_ENDPOINT:
+				return YECviewPackage.YPAIR_COMBO_BOX__SELECTION_BINDING_ENDPOINT;
+			default:
+				return -1;
+			}
+		}
+		if (baseClass == YBeanServiceConsumer.class) {
+			switch (baseFeatureID) {
+			case ExtensionModelPackage.YBEAN_SERVICE_CONSUMER__USE_BEAN_SERVICE:
+				return YECviewPackage.YPAIR_COMBO_BOX__USE_BEAN_SERVICE;
+			default:
+				return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy())
+			return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (useBeanService: ");
+		result.append(useBeanService);
+		result.append(", selection: ");
+		result.append(selection);
+		result.append(", collection: ");
+		result.append(collection);
+		result.append(", type: ");
+		result.append(type);
+		result.append(", emfNsURI: ");
+		result.append(emfNsURI);
+		result.append(", typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(", captionProperty: ");
+		result.append(captionProperty);
+		result.append(", imageProperty: ");
+		result.append(imageProperty);
+		result.append(", descriptionProperty: ");
+		result.append(descriptionProperty);
+		result.append(", description: ");
+		result.append(description);
+		result.append(')');
+		return result.toString();
+	}
+
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+
+} // YPairComboBoxImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YPrefixedMaskedTextFieldImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YPrefixedMaskedTextFieldImpl.java
new file mode 100644
index 0000000..b53a42b
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YPrefixedMaskedTextFieldImpl.java
@@ -0,0 +1,554 @@
+/**
+ * All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YPrefixed Masked Text Field</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl#getMask <em>Mask</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YPrefixedMaskedTextFieldImpl#getPrefixes <em>Prefixes</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YPrefixedMaskedTextFieldImpl extends YInputImpl implements YPrefixedMaskedTextField {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected String value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String MASK_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getMask() <em>Mask</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMask()
+	 * @generated
+	 * @ordered
+	 */
+	protected String mask = MASK_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getPrefixes() <em>Prefixes</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getPrefixes()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> prefixes;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YPrefixedMaskedTextFieldImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YPREFIXED_MASKED_TEXT_FIELD;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValue(String newValue) {
+		String oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getMask() {
+		return mask;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMask(String newMask) {
+		String oldMask = mask;
+		mask = newMask;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__MASK, oldMask, mask));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EMap<String, String> getPrefixes() {
+		if (prefixes == null) {
+			prefixes = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES);
+		}
+		return prefixes;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		YEmbeddableValueEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableValueEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES:
+				return ((InternalEList<?>)getPrefixes()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE:
+				return getValue();
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__MASK:
+				return getMask();
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES:
+				if (coreType) return getPrefixes();
+				else return getPrefixes().map();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE:
+				setValue((String)newValue);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__MASK:
+				setMask((String)newValue);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES:
+				((EStructuralFeature.Setting)getPrefixes()).set(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__MASK:
+				setMask(MASK_EDEFAULT);
+				return;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES:
+				getPrefixes().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__MASK:
+				return MASK_EDEFAULT == null ? mask != null : !MASK_EDEFAULT.equals(mask);
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__PREFIXES:
+				return prefixes != null && !prefixes.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(", mask: ");
+		result.append(mask);
+		result.append(')');
+		return result.toString();
+	}
+
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+	
+} //YPrefixedMaskedTextFieldImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YQuantityTextFieldImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YQuantityTextFieldImpl.java
new file mode 100644
index 0000000..3298137
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YQuantityTextFieldImpl.java
@@ -0,0 +1,477 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YQuantityTextField;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YQuantity Text Field</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YQuantityTextFieldImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YQuantityTextFieldImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YQuantityTextFieldImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YQuantityTextFieldImpl extends YInputImpl implements YQuantityTextField {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final Object VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected Object value = VALUE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YQuantityTextFieldImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YQUANTITY_TEXT_FIELD;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValueBindingEndpoint()
+	 *         <em>Value Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValueBindingEndpoint
+	 *            the new value binding endpoint
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint, NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValueBindingEndpoint
+	 *            the new cached value of the '
+	 *            {@link #getValueBindingEndpoint()
+	 *            <em>Value Binding Endpoint</em>}' reference
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDatadescription()
+	 *         <em>Datadescription</em>}' reference
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YQUANTITY_TEXT_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y datadescription
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDatadescription
+	 *            the new cached value of the '{@link #getDatadescription()
+	 *            <em>Datadescription</em>}' reference
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YQUANTITY_TEXT_FIELD__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValue() <em>Value</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Object getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newValue
+	 *            the new cached value of the '{@link #getValue()
+	 *            <em>Value</em>}' attribute
+	 * @generated
+	 */
+	public void setValue(Object newValue) {
+		Object oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable value endpoint
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE:
+				return getValue();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE:
+				setValue(newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param derivedFeatureID
+	 *            the derived feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param baseFeatureID
+	 *            the base feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YQUANTITY_TEXT_FIELD__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: ");
+		result.append(value);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YRichTextAreaImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YRichTextAreaImpl.java
new file mode 100644
index 0000000..60bf43c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YRichTextAreaImpl.java
@@ -0,0 +1,557 @@
+/**
+ * All rights reserved by Loetz GmbH&Co.KG Heidelberg 2015.
+ * 
+ * Contributors:
+ *       Florian Pirchner - initial API and implementation
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.binding.BindingFactory;
+import org.eclipse.osbp.ecview.core.common.model.binding.YECViewModelValueBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.binding.YValueBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableValueEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.datatypes.YDatadescription;
+import org.eclipse.osbp.ecview.core.extension.model.extension.impl.YInputImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YRichTextArea;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>YRich Text Area</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl#getValueBindingEndpoint <em>Value Binding Endpoint</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl#getDatadescription <em>Datadescription</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl#getBlobValue <em>Blob Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YRichTextAreaImpl#isUseBlob <em>Use Blob</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YRichTextAreaImpl extends YInputImpl implements YRichTextArea {
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoint() <em>Value Binding Endpoint</em>}' reference.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getValueBindingEndpoint()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddableValueEndpoint valueBindingEndpoint;
+
+	/**
+	 * The cached value of the '{@link #getDatadescription() <em>Datadescription</em>}' reference.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getDatadescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected YDatadescription datadescription;
+
+	/**
+	 * The default value of the '{@link #getBlobValue() <em>Blob Value</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getBlobValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final byte[] BLOB_VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getBlobValue() <em>Blob Value</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getBlobValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected byte[] blobValue = BLOB_VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected String value = VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isUseBlob() <em>Use Blob</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseBlob()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean USE_BLOB_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isUseBlob() <em>Use Blob</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isUseBlob()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean useBlob = USE_BLOB_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YRichTextAreaImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YRICH_TEXT_AREA;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint getValueBindingEndpoint() {
+		if (valueBindingEndpoint != null && valueBindingEndpoint.eIsProxy()) {
+			InternalEObject oldValueBindingEndpoint = (InternalEObject)valueBindingEndpoint;
+			valueBindingEndpoint = (YEmbeddableValueEndpoint)eResolveProxy(oldValueBindingEndpoint);
+			if (valueBindingEndpoint != oldValueBindingEndpoint) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, valueBindingEndpoint));
+			}
+		}
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddableValueEndpoint basicGetValueBindingEndpoint() {
+		return valueBindingEndpoint;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetValueBindingEndpoint(
+			YEmbeddableValueEndpoint newValueBindingEndpoint,
+			NotificationChain msgs) {
+		YEmbeddableValueEndpoint oldValueBindingEndpoint = valueBindingEndpoint;
+		valueBindingEndpoint = newValueBindingEndpoint;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT, oldValueBindingEndpoint, newValueBindingEndpoint);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValueBindingEndpoint(
+			YEmbeddableValueEndpoint newValueBindingEndpoint) {
+		if (newValueBindingEndpoint != valueBindingEndpoint) {
+			NotificationChain msgs = null;
+			if (valueBindingEndpoint != null)
+				msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			if (newValueBindingEndpoint != null)
+				msgs = ((InternalEObject)newValueBindingEndpoint).eInverseAdd(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+			msgs = basicSetValueBindingEndpoint(newValueBindingEndpoint, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT, newValueBindingEndpoint, newValueBindingEndpoint));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription getDatadescription() {
+		if (datadescription != null && datadescription.eIsProxy()) {
+			InternalEObject oldDatadescription = (InternalEObject)datadescription;
+			datadescription = (YDatadescription)eResolveProxy(oldDatadescription);
+			if (datadescription != oldDatadescription) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YRICH_TEXT_AREA__DATADESCRIPTION, oldDatadescription, datadescription));
+			}
+		}
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YDatadescription basicGetDatadescription() {
+		return datadescription;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setDatadescription(YDatadescription newDatadescription) {
+		YDatadescription oldDatadescription = datadescription;
+		datadescription = newDatadescription;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YRICH_TEXT_AREA__DATADESCRIPTION, oldDatadescription, datadescription));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public byte[] getBlobValue() {
+		return blobValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setBlobValue(byte[] newBlobValue) {
+		byte[] oldBlobValue = blobValue;
+		blobValue = newBlobValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YRICH_TEXT_AREA__BLOB_VALUE, oldBlobValue, blobValue));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValue(String newValue) {
+		String oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YRICH_TEXT_AREA__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isUseBlob() {
+		return useBlob;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setUseBlob(boolean newUseBlob) {
+		boolean oldUseBlob = useBlob;
+		useBlob = newUseBlob;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YRICH_TEXT_AREA__USE_BLOB, oldUseBlob, useBlob));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 */
+	public YEmbeddableValueEndpoint createValueEndpoint() {
+		YEmbeddableValueEndpoint ep = CoreModelFactory.eINSTANCE
+				.createYEmbeddableValueEndpoint();
+		ep.setElement(this);
+		return ep;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT:
+				if (valueBindingEndpoint != null)
+					msgs = ((InternalEObject)valueBindingEndpoint).eInverseRemove(this, CoreModelPackage.YEMBEDDABLE_VALUE_ENDPOINT__ELEMENT, YEmbeddableValueEndpoint.class, msgs);
+				return basicSetValueBindingEndpoint((YEmbeddableValueEndpoint)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd,
+			int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT:
+				return basicSetValueBindingEndpoint(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT:
+				if (resolve) return getValueBindingEndpoint();
+				return basicGetValueBindingEndpoint();
+			case YECviewPackage.YRICH_TEXT_AREA__DATADESCRIPTION:
+				if (resolve) return getDatadescription();
+				return basicGetDatadescription();
+			case YECviewPackage.YRICH_TEXT_AREA__BLOB_VALUE:
+				return getBlobValue();
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE:
+				return getValue();
+			case YECviewPackage.YRICH_TEXT_AREA__USE_BLOB:
+				return isUseBlob();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)newValue);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__DATADESCRIPTION:
+				setDatadescription((YDatadescription)newValue);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__BLOB_VALUE:
+				setBlobValue((byte[])newValue);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE:
+				setValue((String)newValue);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__USE_BLOB:
+				setUseBlob((Boolean)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT:
+				setValueBindingEndpoint((YEmbeddableValueEndpoint)null);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__DATADESCRIPTION:
+				setDatadescription((YDatadescription)null);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__BLOB_VALUE:
+				setBlobValue(BLOB_VALUE_EDEFAULT);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE:
+				setValue(VALUE_EDEFAULT);
+				return;
+			case YECviewPackage.YRICH_TEXT_AREA__USE_BLOB:
+				setUseBlob(USE_BLOB_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT:
+				return valueBindingEndpoint != null;
+			case YECviewPackage.YRICH_TEXT_AREA__DATADESCRIPTION:
+				return datadescription != null;
+			case YECviewPackage.YRICH_TEXT_AREA__BLOB_VALUE:
+				return BLOB_VALUE_EDEFAULT == null ? blobValue != null : !BLOB_VALUE_EDEFAULT.equals(blobValue);
+			case YECviewPackage.YRICH_TEXT_AREA__VALUE:
+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+			case YECviewPackage.YRICH_TEXT_AREA__USE_BLOB:
+				return useBlob != USE_BLOB_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (derivedFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT: return CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YBindable.class) {
+			switch (baseFeatureID) {
+				default: return -1;
+			}
+		}
+		if (baseClass == YValueBindable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YVALUE_BINDABLE__VALUE_BINDING_ENDPOINT: return YECviewPackage.YRICH_TEXT_AREA__VALUE_BINDING_ENDPOINT;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (blobValue: ");
+		result.append(blobValue);
+		result.append(", value: ");
+		result.append(value);
+		result.append(", useBlob: ");
+		result.append(useBlob);
+		result.append(')');
+		return result.toString();
+	}
+
+	@Override
+	public YValueBindingEndpoint createBlobValueEndpoint() {
+		YECViewModelValueBindingEndpoint ep = BindingFactory.eINSTANCE
+				.createYECViewModelValueBindingEndpoint();
+		ep.setElement(this);
+		ep.setPropertyPath("blobValue");
+		return ep;
+	}
+	
+	/**
+	 * Sets the label by creating a new datadescription.
+	 *
+	 * @param label
+	 *            the new label
+	 */
+	public void setLabel(String label) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescription(label));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabel(label);
+		}
+	}
+
+	/**
+	 * Sets the label i18nKey by creating a new datadescription.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 */
+	public void setLabelI18nKey(String i18nKey) {
+		YDatadescription ds = getDatadescription();
+		if (ds == null) {
+			setDatadescription(createDatadescriptionForI18n(i18nKey));
+			getOrphanDatadescriptions().add(getDatadescription());
+		} else {
+			ds.setLabelI18nKey(i18nKey);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabel();
+		}
+		return "";
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.impl.YFieldImpl#getLabelI18nKey()
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		YDatadescription ds = getDatadescription();
+		if (ds != null) {
+			return ds.getLabelI18nKey();
+		}
+		return "";
+	}
+
+} // YRichTextAreaImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YStrategyLayoutImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YStrategyLayoutImpl.java
new file mode 100644
index 0000000..3cbf213
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YStrategyLayoutImpl.java
@@ -0,0 +1,567 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YEmbeddableImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YStrategy Layout</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getLayoutingStrategy <em>Layouting Strategy</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getFocusingStrategies <em>Focusing Strategies</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getSuspects <em>Suspects</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getLayoutingInfo <em>Layouting Info</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getDefaultFocusingEnhancerId <em>Default Focusing Enhancer Id</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YStrategyLayoutImpl extends YEmbeddableImpl implements YStrategyLayout {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getLayoutingStrategy() <em>Layouting Strategy</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLayoutingStrategy()
+	 * @generated
+	 * @ordered
+	 */
+	protected YLayoutingStrategy layoutingStrategy;
+
+	/**
+	 * The cached value of the '{@link #getFocusingStrategies() <em>Focusing Strategies</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getFocusingStrategies()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YFocusingStrategy> focusingStrategies;
+
+	/**
+	 * The cached value of the '{@link #getSuspects() <em>Suspects</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSuspects()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YSuspect> suspects;
+
+	/**
+	 * The cached value of the '{@link #getLayoutingInfo() <em>Layouting Info</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLayoutingInfo()
+	 * @generated
+	 * @ordered
+	 */
+	protected YLayoutingInfo layoutingInfo;
+
+	/**
+	 * The default value of the '{@link #getDefaultFocusingEnhancerId() <em>Default Focusing Enhancer Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDefaultFocusingEnhancerId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DEFAULT_FOCUSING_ENHANCER_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getDefaultFocusingEnhancerId() <em>Default Focusing Enhancer Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDefaultFocusingEnhancerId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String defaultFocusingEnhancerId = DEFAULT_FOCUSING_ENHANCER_ID_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YStrategyLayoutImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YSTRATEGY_LAYOUT;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLayoutingStrategy()
+	 *         <em>Layouting Strategy</em>}' containment reference
+	 * @generated
+	 */
+	public YLayoutingStrategy getLayoutingStrategy() {
+		return layoutingStrategy;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLayoutingStrategy
+	 *            the new layouting strategy
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetLayoutingStrategy(YLayoutingStrategy newLayoutingStrategy, NotificationChain msgs) {
+		YLayoutingStrategy oldLayoutingStrategy = layoutingStrategy;
+		layoutingStrategy = newLayoutingStrategy;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY, oldLayoutingStrategy, newLayoutingStrategy);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLayoutingStrategy
+	 *            the new cached value of the '{@link #getLayoutingStrategy()
+	 *            <em>Layouting Strategy</em>}' containment reference
+	 * @generated
+	 */
+	public void setLayoutingStrategy(YLayoutingStrategy newLayoutingStrategy) {
+		if (newLayoutingStrategy != layoutingStrategy) {
+			NotificationChain msgs = null;
+			if (layoutingStrategy != null)
+				msgs = ((InternalEObject)layoutingStrategy).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY, null, msgs);
+			if (newLayoutingStrategy != null)
+				msgs = ((InternalEObject)newLayoutingStrategy).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY, null, msgs);
+			msgs = basicSetLayoutingStrategy(newLayoutingStrategy, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY, newLayoutingStrategy, newLayoutingStrategy));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getFocusingStrategies()
+	 *         <em>Focusing Strategies</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<YFocusingStrategy> getFocusingStrategies() {
+		if (focusingStrategies == null) {
+			focusingStrategies = new EObjectContainmentEList<YFocusingStrategy>(YFocusingStrategy.class, this, YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES);
+		}
+		return focusingStrategies;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSuspects() <em>Suspects</em>}
+	 *         ' containment reference list
+	 * @generated
+	 */
+	public EList<YSuspect> getSuspects() {
+		if (suspects == null) {
+			suspects = new EObjectContainmentEList<YSuspect>(YSuspect.class, this, YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS);
+		}
+		return suspects;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLayoutingInfo()
+	 *         <em>Layouting Info</em>}' containment reference
+	 * @generated
+	 */
+	public YLayoutingInfo getLayoutingInfo() {
+		return layoutingInfo;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLayoutingInfo
+	 *            the new layouting info
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetLayoutingInfo(YLayoutingInfo newLayoutingInfo, NotificationChain msgs) {
+		YLayoutingInfo oldLayoutingInfo = layoutingInfo;
+		layoutingInfo = newLayoutingInfo;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO, oldLayoutingInfo, newLayoutingInfo);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLayoutingInfo
+	 *            the new cached value of the '{@link #getLayoutingInfo()
+	 *            <em>Layouting Info</em>}' containment reference
+	 * @generated
+	 */
+	public void setLayoutingInfo(YLayoutingInfo newLayoutingInfo) {
+		if (newLayoutingInfo != layoutingInfo) {
+			NotificationChain msgs = null;
+			if (layoutingInfo != null)
+				msgs = ((InternalEObject)layoutingInfo).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO, null, msgs);
+			if (newLayoutingInfo != null)
+				msgs = ((InternalEObject)newLayoutingInfo).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO, null, msgs);
+			msgs = basicSetLayoutingInfo(newLayoutingInfo, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO, newLayoutingInfo, newLayoutingInfo));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getDefaultFocusingEnhancerId()
+	 *         <em>Default Focusing Enhancer Id</em>}' attribute
+	 * @generated
+	 */
+	public String getDefaultFocusingEnhancerId() {
+		return defaultFocusingEnhancerId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newDefaultFocusingEnhancerId
+	 *            the new cached value of the '
+	 *            {@link #getDefaultFocusingEnhancerId()
+	 *            <em>Default Focusing Enhancer Id</em>}' attribute
+	 * @generated
+	 */
+	public void setDefaultFocusingEnhancerId(String newDefaultFocusingEnhancerId) {
+		String oldDefaultFocusingEnhancerId = defaultFocusingEnhancerId;
+		defaultFocusingEnhancerId = newDefaultFocusingEnhancerId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID, oldDefaultFocusingEnhancerId, defaultFocusingEnhancerId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
+				return basicSetLayoutingStrategy(null, msgs);
+			case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
+				return ((InternalEList<?>)getFocusingStrategies()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
+				return ((InternalEList<?>)getSuspects()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO:
+				return basicSetLayoutingInfo(null, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
+				return getLayoutingStrategy();
+			case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
+				return getFocusingStrategies();
+			case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
+				return getSuspects();
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO:
+				return getLayoutingInfo();
+			case YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID:
+				return getDefaultFocusingEnhancerId();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
+				setLayoutingStrategy((YLayoutingStrategy)newValue);
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
+				getFocusingStrategies().clear();
+				getFocusingStrategies().addAll((Collection<? extends YFocusingStrategy>)newValue);
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
+				getSuspects().clear();
+				getSuspects().addAll((Collection<? extends YSuspect>)newValue);
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO:
+				setLayoutingInfo((YLayoutingInfo)newValue);
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID:
+				setDefaultFocusingEnhancerId((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
+				setLayoutingStrategy((YLayoutingStrategy)null);
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
+				getFocusingStrategies().clear();
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
+				getSuspects().clear();
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO:
+				setLayoutingInfo((YLayoutingInfo)null);
+				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID:
+				setDefaultFocusingEnhancerId(DEFAULT_FOCUSING_ENHANCER_ID_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
+				return layoutingStrategy != null;
+			case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
+				return focusingStrategies != null && !focusingStrategies.isEmpty();
+			case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
+				return suspects != null && !suspects.isEmpty();
+			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO:
+				return layoutingInfo != null;
+			case YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID:
+				return DEFAULT_FOCUSING_ENHANCER_ID_EDEFAULT == null ? defaultFocusingEnhancerId != null : !DEFAULT_FOCUSING_ENHANCER_ID_EDEFAULT.equals(defaultFocusingEnhancerId);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (defaultFocusingEnhancerId: ");
+		result.append(defaultFocusingEnhancerId);
+		result.append(')');
+		return result.toString();
+	}
+
+	/**
+	 * Sets the label.
+	 *
+	 * @param label
+	 *            the new label
+	 * @generated NOT
+	 */
+	@Override
+	public void setLabel(String label) {
+		// nothing to do
+
+	}
+
+	/**
+	 * Sets the label i18n key.
+	 *
+	 * @param i18nKey
+	 *            the new label i18n key
+	 * @generated NOT
+	 */
+	@Override
+	public void setLabelI18nKey(String i18nKey) {
+		// nothing to do
+
+	}
+
+	/**
+	 * Find info for.
+	 *
+	 * @param yEmbeddable
+	 *            the y embeddable
+	 * @return the y suspect info
+	 * @generated NOT
+	 */
+	@Override
+	public YSuspectInfo findInfoFor(YEmbeddable yEmbeddable) {
+		if (getLayoutingInfo() != null) {
+			for (YSuspectInfo info : getLayoutingInfo()
+					.getActiveSuspectInfos()) {
+				if (info.getTarget() == yEmbeddable) {
+					return info;
+				}
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Find last focus.
+	 *
+	 * @return the y suspect info
+	 * @generated NOT
+	 */
+	@Override
+	public YSuspectInfo findLastFocus() {
+		return getLayoutingInfo() != null ? findLastFocus(getLayoutingInfo()
+				.getFirstFocus()) : null;
+	}
+
+	/**
+	 * Find last focus.
+	 *
+	 * @param current
+	 *            the current
+	 * @return the y suspect info
+	 * @generated NOT
+	 */
+	private YSuspectInfo findLastFocus(YSuspectInfo current) {
+		if (current == null) {
+			return null;
+		}
+
+		if (current.getNextFocus() == null) {
+			return current;
+		}
+
+		return findLastFocus(current.getNextFocus());
+	}
+
+	/**
+	 * Gets the label.
+	 *
+	 * @return the label
+	 * @generated NOT
+	 */
+	@Override
+	public String getLabel() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	/**
+	 * Gets the label i18n key.
+	 *
+	 * @return the label i18n key
+	 * @generated NOT
+	 */
+	@Override
+	public String getLabelI18nKey() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSubTypeBaseSuspectImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSubTypeBaseSuspectImpl.java
new file mode 100644
index 0000000..b9bc5f5
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSubTypeBaseSuspectImpl.java
@@ -0,0 +1,56 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YSub Type Base Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * </p>
+ *
+ * @generated
+ */
+public class YSubTypeBaseSuspectImpl extends YTypedCompoundSuspectImpl implements YSubTypeBaseSuspect {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSubTypeBaseSuspectImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YSUB_TYPE_BASE_SUSPECT;
+	}
+
+} //YSubTypeBaseSuspectImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSubTypeSuspectImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSubTypeSuspectImpl.java
new file mode 100644
index 0000000..8b2366d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSubTypeSuspectImpl.java
@@ -0,0 +1,171 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.YBeanSlot;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YSub Type Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSubTypeSuspectImpl#getBeanSlot <em>Bean Slot</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YSubTypeSuspectImpl extends YTypedCompoundSuspectImpl implements YSubTypeSuspect {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getBeanSlot() <em>Bean Slot</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getBeanSlot()
+	 * @generated
+	 * @ordered
+	 */
+	protected YBeanSlot beanSlot;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSubTypeSuspectImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YSUB_TYPE_SUSPECT;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YBeanSlot getBeanSlot() {
+		if (beanSlot != null && beanSlot.eIsProxy()) {
+			InternalEObject oldBeanSlot = (InternalEObject)beanSlot;
+			beanSlot = (YBeanSlot)eResolveProxy(oldBeanSlot);
+			if (beanSlot != oldBeanSlot) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YSUB_TYPE_SUSPECT__BEAN_SLOT, oldBeanSlot, beanSlot));
+			}
+		}
+		return beanSlot;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YBeanSlot basicGetBeanSlot() {
+		return beanSlot;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setBeanSlot(YBeanSlot newBeanSlot) {
+		YBeanSlot oldBeanSlot = beanSlot;
+		beanSlot = newBeanSlot;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUB_TYPE_SUSPECT__BEAN_SLOT, oldBeanSlot, beanSlot));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YSUB_TYPE_SUSPECT__BEAN_SLOT:
+				if (resolve) return getBeanSlot();
+				return basicGetBeanSlot();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YSUB_TYPE_SUSPECT__BEAN_SLOT:
+				setBeanSlot((YBeanSlot)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSUB_TYPE_SUSPECT__BEAN_SLOT:
+				setBeanSlot((YBeanSlot)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSUB_TYPE_SUSPECT__BEAN_SLOT:
+				return beanSlot != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //YSubTypeSuspectImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectImpl.java
new file mode 100644
index 0000000..6d6e61d
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectImpl.java
@@ -0,0 +1,938 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EObjectResolvingEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.binding.YBinding;
+import org.eclipse.osbp.ecview.core.common.model.binding.YBindingEndpoint;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCommand;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YSuspect</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getAuthorizationGroup <em>Authorization Group</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getAuthorizationId <em>Authorization Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getLabelI18nKey <em>Label I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getImageI18nKey <em>Image I1 8n Key</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getValueBindingEndpoints <em>Value Binding Endpoints</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getVisibilityProcessors <em>Visibility Processors</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getCommands <em>Commands</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getAssocNewiatedElements <em>Assoc Newiated Elements</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getAssociatedBindings <em>Associated Bindings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getLabel <em>Label</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YSuspectImpl extends MinimalEObjectImpl.Container implements YSuspect {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The default value of the '{@link #getAuthorizationGroup() <em>Authorization Group</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAuthorizationGroup()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String AUTHORIZATION_GROUP_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getAuthorizationGroup() <em>Authorization Group</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAuthorizationGroup()
+	 * @generated
+	 * @ordered
+	 */
+	protected String authorizationGroup = AUTHORIZATION_GROUP_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getAuthorizationId() <em>Authorization Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAuthorizationId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String AUTHORIZATION_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getAuthorizationId() <em>Authorization Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAuthorizationId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String authorizationId = AUTHORIZATION_ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_I1_8N_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabelI18nKey() <em>Label I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String labelI18nKey = LABEL_I1_8N_KEY_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getImageI18nKey() <em>Image I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getImageI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String IMAGE_I1_8N_KEY_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getImageI18nKey() <em>Image I1 8n Key</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getImageI18nKey()
+	 * @generated
+	 * @ordered
+	 */
+	protected String imageI18nKey = IMAGE_I1_8N_KEY_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getValueBindingEndpoints() <em>Value Binding Endpoints</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValueBindingEndpoints()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YBindingEndpoint> valueBindingEndpoints;
+
+	/**
+	 * The cached value of the '{@link #getVisibilityProcessors() <em>Visibility Processors</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getVisibilityProcessors()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YVisibilityProcessor> visibilityProcessors;
+
+	/**
+	 * The cached value of the '{@link #getCommands() <em>Commands</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCommands()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YCommand> commands;
+
+	/**
+	 * The cached value of the '{@link #getAssocNewiatedElements() <em>Assoc Newiated Elements</em>}' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAssocNewiatedElements()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YEmbeddable> assocNewiatedElements;
+
+	/**
+	 * The cached value of the '{@link #getAssociatedBindings() <em>Associated Bindings</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getAssociatedBindings()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YBinding> associatedBindings;
+
+	/**
+	 * The default value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected String label = LABEL_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YSuspectImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YSUSPECT;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YECviewPackage.YSUSPECT__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YECviewPackage.YSUSPECT__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getAuthorizationGroup()
+	 *         <em>Authorization Group</em>}' attribute
+	 * @generated
+	 */
+	public String getAuthorizationGroup() {
+		return authorizationGroup;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newAuthorizationGroup
+	 *            the new cached value of the '{@link #getAuthorizationGroup()
+	 *            <em>Authorization Group</em>}' attribute
+	 * @generated
+	 */
+	public void setAuthorizationGroup(String newAuthorizationGroup) {
+		String oldAuthorizationGroup = authorizationGroup;
+		authorizationGroup = newAuthorizationGroup;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP, oldAuthorizationGroup, authorizationGroup));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getAuthorizationId()
+	 *         <em>Authorization Id</em>}' attribute
+	 * @generated
+	 */
+	public String getAuthorizationId() {
+		return authorizationId;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newAuthorizationId
+	 *            the new cached value of the '{@link #getAuthorizationId()
+	 *            <em>Authorization Id</em>}' attribute
+	 * @generated
+	 */
+	public void setAuthorizationId(String newAuthorizationId) {
+		String oldAuthorizationId = authorizationId;
+		authorizationId = newAuthorizationId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__AUTHORIZATION_ID, oldAuthorizationId, authorizationId));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabelI18nKey()
+	 *         <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public String getLabelI18nKey() {
+		return labelI18nKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabelI18nKey
+	 *            the new cached value of the '{@link #getLabelI18nKey()
+	 *            <em>Label I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public void setLabelI18nKey(String newLabelI18nKey) {
+		String oldLabelI18nKey = labelI18nKey;
+		labelI18nKey = newLabelI18nKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__LABEL_I1_8N_KEY, oldLabelI18nKey, labelI18nKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getImageI18nKey()
+	 *         <em>Image I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public String getImageI18nKey() {
+		return imageI18nKey;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newImageI18nKey
+	 *            the new cached value of the '{@link #getImageI18nKey()
+	 *            <em>Image I1 8n Key</em>}' attribute
+	 * @generated
+	 */
+	public void setImageI18nKey(String newImageI18nKey) {
+		String oldImageI18nKey = imageI18nKey;
+		imageI18nKey = newImageI18nKey;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__IMAGE_I1_8N_KEY, oldImageI18nKey, imageI18nKey));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getValueBindingEndpoints()
+	 *         <em>Value Binding Endpoints</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<YBindingEndpoint> getValueBindingEndpoints() {
+		if (valueBindingEndpoints == null) {
+			valueBindingEndpoints = new EObjectContainmentEList<YBindingEndpoint>(YBindingEndpoint.class, this, YECviewPackage.YSUSPECT__VALUE_BINDING_ENDPOINTS);
+		}
+		return valueBindingEndpoints;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getVisibilityProcessors()
+	 *         <em>Visibility Processors</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<YVisibilityProcessor> getVisibilityProcessors() {
+		if (visibilityProcessors == null) {
+			visibilityProcessors = new EObjectContainmentEList<YVisibilityProcessor>(YVisibilityProcessor.class, this, YECviewPackage.YSUSPECT__VISIBILITY_PROCESSORS);
+		}
+		return visibilityProcessors;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getCommands() <em>Commands</em>}
+	 *         ' containment reference list
+	 * @generated
+	 */
+	public EList<YCommand> getCommands() {
+		if (commands == null) {
+			commands = new EObjectContainmentEList<YCommand>(YCommand.class, this, YECviewPackage.YSUSPECT__COMMANDS);
+		}
+		return commands;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getAssocNewiatedElements()
+	 *         <em>Assoc Newiated Elements</em>}' reference list
+	 * @generated
+	 */
+	public EList<YEmbeddable> getAssocNewiatedElements() {
+		if (assocNewiatedElements == null) {
+			assocNewiatedElements = new EObjectResolvingEList<YEmbeddable>(YEmbeddable.class, this, YECviewPackage.YSUSPECT__ASSOC_NEWIATED_ELEMENTS);
+		}
+		return assocNewiatedElements;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getAssociatedBindings()
+	 *         <em>Associated Bindings</em>}' containment reference list
+	 * @generated
+	 */
+	public EList<YBinding> getAssociatedBindings() {
+		if (associatedBindings == null) {
+			associatedBindings = new EObjectContainmentEList<YBinding>(YBinding.class, this, YECviewPackage.YSUSPECT__ASSOCIATED_BINDINGS);
+		}
+		return associatedBindings;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getLabel() <em>Label</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newLabel
+	 *            the new cached value of the '{@link #getLabel()
+	 *            <em>Label</em>}' attribute
+	 * @generated
+	 */
+	public void setLabel(String newLabel) {
+		String oldLabel = label;
+		label = newLabel;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__LABEL, oldLabel, label));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSUSPECT__VALUE_BINDING_ENDPOINTS:
+				return ((InternalEList<?>)getValueBindingEndpoints()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSUSPECT__VISIBILITY_PROCESSORS:
+				return ((InternalEList<?>)getVisibilityProcessors()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSUSPECT__COMMANDS:
+				return ((InternalEList<?>)getCommands()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSUSPECT__ASSOCIATED_BINDINGS:
+				return ((InternalEList<?>)getAssociatedBindings()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT__TAGS:
+				return getTags();
+			case YECviewPackage.YSUSPECT__ID:
+				return getId();
+			case YECviewPackage.YSUSPECT__NAME:
+				return getName();
+			case YECviewPackage.YSUSPECT__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP:
+				return getAuthorizationGroup();
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_ID:
+				return getAuthorizationId();
+			case YECviewPackage.YSUSPECT__LABEL_I1_8N_KEY:
+				return getLabelI18nKey();
+			case YECviewPackage.YSUSPECT__IMAGE_I1_8N_KEY:
+				return getImageI18nKey();
+			case YECviewPackage.YSUSPECT__VALUE_BINDING_ENDPOINTS:
+				return getValueBindingEndpoints();
+			case YECviewPackage.YSUSPECT__VISIBILITY_PROCESSORS:
+				return getVisibilityProcessors();
+			case YECviewPackage.YSUSPECT__COMMANDS:
+				return getCommands();
+			case YECviewPackage.YSUSPECT__ASSOC_NEWIATED_ELEMENTS:
+				return getAssocNewiatedElements();
+			case YECviewPackage.YSUSPECT__ASSOCIATED_BINDINGS:
+				return getAssociatedBindings();
+			case YECviewPackage.YSUSPECT__LABEL:
+				return getLabel();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__ID:
+				setId((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__NAME:
+				setName((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP:
+				setAuthorizationGroup((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_ID:
+				setAuthorizationId((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__LABEL_I1_8N_KEY:
+				setLabelI18nKey((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__IMAGE_I1_8N_KEY:
+				setImageI18nKey((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__VALUE_BINDING_ENDPOINTS:
+				getValueBindingEndpoints().clear();
+				getValueBindingEndpoints().addAll((Collection<? extends YBindingEndpoint>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__VISIBILITY_PROCESSORS:
+				getVisibilityProcessors().clear();
+				getVisibilityProcessors().addAll((Collection<? extends YVisibilityProcessor>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__COMMANDS:
+				getCommands().clear();
+				getCommands().addAll((Collection<? extends YCommand>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__ASSOC_NEWIATED_ELEMENTS:
+				getAssocNewiatedElements().clear();
+				getAssocNewiatedElements().addAll((Collection<? extends YEmbeddable>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__ASSOCIATED_BINDINGS:
+				getAssociatedBindings().clear();
+				getAssociatedBindings().addAll((Collection<? extends YBinding>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT__LABEL:
+				setLabel((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT__TAGS:
+				getTags().clear();
+				return;
+			case YECviewPackage.YSUSPECT__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP:
+				setAuthorizationGroup(AUTHORIZATION_GROUP_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_ID:
+				setAuthorizationId(AUTHORIZATION_ID_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT__LABEL_I1_8N_KEY:
+				setLabelI18nKey(LABEL_I1_8N_KEY_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT__IMAGE_I1_8N_KEY:
+				setImageI18nKey(IMAGE_I1_8N_KEY_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT__VALUE_BINDING_ENDPOINTS:
+				getValueBindingEndpoints().clear();
+				return;
+			case YECviewPackage.YSUSPECT__VISIBILITY_PROCESSORS:
+				getVisibilityProcessors().clear();
+				return;
+			case YECviewPackage.YSUSPECT__COMMANDS:
+				getCommands().clear();
+				return;
+			case YECviewPackage.YSUSPECT__ASSOC_NEWIATED_ELEMENTS:
+				getAssocNewiatedElements().clear();
+				return;
+			case YECviewPackage.YSUSPECT__ASSOCIATED_BINDINGS:
+				getAssociatedBindings().clear();
+				return;
+			case YECviewPackage.YSUSPECT__LABEL:
+				setLabel(LABEL_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YECviewPackage.YSUSPECT__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YECviewPackage.YSUSPECT__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YECviewPackage.YSUSPECT__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP:
+				return AUTHORIZATION_GROUP_EDEFAULT == null ? authorizationGroup != null : !AUTHORIZATION_GROUP_EDEFAULT.equals(authorizationGroup);
+			case YECviewPackage.YSUSPECT__AUTHORIZATION_ID:
+				return AUTHORIZATION_ID_EDEFAULT == null ? authorizationId != null : !AUTHORIZATION_ID_EDEFAULT.equals(authorizationId);
+			case YECviewPackage.YSUSPECT__LABEL_I1_8N_KEY:
+				return LABEL_I1_8N_KEY_EDEFAULT == null ? labelI18nKey != null : !LABEL_I1_8N_KEY_EDEFAULT.equals(labelI18nKey);
+			case YECviewPackage.YSUSPECT__IMAGE_I1_8N_KEY:
+				return IMAGE_I1_8N_KEY_EDEFAULT == null ? imageI18nKey != null : !IMAGE_I1_8N_KEY_EDEFAULT.equals(imageI18nKey);
+			case YECviewPackage.YSUSPECT__VALUE_BINDING_ENDPOINTS:
+				return valueBindingEndpoints != null && !valueBindingEndpoints.isEmpty();
+			case YECviewPackage.YSUSPECT__VISIBILITY_PROCESSORS:
+				return visibilityProcessors != null && !visibilityProcessors.isEmpty();
+			case YECviewPackage.YSUSPECT__COMMANDS:
+				return commands != null && !commands.isEmpty();
+			case YECviewPackage.YSUSPECT__ASSOC_NEWIATED_ELEMENTS:
+				return assocNewiatedElements != null && !assocNewiatedElements.isEmpty();
+			case YECviewPackage.YSUSPECT__ASSOCIATED_BINDINGS:
+				return associatedBindings != null && !associatedBindings.isEmpty();
+			case YECviewPackage.YSUSPECT__LABEL:
+				return LABEL_EDEFAULT == null ? label != null : !LABEL_EDEFAULT.equals(label);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param derivedFeatureID
+	 *            the derived feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
+		if (baseClass == YAuthorizationable.class) {
+			switch (derivedFeatureID) {
+				case YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP: return CoreModelPackage.YAUTHORIZATIONABLE__AUTHORIZATION_GROUP;
+				case YECviewPackage.YSUSPECT__AUTHORIZATION_ID: return CoreModelPackage.YAUTHORIZATIONABLE__AUTHORIZATION_ID;
+				default: return -1;
+			}
+		}
+		return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param baseFeatureID
+	 *            the base feature id
+	 * @param baseClass
+	 *            the base class
+	 * @return the int
+	 * @generated
+	 */
+	@Override
+	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
+		if (baseClass == YAuthorizationable.class) {
+			switch (baseFeatureID) {
+				case CoreModelPackage.YAUTHORIZATIONABLE__AUTHORIZATION_GROUP: return YECviewPackage.YSUSPECT__AUTHORIZATION_GROUP;
+				case CoreModelPackage.YAUTHORIZATIONABLE__AUTHORIZATION_ID: return YECviewPackage.YSUSPECT__AUTHORIZATION_ID;
+				default: return -1;
+			}
+		}
+		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(", authorizationGroup: ");
+		result.append(authorizationGroup);
+		result.append(", authorizationId: ");
+		result.append(authorizationId);
+		result.append(", labelI18nKey: ");
+		result.append(labelI18nKey);
+		result.append(", imageI18nKey: ");
+		result.append(imageI18nKey);
+		result.append(", label: ");
+		result.append(label);
+		result.append(')');
+		return result.toString();
+	}
+
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 * @generated NOT
+	 */
+	public YView getView() {
+		return findViewGeneric(eContainer());
+	}
+
+	/**
+	 * Find view generic.
+	 *
+	 * @param container
+	 *            the container
+	 * @return the y view
+	 * @generated NOT
+	 */
+	protected YView findViewGeneric(EObject container) {
+		if (container == null) {
+			return null;
+		}
+		if (container instanceof YView) {
+			return (YView) container;
+		} else if (container instanceof YLayout) {
+			return ((YLayout) container).getView();
+		} else {
+			EObject parent = container.eContainer();
+			return findViewGeneric(parent);
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectInfoImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectInfoImpl.java
new file mode 100644
index 0000000..e6d38cc
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectInfoImpl.java
@@ -0,0 +1,830 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EcoreEMap;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.core.common.model.binding.YBinding;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
+import org.eclipse.osbp.ecview.core.common.model.core.impl.YStringToStringMapImpl;
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YSuspect Info</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getTags <em>Tags</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getProperties <em>Properties</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getSuspect <em>Suspect</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getBindings <em>Bindings</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getNextFocus <em>Next Focus</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getPreviousFocus <em>Previous Focus</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getTarget <em>Target</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectInfoImpl#getVisibilityProcessors <em>Visibility Processors</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YSuspectInfoImpl extends MinimalEObjectImpl.Container implements YSuspectInfo {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getTags() <em>Tags</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTags()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> tags;
+
+	/**
+	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getId()
+	 * @generated
+	 * @ordered
+	 */
+	protected String id = ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getProperties() <em>Properties</em>}' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getProperties()
+	 * @generated
+	 * @ordered
+	 */
+	protected EMap<String, String> properties;
+
+	/**
+	 * The cached value of the '{@link #getSuspect() <em>Suspect</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSuspect()
+	 * @generated
+	 * @ordered
+	 */
+	protected YSuspect suspect;
+
+	/**
+	 * The cached value of the '{@link #getBindings() <em>Bindings</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getBindings()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YBinding> bindings;
+
+	/**
+	 * The cached value of the '{@link #getNextFocus() <em>Next Focus</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getNextFocus()
+	 * @generated
+	 * @ordered
+	 */
+	protected YSuspectInfo nextFocus;
+
+	/**
+	 * The cached value of the '{@link #getPreviousFocus() <em>Previous Focus</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getPreviousFocus()
+	 * @generated
+	 * @ordered
+	 */
+	protected YSuspectInfo previousFocus;
+
+	/**
+	 * The cached value of the '{@link #getTarget() <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTarget()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddable target;
+
+	/**
+	 * The cached value of the '{@link #getVisibilityProcessors() <em>Visibility Processors</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getVisibilityProcessors()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YVisibilityProcessor> visibilityProcessors;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YSuspectInfoImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YSUSPECT_INFO;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getId() <em>Id</em>}' attribute
+	 * @generated
+	 */
+	public String getId() {
+		return id;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newId
+	 *            the new cached value of the '{@link #getId() <em>Id</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setId(String newId) {
+		String oldId = id;
+		id = newId;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__ID, oldId, id));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getName() <em>Name</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newName
+	 *            the new cached value of the '{@link #getName() <em>Name</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__NAME, oldName, name));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTags() <em>Tags</em>}'
+	 *         attribute list
+	 * @generated
+	 */
+	public EList<String> getTags() {
+		if (tags == null) {
+			tags = new EDataTypeUniqueEList<String>(String.class, this, YECviewPackage.YSUSPECT_INFO__TAGS);
+		}
+		return tags;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getProperties()
+	 *         <em>Properties</em>}' map
+	 * @generated
+	 */
+	public EMap<String, String> getProperties() {
+		if (properties == null) {
+			properties = new EcoreEMap<String,String>(CoreModelPackage.Literals.YSTRING_TO_STRING_MAP, YStringToStringMapImpl.class, this, YECviewPackage.YSUSPECT_INFO__PROPERTIES);
+		}
+		return properties;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getSuspect() <em>Suspect</em>}'
+	 *         reference
+	 * @generated
+	 */
+	public YSuspect getSuspect() {
+		if (suspect != null && suspect.eIsProxy()) {
+			InternalEObject oldSuspect = (InternalEObject)suspect;
+			suspect = (YSuspect)eResolveProxy(oldSuspect);
+			if (suspect != oldSuspect) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YSUSPECT_INFO__SUSPECT, oldSuspect, suspect));
+			}
+		}
+		return suspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect
+	 * @generated
+	 */
+	public YSuspect basicGetSuspect() {
+		return suspect;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newSuspect
+	 *            the new cached value of the '{@link #getSuspect()
+	 *            <em>Suspect</em>}' reference
+	 * @generated
+	 */
+	public void setSuspect(YSuspect newSuspect) {
+		YSuspect oldSuspect = suspect;
+		suspect = newSuspect;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__SUSPECT, oldSuspect, suspect));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getBindings() <em>Bindings</em>}
+	 *         ' containment reference list
+	 * @generated
+	 */
+	public EList<YBinding> getBindings() {
+		if (bindings == null) {
+			bindings = new EObjectContainmentEList<YBinding>(YBinding.class, this, YECviewPackage.YSUSPECT_INFO__BINDINGS);
+		}
+		return bindings;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getNextFocus()
+	 *         <em>Next Focus</em>}' reference
+	 * @generated
+	 */
+	public YSuspectInfo getNextFocus() {
+		if (nextFocus != null && nextFocus.eIsProxy()) {
+			InternalEObject oldNextFocus = (InternalEObject)nextFocus;
+			nextFocus = (YSuspectInfo)eResolveProxy(oldNextFocus);
+			if (nextFocus != oldNextFocus) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS, oldNextFocus, nextFocus));
+			}
+		}
+		return nextFocus;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info
+	 * @generated
+	 */
+	public YSuspectInfo basicGetNextFocus() {
+		return nextFocus;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNextFocus
+	 *            the new next focus
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetNextFocus(YSuspectInfo newNextFocus, NotificationChain msgs) {
+		YSuspectInfo oldNextFocus = nextFocus;
+		nextFocus = newNextFocus;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS, oldNextFocus, newNextFocus);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newNextFocus
+	 *            the new cached value of the '{@link #getNextFocus()
+	 *            <em>Next Focus</em>}' reference
+	 * @generated
+	 */
+	public void setNextFocus(YSuspectInfo newNextFocus) {
+		if (newNextFocus != nextFocus) {
+			NotificationChain msgs = null;
+			if (nextFocus != null)
+				msgs = ((InternalEObject)nextFocus).eInverseRemove(this, YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS, YSuspectInfo.class, msgs);
+			if (newNextFocus != null)
+				msgs = ((InternalEObject)newNextFocus).eInverseAdd(this, YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS, YSuspectInfo.class, msgs);
+			msgs = basicSetNextFocus(newNextFocus, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS, newNextFocus, newNextFocus));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getPreviousFocus()
+	 *         <em>Previous Focus</em>}' reference
+	 * @generated
+	 */
+	public YSuspectInfo getPreviousFocus() {
+		if (previousFocus != null && previousFocus.eIsProxy()) {
+			InternalEObject oldPreviousFocus = (InternalEObject)previousFocus;
+			previousFocus = (YSuspectInfo)eResolveProxy(oldPreviousFocus);
+			if (previousFocus != oldPreviousFocus) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS, oldPreviousFocus, previousFocus));
+			}
+		}
+		return previousFocus;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y suspect info
+	 * @generated
+	 */
+	public YSuspectInfo basicGetPreviousFocus() {
+		return previousFocus;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newPreviousFocus
+	 *            the new previous focus
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	public NotificationChain basicSetPreviousFocus(YSuspectInfo newPreviousFocus, NotificationChain msgs) {
+		YSuspectInfo oldPreviousFocus = previousFocus;
+		previousFocus = newPreviousFocus;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS, oldPreviousFocus, newPreviousFocus);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newPreviousFocus
+	 *            the new cached value of the '{@link #getPreviousFocus()
+	 *            <em>Previous Focus</em>}' reference
+	 * @generated
+	 */
+	public void setPreviousFocus(YSuspectInfo newPreviousFocus) {
+		if (newPreviousFocus != previousFocus) {
+			NotificationChain msgs = null;
+			if (previousFocus != null)
+				msgs = ((InternalEObject)previousFocus).eInverseRemove(this, YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS, YSuspectInfo.class, msgs);
+			if (newPreviousFocus != null)
+				msgs = ((InternalEObject)newPreviousFocus).eInverseAdd(this, YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS, YSuspectInfo.class, msgs);
+			msgs = basicSetPreviousFocus(newPreviousFocus, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS, newPreviousFocus, newPreviousFocus));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTarget() <em>Target</em>}'
+	 *         reference
+	 * @generated
+	 */
+	public YEmbeddable getTarget() {
+		if (target != null && target.eIsProxy()) {
+			InternalEObject oldTarget = (InternalEObject)target;
+			target = (YEmbeddable)eResolveProxy(oldTarget);
+			if (target != oldTarget) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YECviewPackage.YSUSPECT_INFO__TARGET, oldTarget, target));
+			}
+		}
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y embeddable
+	 * @generated
+	 */
+	public YEmbeddable basicGetTarget() {
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTarget
+	 *            the new cached value of the '{@link #getTarget()
+	 *            <em>Target</em>}' reference
+	 * @generated
+	 */
+	public void setTarget(YEmbeddable newTarget) {
+		YEmbeddable oldTarget = target;
+		target = newTarget;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT_INFO__TARGET, oldTarget, target));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<YVisibilityProcessor> getVisibilityProcessors() {
+		if (visibilityProcessors == null) {
+			visibilityProcessors = new EObjectContainmentEList<YVisibilityProcessor>(YVisibilityProcessor.class, this, YECviewPackage.YSUSPECT_INFO__VISIBILITY_PROCESSORS);
+		}
+		return visibilityProcessors;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS:
+				if (nextFocus != null)
+					msgs = ((InternalEObject)nextFocus).eInverseRemove(this, YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS, YSuspectInfo.class, msgs);
+				return basicSetNextFocus((YSuspectInfo)otherEnd, msgs);
+			case YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS:
+				if (previousFocus != null)
+					msgs = ((InternalEObject)previousFocus).eInverseRemove(this, YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS, YSuspectInfo.class, msgs);
+				return basicSetPreviousFocus((YSuspectInfo)otherEnd, msgs);
+		}
+		return super.eInverseAdd(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT_INFO__PROPERTIES:
+				return ((InternalEList<?>)getProperties()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSUSPECT_INFO__BINDINGS:
+				return ((InternalEList<?>)getBindings()).basicRemove(otherEnd, msgs);
+			case YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS:
+				return basicSetNextFocus(null, msgs);
+			case YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS:
+				return basicSetPreviousFocus(null, msgs);
+			case YECviewPackage.YSUSPECT_INFO__VISIBILITY_PROCESSORS:
+				return ((InternalEList<?>)getVisibilityProcessors()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT_INFO__TAGS:
+				return getTags();
+			case YECviewPackage.YSUSPECT_INFO__ID:
+				return getId();
+			case YECviewPackage.YSUSPECT_INFO__NAME:
+				return getName();
+			case YECviewPackage.YSUSPECT_INFO__PROPERTIES:
+				if (coreType) return getProperties();
+				else return getProperties().map();
+			case YECviewPackage.YSUSPECT_INFO__SUSPECT:
+				if (resolve) return getSuspect();
+				return basicGetSuspect();
+			case YECviewPackage.YSUSPECT_INFO__BINDINGS:
+				return getBindings();
+			case YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS:
+				if (resolve) return getNextFocus();
+				return basicGetNextFocus();
+			case YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS:
+				if (resolve) return getPreviousFocus();
+				return basicGetPreviousFocus();
+			case YECviewPackage.YSUSPECT_INFO__TARGET:
+				if (resolve) return getTarget();
+				return basicGetTarget();
+			case YECviewPackage.YSUSPECT_INFO__VISIBILITY_PROCESSORS:
+				return getVisibilityProcessors();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT_INFO__TAGS:
+				getTags().clear();
+				getTags().addAll((Collection<? extends String>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__ID:
+				setId((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__NAME:
+				setName((String)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__PROPERTIES:
+				((EStructuralFeature.Setting)getProperties()).set(newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__SUSPECT:
+				setSuspect((YSuspect)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__BINDINGS:
+				getBindings().clear();
+				getBindings().addAll((Collection<? extends YBinding>)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS:
+				setNextFocus((YSuspectInfo)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS:
+				setPreviousFocus((YSuspectInfo)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__TARGET:
+				setTarget((YEmbeddable)newValue);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__VISIBILITY_PROCESSORS:
+				getVisibilityProcessors().clear();
+				getVisibilityProcessors().addAll((Collection<? extends YVisibilityProcessor>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT_INFO__TAGS:
+				getTags().clear();
+				return;
+			case YECviewPackage.YSUSPECT_INFO__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__PROPERTIES:
+				getProperties().clear();
+				return;
+			case YECviewPackage.YSUSPECT_INFO__SUSPECT:
+				setSuspect((YSuspect)null);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__BINDINGS:
+				getBindings().clear();
+				return;
+			case YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS:
+				setNextFocus((YSuspectInfo)null);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS:
+				setPreviousFocus((YSuspectInfo)null);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__TARGET:
+				setTarget((YEmbeddable)null);
+				return;
+			case YECviewPackage.YSUSPECT_INFO__VISIBILITY_PROCESSORS:
+				getVisibilityProcessors().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YSUSPECT_INFO__TAGS:
+				return tags != null && !tags.isEmpty();
+			case YECviewPackage.YSUSPECT_INFO__ID:
+				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
+			case YECviewPackage.YSUSPECT_INFO__NAME:
+				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+			case YECviewPackage.YSUSPECT_INFO__PROPERTIES:
+				return properties != null && !properties.isEmpty();
+			case YECviewPackage.YSUSPECT_INFO__SUSPECT:
+				return suspect != null;
+			case YECviewPackage.YSUSPECT_INFO__BINDINGS:
+				return bindings != null && !bindings.isEmpty();
+			case YECviewPackage.YSUSPECT_INFO__NEXT_FOCUS:
+				return nextFocus != null;
+			case YECviewPackage.YSUSPECT_INFO__PREVIOUS_FOCUS:
+				return previousFocus != null;
+			case YECviewPackage.YSUSPECT_INFO__TARGET:
+				return target != null;
+			case YECviewPackage.YSUSPECT_INFO__VISIBILITY_PROCESSORS:
+				return visibilityProcessors != null && !visibilityProcessors.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (tags: ");
+		result.append(tags);
+		result.append(", id: ");
+		result.append(id);
+		result.append(", name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
+	}
+
+	/**
+	 * Gets the view.
+	 *
+	 * @return the view
+	 * @generated NOT
+	 */
+	public YView getView() {
+		return findViewGeneric(eContainer());
+	}
+
+	/**
+	 * Find view generic.
+	 *
+	 * @param container
+	 *            the container
+	 * @return the y view
+	 */
+	protected YView findViewGeneric(EObject container) {
+		if (container == null) {
+			return null;
+		}
+		if (container instanceof YView) {
+			return (YView) container;
+		} else if (container instanceof YLayout) {
+			return ((YLayout) container).getView();
+		} else {
+			EObject parent = container.eContainer();
+			return findViewGeneric(parent);
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YTypedCompoundSuspectImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YTypedCompoundSuspectImpl.java
new file mode 100644
index 0000000..1e0ad3c
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YTypedCompoundSuspectImpl.java
@@ -0,0 +1,191 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YTyped Compound Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YTypedCompoundSuspectImpl#getChildren <em>Children</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YTypedCompoundSuspectImpl extends YTypedSuspectImpl implements YTypedCompoundSuspect {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached value of the '{@link #getChildren() <em>Children</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getChildren()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<YSuspect> children;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YTypedCompoundSuspectImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YTYPED_COMPOUND_SUSPECT;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getChildren() <em>Children</em>}
+	 *         ' containment reference list
+	 * @generated
+	 */
+	public EList<YSuspect> getChildren() {
+		if (children == null) {
+			children = new EObjectContainmentEList<YSuspect>(YSuspect.class, this, YECviewPackage.YTYPED_COMPOUND_SUSPECT__CHILDREN);
+		}
+		return children;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param otherEnd
+	 *            the other end
+	 * @param featureID
+	 *            the feature id
+	 * @param msgs
+	 *            the msgs
+	 * @return the notification chain
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT__CHILDREN:
+				return ((InternalEList<?>)getChildren()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT__CHILDREN:
+				return getChildren();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT__CHILDREN:
+				getChildren().clear();
+				getChildren().addAll((Collection<? extends YSuspect>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT__CHILDREN:
+				getChildren().clear();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT__CHILDREN:
+				return children != null && !children.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YTypedSuspectImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YTypedSuspectImpl.java
new file mode 100644
index 0000000..581389a
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YTypedSuspectImpl.java
@@ -0,0 +1,250 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YTypedSuspect;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YTyped Suspect</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YTypedSuspectImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YTypedSuspectImpl#getType <em>Type</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YTypedSuspectImpl extends YSuspectImpl implements YTypedSuspect {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YTypedSuspectImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YECviewPackage.Literals.YTYPED_SUSPECT;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getTypeQualifiedName()
+	 *         <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newTypeQualifiedName
+	 *            the new cached value of the '{@link #getTypeQualifiedName()
+	 *            <em>Type Qualified Name</em>}' attribute
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YTYPED_SUSPECT__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the cached value of the '{@link #getType() <em>Type</em>}'
+	 *         attribute
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param newType
+	 *            the new cached value of the '{@link #getType() <em>Type</em>}'
+	 *            attribute
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YTYPED_SUSPECT__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param resolve
+	 *            the resolve
+	 * @param coreType
+	 *            the core type
+	 * @return the object
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_SUSPECT__TYPE_QUALIFIED_NAME:
+				return getTypeQualifiedName();
+			case YECviewPackage.YTYPED_SUSPECT__TYPE:
+				return getType();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @param newValue
+	 *            the new value
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_SUSPECT__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName((String)newValue);
+				return;
+			case YECviewPackage.YTYPED_SUSPECT__TYPE:
+				setType((Class<?>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_SUSPECT__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+			case YECviewPackage.YTYPED_SUSPECT__TYPE:
+				setType((Class<?>)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param featureID
+	 *            the feature id
+	 * @return true, if successful
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YECviewPackage.YTYPED_SUSPECT__TYPE_QUALIFIED_NAME:
+				return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+			case YECviewPackage.YTYPED_SUSPECT__TYPE:
+				return type != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the string
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(", type: ");
+		result.append(type);
+		result.append(')');
+		return result.toString();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/SimpleECviewExtensionModelFactory.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/SimpleECviewExtensionModelFactory.java
new file mode 100644
index 0000000..4875d50
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/SimpleECviewExtensionModelFactory.java
@@ -0,0 +1,606 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.util;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.util.SimpleCoreModelFactory;
+import org.eclipse.osbp.ecview.core.common.model.validation.ValidationFactory;
+import org.eclipse.osbp.ecview.core.common.model.validation.YBeanValidationValidator;
+import org.eclipse.osbp.ecview.core.common.model.validation.YClassDelegateValidator;
+import org.eclipse.osbp.ecview.core.common.model.validation.YMaxLengthValidator;
+import org.eclipse.osbp.ecview.core.common.model.validation.YMinLengthValidator;
+import org.eclipse.osbp.ecview.core.common.model.validation.YRegexpValidator;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YCheckBoxDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YComboBoxDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YDecimalDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YListDataType;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YNumericDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YProgressBarDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YTableDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YTextAreaDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YTextDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.YTreeDatatype;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBrowser;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YButton;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YCheckBox;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YColumn;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YComboBox;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YCssLayout;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YCssLayoutCellStyle;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YDateTime;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YDecimalField;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YFormLayout;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YGridLayout;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YGridLayoutCellStyle;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YHorizontalLayout;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YHorizontalLayoutCellStyle;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YImage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YLabel;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YList;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YMasterDetail;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YNumericField;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YOptionsGroup;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YPanel;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YProgressBar;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YSlider;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YSpanInfo;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YSplitPanel;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTab;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTabSheet;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTextArea;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTextField;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YTree;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YVerticalLayout;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YVerticalLayoutCellStyle;
+import org.eclipse.osbp.ecview.extension.model.YCustomDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
+
+/**
+ * A factory for creating SimpleECviewExtensionModel objects.
+ */
+public class SimpleECviewExtensionModelFactory extends SimpleCoreModelFactory {
+
+	/** The extfactory. */
+	private ExtensionModelFactory extfactory = ExtensionModelFactory.eINSTANCE;
+	
+	/** The dt factory. */
+	private ExtDatatypesFactory dtFactory = ExtDatatypesFactory.eINSTANCE;
+	
+	/** The ec factory. */
+	private YECviewFactory ecFactory = YECviewFactory.eINSTANCE;
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y text field
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYTextField()
+	 */
+	public YTextField createTextField() {
+		return extfactory.createYTextField();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y image
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYImage()
+	 */
+	public YImage createImage() {
+		return extfactory.createYImage();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y progress bar
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYProgressBar()
+	 */
+	public YProgressBar createProgressBar() {
+		return extfactory.createYProgressBar();
+	}
+	
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y slider
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYSlider()
+	 */
+	public YSlider createSlider() {
+		return extfactory.createYSlider();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y grid layout
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYGridLayout()
+	 */
+	public YGridLayout createGridLayout() {
+		return extfactory.createYGridLayout();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y grid layout cell style
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYGridLayoutCellStyle()
+	 */
+	public YGridLayoutCellStyle createGridLayoutCellStyle() {
+		return extfactory.createYGridLayoutCellStyle();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y css layout
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYHorizontalLayout()
+	 */
+	public YCssLayout createCssLayout() {
+		return extfactory.createYCssLayout();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y css layout cell style
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYHorizontalLayoutCellStyle()
+	 */
+	public YCssLayoutCellStyle createCssLayoutCellStyle() {
+		return extfactory.createYCssLayoutCellStyle();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y horizontal layout
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYHorizontalLayout()
+	 */
+	public YHorizontalLayout createHorizontalLayout() {
+		return extfactory.createYHorizontalLayout();
+	}
+	
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y horizontal layout cell style
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYHorizontalLayoutCellStyle()
+	 */
+	public YHorizontalLayoutCellStyle createHorizontalLayoutCellStyle() {
+		return extfactory.createYHorizontalLayoutCellStyle();
+	}
+	
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y vertical layout
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYVerticalLayout()
+	 */
+	public YVerticalLayout createVerticalLayout() {
+		return extfactory.createYVerticalLayout();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y form layout
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYFormLayout()
+	 */
+	public YFormLayout createFormLayout() {
+		return extfactory.createYFormLayout();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y vertical layout cell style
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYVerticalLayoutCellStyle()
+	 */
+	public YVerticalLayoutCellStyle createVerticalLayoutCellStyle() {
+		return extfactory.createYVerticalLayoutCellStyle();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y span info
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYSpanInfo()
+	 */
+	public YSpanInfo createSpanInfo() {
+		return extfactory.createYSpanInfo();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y table
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYTable()
+	 */
+	public YTable createTable() {
+		return extfactory.createYTable();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y column
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#creatYColumn()
+	 */
+	public YColumn createColumn() {
+		return ExtensionModelFactory.eINSTANCE.createYColumn();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y tab sheet
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYTable()
+	 */
+	public YTabSheet createTabSheet() {
+		return extfactory.createYTabSheet();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y tab
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYTable()
+	 */
+	public YTab createTab() {
+		return extfactory.createYTab();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y tree
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYTree()
+	 */
+	public YTree createTree() {
+		return extfactory.createYTree();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y label
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYLabel()
+	 */
+	public YLabel createLabel() {
+		return extfactory.createYLabel();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y text area
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYTextArea()
+	 */
+	public YTextArea createTextArea() {
+		return extfactory.createYTextArea();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y browser
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYBrowser()
+	 */
+	public YBrowser createBrowser() {
+		return extfactory.createYBrowser();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y date time
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYDateTime()
+	 */
+	public YDateTime createDateTime() {
+		return extfactory.createYDateTime();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y check box
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYCheckBox()
+	 */
+	public YCheckBox createCheckBox() {
+		return extfactory.createYCheckBox();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y decimal field
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYDecimalField()
+	 */
+	public YDecimalField createDecimalField() {
+		return extfactory.createYDecimalField();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y custom decimal field
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYDecimalField()
+	 */
+	public YCustomDecimalField createCustomDecimalField() {
+		return ecFactory.createYCustomDecimalField();
+	}
+	
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y numeric field
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYNumericField()
+	 */
+	public YNumericField createNumericField() {
+		return extfactory.createYNumericField();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y combo box
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYComboBox()
+	 */
+	public YComboBox createComboBox() {
+		return extfactory.createYComboBox();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y list
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYList()
+	 */
+	public YList createList() {
+		return extfactory.createYList();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y options group
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYOptionsGroup()
+	 */
+	public YOptionsGroup createOptionsGroup() {
+		return extfactory.createYOptionsGroup();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y button
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory#createYButton()
+	 */
+	public YButton createButton() {
+		return extfactory.createYButton();
+	}
+	
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y split panel
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYSplitPanel()
+	 */
+	public YSplitPanel createSplitPanel() {
+		return extfactory.createYSplitPanel();
+	}
+	
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y panel
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYPanel()
+	 */
+	public YPanel createPanel() {
+		return extfactory.createYPanel();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y text datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYTextDatatype()
+	 */
+	public YTextDatatype createTextDatatype() {
+		return dtFactory.createYTextDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y progress bar datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYProgressBarDatatype()
+	 */
+	public YProgressBarDatatype createProgressBarDatatype() {
+		return dtFactory.createYProgressBarDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y text area datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYTextAreaDatatype()
+	 */
+	public YTextAreaDatatype createTextAreaDatatype() {
+		return dtFactory.createYTextAreaDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y numeric datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYNumericDatatype()
+	 */
+	public YNumericDatatype createNumericDatatype() {
+		return dtFactory.createYNumericDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y decimal datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYDecimalDatatype()
+	 */
+	public YDecimalDatatype createDecimalDatatype() {
+		return dtFactory.createYDecimalDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y table datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYTableDatatype()
+	 */
+	public YTableDatatype createTableDatatype() {
+		return dtFactory.createYTableDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y tree datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYTreeDatatype()
+	 */
+	public YTreeDatatype createTreeDatatype() {
+		return dtFactory.createYTreeDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y check box datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYCheckBoxDatatype()
+	 */
+	public YCheckBoxDatatype createCheckBoxDatatype() {
+		return dtFactory.createYCheckBoxDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y combo box datatype
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYComboBoxDatatype()
+	 */
+	public YComboBoxDatatype createComboBoxDatatype() {
+		return dtFactory.createYComboBoxDatatype();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y list data type
+	 * @see org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesFactory#createYListDataType()
+	 */
+	public YListDataType createListDataType() {
+		return dtFactory.createYListDataType();
+	}
+	
+	/**
+	 * Creates an instance of {@link YHorizontalLayoutCellStyle}.
+	 *
+	 * @param yComponent
+	 *            set as target
+	 * @param yLayout
+	 *            style added to this layout
+	 * @return the y horizontal layout cell style
+	 */
+	public YHorizontalLayoutCellStyle createHorizontalLayoutCellStyle(
+			YEmbeddable yComponent, YHorizontalLayout yLayout) {
+		YHorizontalLayoutCellStyle yStyle = ExtensionModelFactory.eINSTANCE
+				.createYHorizontalLayoutCellStyle();
+		yStyle.setTarget(yComponent);
+		yLayout.getCellStyles().add(yStyle);
+		return yStyle;
+	}
+
+	/**
+	 * Creates an instance of {@link YVerticalLayoutCellStyle}.
+	 *
+	 * @param yComponent
+	 *            set as target
+	 * @param yLayout
+	 *            style added to this layout
+	 * @return the y vertical layout cell style
+	 */
+	public YVerticalLayoutCellStyle createVerticalLayoutCellStyle(
+			YEmbeddable yComponent, YVerticalLayout yLayout) {
+		YVerticalLayoutCellStyle yStyle = ExtensionModelFactory.eINSTANCE
+				.createYVerticalLayoutCellStyle();
+		yStyle.setTarget(yComponent);
+		yLayout.getCellStyles().add(yStyle);
+		return yStyle;
+	}
+
+	/**
+	 * Returns a master detail element.
+	 *
+	 * @return the y master detail
+	 */
+	public YMasterDetail createMasterDetail() {
+		return ExtensionModelFactory.eINSTANCE.createYMasterDetail();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y max length validator
+	 */
+	public YMaxLengthValidator createMaxLengthValidator() {
+		return ValidationFactory.eINSTANCE.createYMaxLengthValidator();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y min length validator
+	 */
+	public YMinLengthValidator createMinLengthValidator() {
+		return ValidationFactory.eINSTANCE.createYMinLengthValidator();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y regexp validator
+	 */
+	public YRegexpValidator createRegexpValidator() {
+		return ValidationFactory.eINSTANCE.createYRegexpValidator();
+	}
+
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y class delegate validator
+	 */
+	public YClassDelegateValidator createClassDelegateValidator() {
+		return ValidationFactory.eINSTANCE.createYClassDelegateValidator();
+	}
+	
+	/**
+	 * Creates a new SimpleECviewExtensionModel object.
+	 *
+	 * @return the y bean validation validator
+	 */
+	public YBeanValidationValidator createBeanValidationValidator() {
+		return ValidationFactory.eINSTANCE.createYBeanValidationValidator();
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/YECviewAdapterFactory.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/YECviewAdapterFactory.java
new file mode 100644
index 0000000..0457766
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/YECviewAdapterFactory.java
@@ -0,0 +1,973 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCssAble;
+import org.eclipse.osbp.ecview.core.common.model.core.YEditable;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEnable;
+import org.eclipse.osbp.ecview.core.common.model.core.YField;
+import org.eclipse.osbp.ecview.core.common.model.core.YFocusable;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YMarginable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSpacingable;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YVisibleable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+import org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent;
+import org.eclipse.osbp.ecview.extension.model.YCollectionSuspect;
+import org.eclipse.osbp.ecview.extension.model.YColumnInfo;
+import org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout;
+import org.eclipse.osbp.ecview.extension.model.YCustomDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YIconComboBox;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedNumericField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YPairComboBox;
+import org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YQuantityTextField;
+import org.eclipse.osbp.ecview.extension.model.YRichTextArea;
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+import org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect;
+import org.eclipse.osbp.ecview.extension.model.YTypedSuspect;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage
+ * @generated
+ */
+public class YECviewAdapterFactory extends AdapterFactoryImpl {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static YECviewPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YECviewAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = YECviewPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc --> This implementation returns <code>true</code> if
+	 * the object is either the model's package or is an instance object of the
+	 * model. <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YECviewSwitch<Adapter> modelSwitch =
+		new YECviewSwitch<Adapter>() {
+			@Override
+			public Adapter caseYStrategyLayout(YStrategyLayout object) {
+				return createYStrategyLayoutAdapter();
+			}
+			@Override
+			public Adapter caseYLayoutingStrategy(YLayoutingStrategy object) {
+				return createYLayoutingStrategyAdapter();
+			}
+			@Override
+			public Adapter caseYDefaultLayoutingStrategy(YDefaultLayoutingStrategy object) {
+				return createYDefaultLayoutingStrategyAdapter();
+			}
+			@Override
+			public Adapter caseYFocusingStrategy(YFocusingStrategy object) {
+				return createYFocusingStrategyAdapter();
+			}
+			@Override
+			public Adapter caseYDelegatingLayoutingStrategy(YDelegatingLayoutingStrategy object) {
+				return createYDelegatingLayoutingStrategyAdapter();
+			}
+			@Override
+			public Adapter caseYDelegatingFocusingStrategy(YDelegatingFocusingStrategy object) {
+				return createYDelegatingFocusingStrategyAdapter();
+			}
+			@Override
+			public Adapter caseYSuspect(YSuspect object) {
+				return createYSuspectAdapter();
+			}
+			@Override
+			public Adapter caseYTypedSuspect(YTypedSuspect object) {
+				return createYTypedSuspectAdapter();
+			}
+			@Override
+			public Adapter caseYTypedCompoundSuspect(YTypedCompoundSuspect object) {
+				return createYTypedCompoundSuspectAdapter();
+			}
+			@Override
+			public Adapter caseYSubTypeBaseSuspect(YSubTypeBaseSuspect object) {
+				return createYSubTypeBaseSuspectAdapter();
+			}
+			@Override
+			public Adapter caseYSubTypeSuspect(YSubTypeSuspect object) {
+				return createYSubTypeSuspectAdapter();
+			}
+			@Override
+			public Adapter caseYLayoutingInfo(YLayoutingInfo object) {
+				return createYLayoutingInfoAdapter();
+			}
+			@Override
+			public Adapter caseYSuspectInfo(YSuspectInfo object) {
+				return createYSuspectInfoAdapter();
+			}
+			@Override
+			public Adapter caseYBlobUploadComponent(YBlobUploadComponent object) {
+				return createYBlobUploadComponentAdapter();
+			}
+			@Override
+			public Adapter caseYCustomDecimalField(YCustomDecimalField object) {
+				return createYCustomDecimalFieldAdapter();
+			}
+			@Override
+			public Adapter caseYIconComboBox(YIconComboBox object) {
+				return createYIconComboBoxAdapter();
+			}
+			@Override
+			public Adapter caseYQuantityTextField(YQuantityTextField object) {
+				return createYQuantityTextFieldAdapter();
+			}
+			@Override
+			public Adapter caseYCollectionSuspect(YCollectionSuspect object) {
+				return createYCollectionSuspectAdapter();
+			}
+			@Override
+			public Adapter caseYColumnInfo(YColumnInfo object) {
+				return createYColumnInfoAdapter();
+			}
+			@Override
+			public Adapter caseYContentSensitiveLayout(YContentSensitiveLayout object) {
+				return createYContentSensitiveLayoutAdapter();
+			}
+			@Override
+			public Adapter caseYRichTextArea(YRichTextArea object) {
+				return createYRichTextAreaAdapter();
+			}
+			@Override
+			public Adapter caseYMaskedTextField(YMaskedTextField object) {
+				return createYMaskedTextFieldAdapter();
+			}
+			@Override
+			public Adapter caseYPrefixedMaskedTextField(YPrefixedMaskedTextField object) {
+				return createYPrefixedMaskedTextFieldAdapter();
+			}
+			@Override
+			public Adapter caseYMaskedNumericField(YMaskedNumericField object) {
+				return createYMaskedNumericFieldAdapter();
+			}
+			@Override
+			public Adapter caseYMaskedDecimalField(YMaskedDecimalField object) {
+				return createYMaskedDecimalFieldAdapter();
+			}
+			@Override
+			public Adapter caseYPairComboBox(YPairComboBox object) {
+				return createYPairComboBoxAdapter();
+			}
+			@Override
+			public Adapter caseYTaggable(YTaggable object) {
+				return createYTaggableAdapter();
+			}
+			@Override
+			public Adapter caseYElement(YElement object) {
+				return createYElementAdapter();
+			}
+			@Override
+			public Adapter caseYCssAble(YCssAble object) {
+				return createYCssAbleAdapter();
+			}
+			@Override
+			public Adapter caseYVisibleable(YVisibleable object) {
+				return createYVisibleableAdapter();
+			}
+			@Override
+			public Adapter caseYAuthorizationable(YAuthorizationable object) {
+				return createYAuthorizationableAdapter();
+			}
+			@Override
+			public Adapter caseYEmbeddable(YEmbeddable object) {
+				return createYEmbeddableAdapter();
+			}
+			@Override
+			public Adapter caseYEditable(YEditable object) {
+				return createYEditableAdapter();
+			}
+			@Override
+			public Adapter caseYEnable(YEnable object) {
+				return createYEnableAdapter();
+			}
+			@Override
+			public Adapter caseYFocusable(YFocusable object) {
+				return createYFocusableAdapter();
+			}
+			@Override
+			public Adapter caseYField(YField object) {
+				return createYFieldAdapter();
+			}
+			@Override
+			public Adapter caseYInput(YInput object) {
+				return createYInputAdapter();
+			}
+			@Override
+			public Adapter caseYBindable(YBindable object) {
+				return createYBindableAdapter();
+			}
+			@Override
+			public Adapter caseYValueBindable(YValueBindable object) {
+				return createYValueBindableAdapter();
+			}
+			@Override
+			public Adapter caseYCollectionBindable(YCollectionBindable object) {
+				return createYCollectionBindableAdapter();
+			}
+			@Override
+			public Adapter caseYSelectionBindable(YSelectionBindable object) {
+				return createYSelectionBindableAdapter();
+			}
+			@Override
+			public Adapter caseYBeanServiceConsumer(YBeanServiceConsumer object) {
+				return createYBeanServiceConsumerAdapter();
+			}
+			@Override
+			public Adapter caseYLayout(YLayout object) {
+				return createYLayoutAdapter();
+			}
+			@Override
+			public Adapter caseYSpacingable(YSpacingable object) {
+				return createYSpacingableAdapter();
+			}
+			@Override
+			public Adapter caseYMarginable(YMarginable object) {
+				return createYMarginableAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout <em>YStrategy Layout</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout
+	 * @generated
+	 */
+	public Adapter createYStrategyLayoutAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy <em>YLayouting Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy
+	 * @generated
+	 */
+	public Adapter createYLayoutingStrategyAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy <em>YDefault Layouting Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy
+	 * @generated
+	 */
+	public Adapter createYDefaultLayoutingStrategyAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YFocusingStrategy <em>YFocusing Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YFocusingStrategy
+	 * @generated
+	 */
+	public Adapter createYFocusingStrategyAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy <em>YDelegating Layouting Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy
+	 * @generated
+	 */
+	public Adapter createYDelegatingLayoutingStrategyAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy <em>YDelegating Focusing Strategy</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy
+	 * @generated
+	 */
+	public Adapter createYDelegatingFocusingStrategyAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YSuspect <em>YSuspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect
+	 * @generated
+	 */
+	public Adapter createYSuspectAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo <em>YLayouting Info</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YLayoutingInfo
+	 * @generated
+	 */
+	public Adapter createYLayoutingInfoAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YSuspectInfo <em>YSuspect Info</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspectInfo
+	 * @generated
+	 */
+	public Adapter createYSuspectInfoAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent <em>YBlob Upload Component</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent
+	 * @generated
+	 */
+	public Adapter createYBlobUploadComponentAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YTypedSuspect <em>YTyped Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YTypedSuspect
+	 * @generated
+	 */
+	public Adapter createYTypedSuspectAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect <em>YTyped Compound Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect
+	 * @generated
+	 */
+	public Adapter createYTypedCompoundSuspectAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect <em>YSub Type Base Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect
+	 * @generated
+	 */
+	public Adapter createYSubTypeBaseSuspectAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect <em>YSub Type Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect
+	 * @generated
+	 */
+	public Adapter createYSubTypeSuspectAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YCustomDecimalField <em>YCustom Decimal Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCustomDecimalField
+	 * @generated
+	 */
+	public Adapter createYCustomDecimalFieldAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YIconComboBox <em>YIcon Combo Box</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YIconComboBox
+	 * @generated
+	 */
+	public Adapter createYIconComboBoxAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YQuantityTextField <em>YQuantity Text Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YQuantityTextField
+	 * @generated
+	 */
+	public Adapter createYQuantityTextFieldAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YCollectionSuspect <em>YCollection Suspect</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YCollectionSuspect
+	 * @generated
+	 */
+	public Adapter createYCollectionSuspectAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YColumnInfo <em>YColumn Info</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YColumnInfo
+	 * @generated
+	 */
+	public Adapter createYColumnInfoAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout <em>YContent Sensitive Layout</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout
+	 * @generated
+	 */
+	public Adapter createYContentSensitiveLayoutAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YRichTextArea <em>YRich Text Area</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YRichTextArea
+	 * @generated
+	 */
+	public Adapter createYRichTextAreaAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YMaskedTextField <em>YMasked Text Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedTextField
+	 * @generated
+	 */
+	public Adapter createYMaskedTextFieldAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField <em>YPrefixed Masked Text Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField
+	 * @generated
+	 */
+	public Adapter createYPrefixedMaskedTextFieldAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YMaskedNumericField <em>YMasked Numeric Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedNumericField
+	 * @generated
+	 */
+	public Adapter createYMaskedNumericFieldAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField <em>YMasked Decimal Field</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField
+	 * @generated
+	 */
+	public Adapter createYMaskedDecimalFieldAdapter() {
+		return null;
+	}
+	
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.YPairComboBox <em>YPair Combo Box</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.YPairComboBox
+	 * @generated
+	 */
+	public Adapter createYPairComboBoxAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YTaggable <em>YTaggable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YTaggable
+	 * @generated
+	 */
+	public Adapter createYTaggableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YElement <em>YElement</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YElement
+	 * @generated
+	 */
+	public Adapter createYElementAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YCssAble <em>YCss Able</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCssAble
+	 * @generated
+	 */
+	public Adapter createYCssAbleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YVisibleable <em>YVisibleable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YVisibleable
+	 * @generated
+	 */
+	public Adapter createYVisibleableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable <em>YAuthorizationable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable
+	 * @generated
+	 */
+	public Adapter createYAuthorizationableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable <em>YEmbeddable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable
+	 * @generated
+	 */
+	public Adapter createYEmbeddableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YEditable <em>YEditable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YEditable
+	 * @generated
+	 */
+	public Adapter createYEditableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YEnable <em>YEnable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YEnable
+	 * @generated
+	 */
+	public Adapter createYEnableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YFocusable <em>YFocusable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YFocusable
+	 * @generated
+	 */
+	public Adapter createYFocusableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YField <em>YField</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YField
+	 * @generated
+	 */
+	public Adapter createYFieldAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.extension.model.extension.YInput <em>YInput</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.YInput
+	 * @generated
+	 */
+	public Adapter createYInputAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YBindable <em>YBindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YBindable
+	 * @generated
+	 */
+	public Adapter createYBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YValueBindable <em>YValue Bindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YValueBindable
+	 * @generated
+	 */
+	public Adapter createYValueBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable <em>YCollection Bindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable
+	 * @generated
+	 */
+	public Adapter createYCollectionBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable <em>YSelection Bindable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable
+	 * @generated
+	 */
+	public Adapter createYSelectionBindableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer <em>YBean Service Consumer</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer
+	 * @generated
+	 */
+	public Adapter createYBeanServiceConsumerAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YLayout <em>YLayout</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YLayout
+	 * @generated
+	 */
+	public Adapter createYLayoutAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YSpacingable <em>YSpacingable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YSpacingable
+	 * @generated
+	 */
+	public Adapter createYSpacingableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YMarginable <em>YMarginable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YMarginable
+	 * @generated
+	 */
+	public Adapter createYMarginableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/YECviewSwitch.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/YECviewSwitch.java
new file mode 100644
index 0000000..168faff
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/util/YECviewSwitch.java
@@ -0,0 +1,1177 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.osbp.ecview.core.common.model.core.YAuthorizationable;
+import org.eclipse.osbp.ecview.core.common.model.core.YBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YCssAble;
+import org.eclipse.osbp.ecview.core.common.model.core.YEditable;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.core.YEnable;
+import org.eclipse.osbp.ecview.core.common.model.core.YField;
+import org.eclipse.osbp.ecview.core.common.model.core.YFocusable;
+import org.eclipse.osbp.ecview.core.common.model.core.YLayout;
+import org.eclipse.osbp.ecview.core.common.model.core.YMarginable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSelectionBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YSpacingable;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable;
+import org.eclipse.osbp.ecview.core.common.model.core.YVisibleable;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YBeanServiceConsumer;
+import org.eclipse.osbp.ecview.core.extension.model.extension.YInput;
+import org.eclipse.osbp.ecview.extension.model.YBlobUploadComponent;
+import org.eclipse.osbp.ecview.extension.model.YCollectionSuspect;
+import org.eclipse.osbp.ecview.extension.model.YColumnInfo;
+import org.eclipse.osbp.ecview.extension.model.YContentSensitiveLayout;
+import org.eclipse.osbp.ecview.extension.model.YCustomDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YDefaultLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YDelegatingLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YIconComboBox;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
+import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
+import org.eclipse.osbp.ecview.extension.model.YMaskedDecimalField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedNumericField;
+import org.eclipse.osbp.ecview.extension.model.YMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YPairComboBox;
+import org.eclipse.osbp.ecview.extension.model.YPrefixedMaskedTextField;
+import org.eclipse.osbp.ecview.extension.model.YQuantityTextField;
+import org.eclipse.osbp.ecview.extension.model.YRichTextArea;
+import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeBaseSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSubTypeSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspect;
+import org.eclipse.osbp.ecview.extension.model.YSuspectInfo;
+import org.eclipse.osbp.ecview.extension.model.YTypedCompoundSuspect;
+import org.eclipse.osbp.ecview.extension.model.YTypedSuspect;
+
+/**
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance
+ * hierarchy. It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the
+ * inheritance hierarchy until a non-null result is returned, which is the
+ * result of the switch. <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage
+ * @generated
+ */
+public class YECviewSwitch<T> extends Switch<T> {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected static YECviewPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YECviewSwitch() {
+		if (modelPackage == null) {
+			modelPackage = YECviewPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param ePackage
+	 *            the e package
+	 * @return whether this is a switch for the given package.
+	 * @parameter ePackage the package in question.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case YECviewPackage.YSTRATEGY_LAYOUT: {
+				YStrategyLayout yStrategyLayout = (YStrategyLayout)theEObject;
+				T result = caseYStrategyLayout(yStrategyLayout);
+				if (result == null) result = caseYEmbeddable(yStrategyLayout);
+				if (result == null) result = caseYElement(yStrategyLayout);
+				if (result == null) result = caseYCssAble(yStrategyLayout);
+				if (result == null) result = caseYVisibleable(yStrategyLayout);
+				if (result == null) result = caseYAuthorizationable(yStrategyLayout);
+				if (result == null) result = caseYTaggable(yStrategyLayout);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YLAYOUTING_STRATEGY: {
+				YLayoutingStrategy yLayoutingStrategy = (YLayoutingStrategy)theEObject;
+				T result = caseYLayoutingStrategy(yLayoutingStrategy);
+				if (result == null) result = caseYElement(yLayoutingStrategy);
+				if (result == null) result = caseYTaggable(yLayoutingStrategy);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YDEFAULT_LAYOUTING_STRATEGY: {
+				YDefaultLayoutingStrategy yDefaultLayoutingStrategy = (YDefaultLayoutingStrategy)theEObject;
+				T result = caseYDefaultLayoutingStrategy(yDefaultLayoutingStrategy);
+				if (result == null) result = caseYLayoutingStrategy(yDefaultLayoutingStrategy);
+				if (result == null) result = caseYElement(yDefaultLayoutingStrategy);
+				if (result == null) result = caseYTaggable(yDefaultLayoutingStrategy);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YFOCUSING_STRATEGY: {
+				YFocusingStrategy yFocusingStrategy = (YFocusingStrategy)theEObject;
+				T result = caseYFocusingStrategy(yFocusingStrategy);
+				if (result == null) result = caseYElement(yFocusingStrategy);
+				if (result == null) result = caseYTaggable(yFocusingStrategy);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YDELEGATING_LAYOUTING_STRATEGY: {
+				YDelegatingLayoutingStrategy yDelegatingLayoutingStrategy = (YDelegatingLayoutingStrategy)theEObject;
+				T result = caseYDelegatingLayoutingStrategy(yDelegatingLayoutingStrategy);
+				if (result == null) result = caseYLayoutingStrategy(yDelegatingLayoutingStrategy);
+				if (result == null) result = caseYElement(yDelegatingLayoutingStrategy);
+				if (result == null) result = caseYTaggable(yDelegatingLayoutingStrategy);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YDELEGATING_FOCUSING_STRATEGY: {
+				YDelegatingFocusingStrategy yDelegatingFocusingStrategy = (YDelegatingFocusingStrategy)theEObject;
+				T result = caseYDelegatingFocusingStrategy(yDelegatingFocusingStrategy);
+				if (result == null) result = caseYFocusingStrategy(yDelegatingFocusingStrategy);
+				if (result == null) result = caseYElement(yDelegatingFocusingStrategy);
+				if (result == null) result = caseYTaggable(yDelegatingFocusingStrategy);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YSUSPECT: {
+				YSuspect ySuspect = (YSuspect)theEObject;
+				T result = caseYSuspect(ySuspect);
+				if (result == null) result = caseYElement(ySuspect);
+				if (result == null) result = caseYAuthorizationable(ySuspect);
+				if (result == null) result = caseYTaggable(ySuspect);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YTYPED_SUSPECT: {
+				YTypedSuspect yTypedSuspect = (YTypedSuspect)theEObject;
+				T result = caseYTypedSuspect(yTypedSuspect);
+				if (result == null) result = caseYSuspect(yTypedSuspect);
+				if (result == null) result = caseYElement(yTypedSuspect);
+				if (result == null) result = caseYAuthorizationable(yTypedSuspect);
+				if (result == null) result = caseYTaggable(yTypedSuspect);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YTYPED_COMPOUND_SUSPECT: {
+				YTypedCompoundSuspect yTypedCompoundSuspect = (YTypedCompoundSuspect)theEObject;
+				T result = caseYTypedCompoundSuspect(yTypedCompoundSuspect);
+				if (result == null) result = caseYTypedSuspect(yTypedCompoundSuspect);
+				if (result == null) result = caseYSuspect(yTypedCompoundSuspect);
+				if (result == null) result = caseYElement(yTypedCompoundSuspect);
+				if (result == null) result = caseYAuthorizationable(yTypedCompoundSuspect);
+				if (result == null) result = caseYTaggable(yTypedCompoundSuspect);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YSUB_TYPE_BASE_SUSPECT: {
+				YSubTypeBaseSuspect ySubTypeBaseSuspect = (YSubTypeBaseSuspect)theEObject;
+				T result = caseYSubTypeBaseSuspect(ySubTypeBaseSuspect);
+				if (result == null) result = caseYTypedCompoundSuspect(ySubTypeBaseSuspect);
+				if (result == null) result = caseYTypedSuspect(ySubTypeBaseSuspect);
+				if (result == null) result = caseYSuspect(ySubTypeBaseSuspect);
+				if (result == null) result = caseYElement(ySubTypeBaseSuspect);
+				if (result == null) result = caseYAuthorizationable(ySubTypeBaseSuspect);
+				if (result == null) result = caseYTaggable(ySubTypeBaseSuspect);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YSUB_TYPE_SUSPECT: {
+				YSubTypeSuspect ySubTypeSuspect = (YSubTypeSuspect)theEObject;
+				T result = caseYSubTypeSuspect(ySubTypeSuspect);
+				if (result == null) result = caseYTypedCompoundSuspect(ySubTypeSuspect);
+				if (result == null) result = caseYTypedSuspect(ySubTypeSuspect);
+				if (result == null) result = caseYSuspect(ySubTypeSuspect);
+				if (result == null) result = caseYElement(ySubTypeSuspect);
+				if (result == null) result = caseYAuthorizationable(ySubTypeSuspect);
+				if (result == null) result = caseYTaggable(ySubTypeSuspect);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YLAYOUTING_INFO: {
+				YLayoutingInfo yLayoutingInfo = (YLayoutingInfo)theEObject;
+				T result = caseYLayoutingInfo(yLayoutingInfo);
+				if (result == null) result = caseYElement(yLayoutingInfo);
+				if (result == null) result = caseYTaggable(yLayoutingInfo);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YSUSPECT_INFO: {
+				YSuspectInfo ySuspectInfo = (YSuspectInfo)theEObject;
+				T result = caseYSuspectInfo(ySuspectInfo);
+				if (result == null) result = caseYElement(ySuspectInfo);
+				if (result == null) result = caseYTaggable(ySuspectInfo);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YBLOB_UPLOAD_COMPONENT: {
+				YBlobUploadComponent yBlobUploadComponent = (YBlobUploadComponent)theEObject;
+				T result = caseYBlobUploadComponent(yBlobUploadComponent);
+				if (result == null) result = caseYInput(yBlobUploadComponent);
+				if (result == null) result = caseYValueBindable(yBlobUploadComponent);
+				if (result == null) result = caseYField(yBlobUploadComponent);
+				if (result == null) result = caseYBindable(yBlobUploadComponent);
+				if (result == null) result = caseYEmbeddable(yBlobUploadComponent);
+				if (result == null) result = caseYEditable(yBlobUploadComponent);
+				if (result == null) result = caseYEnable(yBlobUploadComponent);
+				if (result == null) result = caseYFocusable(yBlobUploadComponent);
+				if (result == null) result = caseYElement(yBlobUploadComponent);
+				if (result == null) result = caseYCssAble(yBlobUploadComponent);
+				if (result == null) result = caseYVisibleable(yBlobUploadComponent);
+				if (result == null) result = caseYAuthorizationable(yBlobUploadComponent);
+				if (result == null) result = caseYTaggable(yBlobUploadComponent);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YCUSTOM_DECIMAL_FIELD: {
+				YCustomDecimalField yCustomDecimalField = (YCustomDecimalField)theEObject;
+				T result = caseYCustomDecimalField(yCustomDecimalField);
+				if (result == null) result = caseYInput(yCustomDecimalField);
+				if (result == null) result = caseYValueBindable(yCustomDecimalField);
+				if (result == null) result = caseYField(yCustomDecimalField);
+				if (result == null) result = caseYBindable(yCustomDecimalField);
+				if (result == null) result = caseYEmbeddable(yCustomDecimalField);
+				if (result == null) result = caseYEditable(yCustomDecimalField);
+				if (result == null) result = caseYEnable(yCustomDecimalField);
+				if (result == null) result = caseYFocusable(yCustomDecimalField);
+				if (result == null) result = caseYElement(yCustomDecimalField);
+				if (result == null) result = caseYCssAble(yCustomDecimalField);
+				if (result == null) result = caseYVisibleable(yCustomDecimalField);
+				if (result == null) result = caseYAuthorizationable(yCustomDecimalField);
+				if (result == null) result = caseYTaggable(yCustomDecimalField);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YICON_COMBO_BOX: {
+				YIconComboBox yIconComboBox = (YIconComboBox)theEObject;
+				T result = caseYIconComboBox(yIconComboBox);
+				if (result == null) result = caseYInput(yIconComboBox);
+				if (result == null) result = caseYCollectionBindable(yIconComboBox);
+				if (result == null) result = caseYSelectionBindable(yIconComboBox);
+				if (result == null) result = caseYBeanServiceConsumer(yIconComboBox);
+				if (result == null) result = caseYField(yIconComboBox);
+				if (result == null) result = caseYBindable(yIconComboBox);
+				if (result == null) result = caseYEmbeddable(yIconComboBox);
+				if (result == null) result = caseYEditable(yIconComboBox);
+				if (result == null) result = caseYEnable(yIconComboBox);
+				if (result == null) result = caseYFocusable(yIconComboBox);
+				if (result == null) result = caseYElement(yIconComboBox);
+				if (result == null) result = caseYCssAble(yIconComboBox);
+				if (result == null) result = caseYVisibleable(yIconComboBox);
+				if (result == null) result = caseYAuthorizationable(yIconComboBox);
+				if (result == null) result = caseYTaggable(yIconComboBox);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YQUANTITY_TEXT_FIELD: {
+				YQuantityTextField yQuantityTextField = (YQuantityTextField)theEObject;
+				T result = caseYQuantityTextField(yQuantityTextField);
+				if (result == null) result = caseYInput(yQuantityTextField);
+				if (result == null) result = caseYValueBindable(yQuantityTextField);
+				if (result == null) result = caseYField(yQuantityTextField);
+				if (result == null) result = caseYBindable(yQuantityTextField);
+				if (result == null) result = caseYEmbeddable(yQuantityTextField);
+				if (result == null) result = caseYEditable(yQuantityTextField);
+				if (result == null) result = caseYEnable(yQuantityTextField);
+				if (result == null) result = caseYFocusable(yQuantityTextField);
+				if (result == null) result = caseYElement(yQuantityTextField);
+				if (result == null) result = caseYCssAble(yQuantityTextField);
+				if (result == null) result = caseYVisibleable(yQuantityTextField);
+				if (result == null) result = caseYAuthorizationable(yQuantityTextField);
+				if (result == null) result = caseYTaggable(yQuantityTextField);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YCOLLECTION_SUSPECT: {
+				YCollectionSuspect yCollectionSuspect = (YCollectionSuspect)theEObject;
+				T result = caseYCollectionSuspect(yCollectionSuspect);
+				if (result == null) result = caseYTypedSuspect(yCollectionSuspect);
+				if (result == null) result = caseYSuspect(yCollectionSuspect);
+				if (result == null) result = caseYElement(yCollectionSuspect);
+				if (result == null) result = caseYAuthorizationable(yCollectionSuspect);
+				if (result == null) result = caseYTaggable(yCollectionSuspect);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YCOLUMN_INFO: {
+				YColumnInfo yColumnInfo = (YColumnInfo)theEObject;
+				T result = caseYColumnInfo(yColumnInfo);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YCONTENT_SENSITIVE_LAYOUT: {
+				YContentSensitiveLayout yContentSensitiveLayout = (YContentSensitiveLayout)theEObject;
+				T result = caseYContentSensitiveLayout(yContentSensitiveLayout);
+				if (result == null) result = caseYLayout(yContentSensitiveLayout);
+				if (result == null) result = caseYSpacingable(yContentSensitiveLayout);
+				if (result == null) result = caseYMarginable(yContentSensitiveLayout);
+				if (result == null) result = caseYEmbeddable(yContentSensitiveLayout);
+				if (result == null) result = caseYEditable(yContentSensitiveLayout);
+				if (result == null) result = caseYEnable(yContentSensitiveLayout);
+				if (result == null) result = caseYElement(yContentSensitiveLayout);
+				if (result == null) result = caseYCssAble(yContentSensitiveLayout);
+				if (result == null) result = caseYVisibleable(yContentSensitiveLayout);
+				if (result == null) result = caseYAuthorizationable(yContentSensitiveLayout);
+				if (result == null) result = caseYTaggable(yContentSensitiveLayout);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YRICH_TEXT_AREA: {
+				YRichTextArea yRichTextArea = (YRichTextArea)theEObject;
+				T result = caseYRichTextArea(yRichTextArea);
+				if (result == null) result = caseYInput(yRichTextArea);
+				if (result == null) result = caseYValueBindable(yRichTextArea);
+				if (result == null) result = caseYField(yRichTextArea);
+				if (result == null) result = caseYBindable(yRichTextArea);
+				if (result == null) result = caseYEmbeddable(yRichTextArea);
+				if (result == null) result = caseYEditable(yRichTextArea);
+				if (result == null) result = caseYEnable(yRichTextArea);
+				if (result == null) result = caseYFocusable(yRichTextArea);
+				if (result == null) result = caseYElement(yRichTextArea);
+				if (result == null) result = caseYCssAble(yRichTextArea);
+				if (result == null) result = caseYVisibleable(yRichTextArea);
+				if (result == null) result = caseYAuthorizationable(yRichTextArea);
+				if (result == null) result = caseYTaggable(yRichTextArea);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YMASKED_TEXT_FIELD: {
+				YMaskedTextField yMaskedTextField = (YMaskedTextField)theEObject;
+				T result = caseYMaskedTextField(yMaskedTextField);
+				if (result == null) result = caseYInput(yMaskedTextField);
+				if (result == null) result = caseYValueBindable(yMaskedTextField);
+				if (result == null) result = caseYField(yMaskedTextField);
+				if (result == null) result = caseYBindable(yMaskedTextField);
+				if (result == null) result = caseYEmbeddable(yMaskedTextField);
+				if (result == null) result = caseYEditable(yMaskedTextField);
+				if (result == null) result = caseYEnable(yMaskedTextField);
+				if (result == null) result = caseYFocusable(yMaskedTextField);
+				if (result == null) result = caseYElement(yMaskedTextField);
+				if (result == null) result = caseYCssAble(yMaskedTextField);
+				if (result == null) result = caseYVisibleable(yMaskedTextField);
+				if (result == null) result = caseYAuthorizationable(yMaskedTextField);
+				if (result == null) result = caseYTaggable(yMaskedTextField);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YPREFIXED_MASKED_TEXT_FIELD: {
+				YPrefixedMaskedTextField yPrefixedMaskedTextField = (YPrefixedMaskedTextField)theEObject;
+				T result = caseYPrefixedMaskedTextField(yPrefixedMaskedTextField);
+				if (result == null) result = caseYInput(yPrefixedMaskedTextField);
+				if (result == null) result = caseYValueBindable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYField(yPrefixedMaskedTextField);
+				if (result == null) result = caseYBindable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYEmbeddable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYEditable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYEnable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYFocusable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYElement(yPrefixedMaskedTextField);
+				if (result == null) result = caseYCssAble(yPrefixedMaskedTextField);
+				if (result == null) result = caseYVisibleable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYAuthorizationable(yPrefixedMaskedTextField);
+				if (result == null) result = caseYTaggable(yPrefixedMaskedTextField);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YMASKED_NUMERIC_FIELD: {
+				YMaskedNumericField yMaskedNumericField = (YMaskedNumericField)theEObject;
+				T result = caseYMaskedNumericField(yMaskedNumericField);
+				if (result == null) result = caseYInput(yMaskedNumericField);
+				if (result == null) result = caseYValueBindable(yMaskedNumericField);
+				if (result == null) result = caseYField(yMaskedNumericField);
+				if (result == null) result = caseYBindable(yMaskedNumericField);
+				if (result == null) result = caseYEmbeddable(yMaskedNumericField);
+				if (result == null) result = caseYEditable(yMaskedNumericField);
+				if (result == null) result = caseYEnable(yMaskedNumericField);
+				if (result == null) result = caseYFocusable(yMaskedNumericField);
+				if (result == null) result = caseYElement(yMaskedNumericField);
+				if (result == null) result = caseYCssAble(yMaskedNumericField);
+				if (result == null) result = caseYVisibleable(yMaskedNumericField);
+				if (result == null) result = caseYAuthorizationable(yMaskedNumericField);
+				if (result == null) result = caseYTaggable(yMaskedNumericField);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YMASKED_DECIMAL_FIELD: {
+				YMaskedDecimalField yMaskedDecimalField = (YMaskedDecimalField)theEObject;
+				T result = caseYMaskedDecimalField(yMaskedDecimalField);
+				if (result == null) result = caseYInput(yMaskedDecimalField);
+				if (result == null) result = caseYValueBindable(yMaskedDecimalField);
+				if (result == null) result = caseYField(yMaskedDecimalField);
+				if (result == null) result = caseYBindable(yMaskedDecimalField);
+				if (result == null) result = caseYEmbeddable(yMaskedDecimalField);
+				if (result == null) result = caseYEditable(yMaskedDecimalField);
+				if (result == null) result = caseYEnable(yMaskedDecimalField);
+				if (result == null) result = caseYFocusable(yMaskedDecimalField);
+				if (result == null) result = caseYElement(yMaskedDecimalField);
+				if (result == null) result = caseYCssAble(yMaskedDecimalField);
+				if (result == null) result = caseYVisibleable(yMaskedDecimalField);
+				if (result == null) result = caseYAuthorizationable(yMaskedDecimalField);
+				if (result == null) result = caseYTaggable(yMaskedDecimalField);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YECviewPackage.YPAIR_COMBO_BOX: {
+				YPairComboBox yPairComboBox = (YPairComboBox)theEObject;
+				T result = caseYPairComboBox(yPairComboBox);
+				if (result == null) result = caseYInput(yPairComboBox);
+				if (result == null) result = caseYCollectionBindable(yPairComboBox);
+				if (result == null) result = caseYSelectionBindable(yPairComboBox);
+				if (result == null) result = caseYBeanServiceConsumer(yPairComboBox);
+				if (result == null) result = caseYField(yPairComboBox);
+				if (result == null) result = caseYBindable(yPairComboBox);
+				if (result == null) result = caseYEmbeddable(yPairComboBox);
+				if (result == null) result = caseYEditable(yPairComboBox);
+				if (result == null) result = caseYEnable(yPairComboBox);
+				if (result == null) result = caseYFocusable(yPairComboBox);
+				if (result == null) result = caseYElement(yPairComboBox);
+				if (result == null) result = caseYCssAble(yPairComboBox);
+				if (result == null) result = caseYVisibleable(yPairComboBox);
+				if (result == null) result = caseYAuthorizationable(yPairComboBox);
+				if (result == null) result = caseYTaggable(yPairComboBox);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YStrategy Layout</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YStrategy Layout</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYStrategyLayout(YStrategyLayout object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YLayouting Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YLayouting Strategy</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYLayoutingStrategy(YLayoutingStrategy object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YDefault Layouting Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YDefault Layouting Strategy</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYDefaultLayoutingStrategy(YDefaultLayoutingStrategy object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YFocusing Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YFocusing Strategy</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYFocusingStrategy(YFocusingStrategy object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YDelegating Layouting Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YDelegating Layouting Strategy</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYDelegatingLayoutingStrategy(YDelegatingLayoutingStrategy object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YDelegating Focusing Strategy</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YDelegating Focusing Strategy</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYDelegatingFocusingStrategy(YDelegatingFocusingStrategy object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSuspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSuspect</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSuspect(YSuspect object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YLayouting Info</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YLayouting Info</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYLayoutingInfo(YLayoutingInfo object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSuspect Info</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSuspect Info</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSuspectInfo(YSuspectInfo object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YBlob Upload Component</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YBlob Upload Component</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYBlobUploadComponent(YBlobUploadComponent object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTyped Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTyped Suspect</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTypedSuspect(YTypedSuspect object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTyped Compound Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTyped Compound Suspect</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTypedCompoundSuspect(YTypedCompoundSuspect object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSub Type Base Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSub Type Base Suspect</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSubTypeBaseSuspect(YSubTypeBaseSuspect object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSub Type Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSub Type Suspect</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSubTypeSuspect(YSubTypeSuspect object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YCustom Decimal Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YCustom Decimal Field</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYCustomDecimalField(YCustomDecimalField object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YIcon Combo Box</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YIcon Combo Box</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYIconComboBox(YIconComboBox object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YQuantity Text Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YQuantity Text Field</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYQuantityTextField(YQuantityTextField object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YCollection Suspect</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YCollection Suspect</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYCollectionSuspect(YCollectionSuspect object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YColumn Info</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YColumn Info</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYColumnInfo(YColumnInfo object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YContent Sensitive Layout</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YContent Sensitive Layout</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYContentSensitiveLayout(YContentSensitiveLayout object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YRich Text Area</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YRich Text Area</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYRichTextArea(YRichTextArea object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YMasked Text Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YMasked Text Field</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYMaskedTextField(YMaskedTextField object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YPrefixed Masked Text Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YPrefixed Masked Text Field</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYPrefixedMaskedTextField(YPrefixedMaskedTextField object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YMasked Numeric Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YMasked Numeric Field</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYMaskedNumericField(YMaskedNumericField object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YMasked Decimal Field</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YMasked Decimal Field</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYMaskedDecimalField(YMaskedDecimalField object) {
+		return null;
+	}
+	
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YPair Combo Box</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YPair Combo Box</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYPairComboBox(YPairComboBox object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTaggable(YTaggable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYElement(YElement object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YCss Able</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YCss Able</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYCssAble(YCssAble object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YVisibleable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YVisibleable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYVisibleable(YVisibleable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YAuthorizationable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YAuthorizationable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYAuthorizationable(YAuthorizationable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YEmbeddable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YEmbeddable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYEmbeddable(YEmbeddable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YEditable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YEditable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYEditable(YEditable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YEnable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YEnable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYEnable(YEnable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YFocusable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YFocusable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYFocusable(YFocusable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YField</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YField</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYField(YField object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YInput</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YInput</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYInput(YInput object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YBindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YBindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYBindable(YBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YValue Bindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YValue Bindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYValueBindable(YValueBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YCollection Bindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YCollection Bindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYCollectionBindable(YCollectionBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSelection Bindable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSelection Bindable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSelectionBindable(YSelectionBindable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YBean Service Consumer</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YBean Service Consumer</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYBeanServiceConsumer(YBeanServiceConsumer object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YLayout</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YLayout</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYLayout(YLayout object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSpacingable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSpacingable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSpacingable(YSpacingable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YMarginable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YMarginable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYMarginable(YMarginable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YAuthorizationVisibilityProcessor.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YAuthorizationVisibilityProcessor.java
new file mode 100644
index 0000000..26f5104
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YAuthorizationVisibilityProcessor.java
@@ -0,0 +1,37 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility;
+
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>YAuthorization Visibility Processor</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage#getYAuthorizationVisibilityProcessor()
+ * @model
+ * @generated
+ */
+public interface YAuthorizationVisibilityProcessor extends YVisibilityProcessor {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YSubTypeVisibilityProcessor.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YSubTypeVisibilityProcessor.java
new file mode 100644
index 0000000..268ba26
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YSubTypeVisibilityProcessor.java
@@ -0,0 +1,129 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.visibility;
+
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '
+ * <em><b>YSub Type Visibility Processor</b></em>'. <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTarget <em>Target</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage#getYSubTypeVisibilityProcessor()
+ * @model
+ * @generated
+ */
+public interface YSubTypeVisibilityProcessor extends YVisibilityProcessor {
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Returns the value of the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type Qualified Name</em>' attribute isn't
+	 * clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #setTypeQualifiedName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage#getYSubTypeVisibilityProcessor_TypeQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getTypeQualifiedName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTypeQualifiedName <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @param value the new value of the '<em>Type Qualified Name</em>' attribute.
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 */
+	void setTypeQualifiedName(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Type</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear, there really
+	 * should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Type</em>' attribute.
+	 * @see #setType(Class)
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage#getYSubTypeVisibilityProcessor_Type()
+	 * @model
+	 * @generated
+	 */
+	Class<?> getType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getType <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * @see #getType()
+	 * @generated
+	 */
+	void setType(Class<?> value);
+
+	/**
+	 * Returns the value of the '<em><b>Target</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Target</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Target</em>' reference.
+	 * @see #setTarget(YEmbeddable)
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage#getYSubTypeVisibilityProcessor_Target()
+	 * @model required="true"
+	 * @generated
+	 */
+	YEmbeddable getTarget();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTarget <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Target</em>' reference.
+	 * @see #getTarget()
+	 * @generated
+	 */
+	void setTarget(YEmbeddable value);
+
+	/**
+	 * Returns true, if the visibility processor config matches the given class.
+	 * 
+	 * @param className
+	 * @return
+	 */
+	boolean matchesType(Class<?> className);
+
+} // YSubTypeVisibilityProcessor
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YVisibilityFactory.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YVisibilityFactory.java
new file mode 100644
index 0000000..38d9185
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YVisibilityFactory.java
@@ -0,0 +1,70 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage
+ * @generated
+ */
+public interface YVisibilityFactory extends EFactory {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	YVisibilityFactory eINSTANCE = org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>YAuthorization Visibility Processor</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YAuthorization Visibility Processor</em>'.
+	 * @generated
+	 */
+	YAuthorizationVisibilityProcessor createYAuthorizationVisibilityProcessor();
+
+	/**
+	 * Returns a new object of class '<em>YSub Type Visibility Processor</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>YSub Type Visibility Processor</em>'.
+	 * @generated
+	 */
+	YSubTypeVisibilityProcessor createYSubTypeVisibilityProcessor();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	YVisibilityPackage getYVisibilityPackage();
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YVisibilityPackage.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YVisibilityPackage.java
new file mode 100644
index 0000000..3482aa3
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/YVisibilityPackage.java
@@ -0,0 +1,405 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.osbp.ecview.core.common.model.visibility.VisibilityPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface YVisibilityPackage extends EPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "visibility";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://osbp.de/ecview/v1/extension/visibility";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "visibility";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	YVisibilityPackage eINSTANCE = org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.visibility.impl.YAuthorizationVisibilityProcessorImpl <em>YAuthorization Visibility Processor</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YAuthorizationVisibilityProcessorImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityPackageImpl#getYAuthorizationVisibilityProcessor()
+	 * @generated
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR = 0;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__TAGS = VisibilityPackage.YVISIBILITY_PROCESSOR__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__ID = VisibilityPackage.YVISIBILITY_PROCESSOR__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__NAME = VisibilityPackage.YVISIBILITY_PROCESSOR__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__PROPERTIES = VisibilityPackage.YVISIBILITY_PROCESSOR__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Data Used</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__DATA_USED = VisibilityPackage.YVISIBILITY_PROCESSOR__DATA_USED;
+
+	/**
+	 * The feature id for the '<em><b>Triggers On</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__TRIGGERS_ON = VisibilityPackage.YVISIBILITY_PROCESSOR__TRIGGERS_ON;
+
+	/**
+	 * The feature id for the '<em><b>Delegate</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__DELEGATE = VisibilityPackage.YVISIBILITY_PROCESSOR__DELEGATE;
+
+	/**
+	 * The feature id for the '<em><b>Delegate Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR__DELEGATE_QUALIFIED_NAME = VisibilityPackage.YVISIBILITY_PROCESSOR__DELEGATE_QUALIFIED_NAME;
+
+	/**
+	 * The number of structural features of the '<em>YAuthorization Visibility Processor</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YAUTHORIZATION_VISIBILITY_PROCESSOR_FEATURE_COUNT = VisibilityPackage.YVISIBILITY_PROCESSOR_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.visibility.impl.YSubTypeVisibilityProcessorImpl <em>YSub Type Visibility Processor</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YSubTypeVisibilityProcessorImpl
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityPackageImpl#getYSubTypeVisibilityProcessor()
+	 * @generated
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR = 1;
+
+	/**
+	 * The feature id for the '<em><b>Tags</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__TAGS = VisibilityPackage.YVISIBILITY_PROCESSOR__TAGS;
+
+	/**
+	 * The feature id for the '<em><b>Id</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__ID = VisibilityPackage.YVISIBILITY_PROCESSOR__ID;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__NAME = VisibilityPackage.YVISIBILITY_PROCESSOR__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Properties</b></em>' map.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__PROPERTIES = VisibilityPackage.YVISIBILITY_PROCESSOR__PROPERTIES;
+
+	/**
+	 * The feature id for the '<em><b>Data Used</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__DATA_USED = VisibilityPackage.YVISIBILITY_PROCESSOR__DATA_USED;
+
+	/**
+	 * The feature id for the '<em><b>Triggers On</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__TRIGGERS_ON = VisibilityPackage.YVISIBILITY_PROCESSOR__TRIGGERS_ON;
+
+	/**
+	 * The feature id for the '<em><b>Delegate</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__DELEGATE = VisibilityPackage.YVISIBILITY_PROCESSOR__DELEGATE;
+
+	/**
+	 * The feature id for the '<em><b>Delegate Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__DELEGATE_QUALIFIED_NAME = VisibilityPackage.YVISIBILITY_PROCESSOR__DELEGATE_QUALIFIED_NAME;
+
+	/**
+	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME = VisibilityPackage.YVISIBILITY_PROCESSOR_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE = VisibilityPackage.YVISIBILITY_PROCESSOR_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Target</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET = VisibilityPackage.YVISIBILITY_PROCESSOR_FEATURE_COUNT + 2;
+
+	/**
+	 * The number of structural features of the '<em>YSub Type Visibility Processor</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_VISIBILITY_PROCESSOR_FEATURE_COUNT = VisibilityPackage.YVISIBILITY_PROCESSOR_FEATURE_COUNT + 3;
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor <em>YAuthorization Visibility Processor</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YAuthorization Visibility Processor</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor
+	 * @generated
+	 */
+	EClass getYAuthorizationVisibilityProcessor();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor <em>YSub Type Visibility Processor</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>YSub Type Visibility Processor</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor
+	 * @generated
+	 */
+	EClass getYSubTypeVisibilityProcessor();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTypeQualifiedName <em>Type Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type Qualified Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTypeQualifiedName()
+	 * @see #getYSubTypeVisibilityProcessor()
+	 * @generated
+	 */
+	EAttribute getYSubTypeVisibilityProcessor_TypeQualifiedName();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getType <em>Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Type</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getType()
+	 * @see #getYSubTypeVisibilityProcessor()
+	 * @generated
+	 */
+	EAttribute getYSubTypeVisibilityProcessor_Type();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTarget <em>Target</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Target</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor#getTarget()
+	 * @see #getYSubTypeVisibilityProcessor()
+	 * @generated
+	 */
+	EReference getYSubTypeVisibilityProcessor_Target();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	YVisibilityFactory getYVisibilityFactory();
+
+	/**
+	 * <!-- begin-user-doc --> Defines literals for the meta objects that
+	 * represent
+	 * <ul>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.visibility.impl.YAuthorizationVisibilityProcessorImpl <em>YAuthorization Visibility Processor</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YAuthorizationVisibilityProcessorImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityPackageImpl#getYAuthorizationVisibilityProcessor()
+		 * @generated
+		 */
+		EClass YAUTHORIZATION_VISIBILITY_PROCESSOR = eINSTANCE.getYAuthorizationVisibilityProcessor();
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.visibility.impl.YSubTypeVisibilityProcessorImpl <em>YSub Type Visibility Processor</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YSubTypeVisibilityProcessorImpl
+		 * @see org.eclipse.osbp.ecview.extension.model.visibility.impl.YVisibilityPackageImpl#getYSubTypeVisibilityProcessor()
+		 * @generated
+		 */
+		EClass YSUB_TYPE_VISIBILITY_PROCESSOR = eINSTANCE.getYSubTypeVisibilityProcessor();
+		/**
+		 * The meta object literal for the '<em><b>Type Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME = eINSTANCE.getYSubTypeVisibilityProcessor_TypeQualifiedName();
+		/**
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE = eINSTANCE.getYSubTypeVisibilityProcessor_Type();
+		/**
+		 * The meta object literal for the '<em><b>Target</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET = eINSTANCE.getYSubTypeVisibilityProcessor_Target();
+
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YAuthorizationVisibilityProcessorImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YAuthorizationVisibilityProcessorImpl.java
new file mode 100644
index 0000000..3df52b1
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YAuthorizationVisibilityProcessorImpl.java
@@ -0,0 +1,59 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.osbp.ecview.core.common.model.visibility.impl.YVisibilityProcessorImpl;
+import org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>YAuthorization Visibility Processor</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * </p>
+ *
+ * @generated
+ */
+public class YAuthorizationVisibilityProcessorImpl extends YVisibilityProcessorImpl implements YAuthorizationVisibilityProcessor {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected YAuthorizationVisibilityProcessorImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the e class
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YVisibilityPackage.Literals.YAUTHORIZATION_VISIBILITY_PROCESSOR;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YSubTypeVisibilityProcessorImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YSubTypeVisibilityProcessorImpl.java
new file mode 100644
index 0000000..d826043
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YSubTypeVisibilityProcessorImpl.java
@@ -0,0 +1,276 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+ package org.eclipse.osbp.ecview.extension.model.visibility.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable;
+import org.eclipse.osbp.ecview.core.common.model.visibility.impl.YVisibilityProcessorImpl;
+import org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '
+ * <em><b>YSub Type Visibility Processor</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.visibility.impl.YSubTypeVisibilityProcessorImpl#getTypeQualifiedName <em>Type Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.visibility.impl.YSubTypeVisibilityProcessorImpl#getType <em>Type</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.visibility.impl.YSubTypeVisibilityProcessorImpl#getTarget <em>Target</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class YSubTypeVisibilityProcessorImpl extends YVisibilityProcessorImpl
+		implements YSubTypeVisibilityProcessor {
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The default value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String TYPE_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getTypeQualifiedName() <em>Type Qualified Name</em>}' attribute.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @see #getTypeQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String typeQualifiedName = TYPE_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @see #getType()
+	 * @generated
+	 * @ordered
+	 */
+	protected Class<?> type;
+
+	/**
+	 * The cached value of the '{@link #getTarget() <em>Target</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTarget()
+	 * @generated
+	 * @ordered
+	 */
+	protected YEmbeddable target;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YSubTypeVisibilityProcessorImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return YVisibilityPackage.Literals.YSUB_TYPE_VISIBILITY_PROCESSOR;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getTypeQualifiedName() {
+		return typeQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setTypeQualifiedName(String newTypeQualifiedName) {
+		String oldTypeQualifiedName = typeQualifiedName;
+		typeQualifiedName = newTypeQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME, oldTypeQualifiedName, typeQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Class<?> getType() {
+		return type;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setType(Class<?> newType) {
+		Class<?> oldType = type;
+		type = newType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE, oldType, type));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddable getTarget() {
+		if (target != null && target.eIsProxy()) {
+			InternalEObject oldTarget = (InternalEObject)target;
+			target = (YEmbeddable)eResolveProxy(oldTarget);
+			if (target != oldTarget) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET, oldTarget, target));
+			}
+		}
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YEmbeddable basicGetTarget() {
+		return target;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setTarget(YEmbeddable newTarget) {
+		YEmbeddable oldTarget = target;
+		target = newTarget;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET, oldTarget, target));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME:
+				return getTypeQualifiedName();
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE:
+				return getType();
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET:
+				if (resolve) return getTarget();
+				return basicGetTarget();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName((String)newValue);
+				return;
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE:
+				setType((Class<?>)newValue);
+				return;
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET:
+				setTarget((YEmbeddable)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME:
+				setTypeQualifiedName(TYPE_QUALIFIED_NAME_EDEFAULT);
+				return;
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE:
+				setType((Class<?>)null);
+				return;
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET:
+				setTarget((YEmbeddable)null);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME:
+				return TYPE_QUALIFIED_NAME_EDEFAULT == null ? typeQualifiedName != null : !TYPE_QUALIFIED_NAME_EDEFAULT.equals(typeQualifiedName);
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE:
+				return type != null;
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET:
+				return target != null;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (typeQualifiedName: ");
+		result.append(typeQualifiedName);
+		result.append(", type: ");
+		result.append(type);
+		result.append(')');
+		return result.toString();
+	}
+
+	@Override
+	public boolean matchesType(Class<?> className) {
+		return className.getName().equals(getTypeQualifiedName());
+	}
+
+} // YSubTypeVisibilityProcessorImpl
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YVisibilityFactoryImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YVisibilityFactoryImpl.java
new file mode 100644
index 0000000..387776e
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YVisibilityFactoryImpl.java
@@ -0,0 +1,131 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityFactory;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YVisibilityFactoryImpl extends EFactoryImpl implements YVisibilityFactory {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @generated
+	 */
+	public static YVisibilityFactory init() {
+		try {
+			YVisibilityFactory theYVisibilityFactory = (YVisibilityFactory)EPackage.Registry.INSTANCE.getEFactory(YVisibilityPackage.eNS_URI);
+			if (theYVisibilityFactory != null) {
+				return theYVisibilityFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new YVisibilityFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YVisibilityFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @param eClass
+	 *            the e class
+	 * @return the e object
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case YVisibilityPackage.YAUTHORIZATION_VISIBILITY_PROCESSOR: return createYAuthorizationVisibilityProcessor();
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR: return createYSubTypeVisibilityProcessor();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y authorization visibility processor
+	 * @generated
+	 */
+	public YAuthorizationVisibilityProcessor createYAuthorizationVisibilityProcessor() {
+		YAuthorizationVisibilityProcessorImpl yAuthorizationVisibilityProcessor = new YAuthorizationVisibilityProcessorImpl();
+		return yAuthorizationVisibilityProcessor;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YSubTypeVisibilityProcessor createYSubTypeVisibilityProcessor() {
+		YSubTypeVisibilityProcessorImpl ySubTypeVisibilityProcessor = new YSubTypeVisibilityProcessorImpl();
+		return ySubTypeVisibilityProcessor;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y visibility package
+	 * @generated
+	 */
+	public YVisibilityPackage getYVisibilityPackage() {
+		return (YVisibilityPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the package
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static YVisibilityPackage getPackage() {
+		return YVisibilityPackage.eINSTANCE;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YVisibilityPackageImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YVisibilityPackageImpl.java
new file mode 100644
index 0000000..c64e0b8
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/impl/YVisibilityPackageImpl.java
@@ -0,0 +1,273 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EGenericType;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+import org.eclipse.osbp.ecview.core.common.model.core.CoreModelPackage;
+import org.eclipse.osbp.ecview.core.common.model.visibility.VisibilityPackage;
+import org.eclipse.osbp.ecview.core.extension.model.datatypes.ExtDatatypesPackage;
+import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage;
+import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.YConverterPackage;
+import org.eclipse.osbp.ecview.extension.model.converter.impl.YConverterPackageImpl;
+import org.eclipse.osbp.ecview.extension.model.impl.YECviewPackageImpl;
+import org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityFactory;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+import org.eclipse.xtext.common.types.TypesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class YVisibilityPackageImpl extends EPackageImpl implements YVisibilityPackage {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private EClass yAuthorizationVisibilityProcessorEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass ySubTypeVisibilityProcessorEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private YVisibilityPackageImpl() {
+		super(eNS_URI, YVisibilityFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model,
+	 * and for any others upon which it depends.
+	 * 
+	 * <p>
+	 * This method is used to initialize {@link YVisibilityPackage#eINSTANCE}
+	 * when that field is accessed. Clients should not invoke it directly.
+	 * Instead, they should simply access that field to obtain the package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @return the y visibility package
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static YVisibilityPackage init() {
+		if (isInited) return (YVisibilityPackage)EPackage.Registry.INSTANCE.getEPackage(YVisibilityPackage.eNS_URI);
+
+		// Obtain or create and register package
+		YVisibilityPackageImpl theYVisibilityPackage = (YVisibilityPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof YVisibilityPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new YVisibilityPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		ExtDatatypesPackage.eINSTANCE.eClass();
+		ExtensionModelPackage.eINSTANCE.eClass();
+		TypesPackage.eINSTANCE.eClass();
+
+		// Obtain or create and register interdependencies
+		YECviewPackageImpl theYECviewPackage = (YECviewPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(YECviewPackage.eNS_URI) instanceof YECviewPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(YECviewPackage.eNS_URI) : YECviewPackage.eINSTANCE);
+		YConverterPackageImpl theYConverterPackage = (YConverterPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(YConverterPackage.eNS_URI) instanceof YConverterPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(YConverterPackage.eNS_URI) : YConverterPackage.eINSTANCE);
+
+		// Create package meta-data objects
+		theYVisibilityPackage.createPackageContents();
+		theYECviewPackage.createPackageContents();
+		theYConverterPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theYVisibilityPackage.initializePackageContents();
+		theYECviewPackage.initializePackageContents();
+		theYConverterPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theYVisibilityPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(YVisibilityPackage.eNS_URI, theYVisibilityPackage);
+		return theYVisibilityPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y authorization visibility processor
+	 * @generated
+	 */
+	public EClass getYAuthorizationVisibilityProcessor() {
+		return yAuthorizationVisibilityProcessorEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getYSubTypeVisibilityProcessor() {
+		return ySubTypeVisibilityProcessorEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYSubTypeVisibilityProcessor_TypeQualifiedName() {
+		return (EAttribute)ySubTypeVisibilityProcessorEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYSubTypeVisibilityProcessor_Type() {
+		return (EAttribute)ySubTypeVisibilityProcessorEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getYSubTypeVisibilityProcessor_Target() {
+		return (EReference)ySubTypeVisibilityProcessorEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @return the y visibility factory
+	 * @generated
+	 */
+	public YVisibilityFactory getYVisibilityFactory() {
+		return (YVisibilityFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		yAuthorizationVisibilityProcessorEClass = createEClass(YAUTHORIZATION_VISIBILITY_PROCESSOR);
+
+		ySubTypeVisibilityProcessorEClass = createEClass(YSUB_TYPE_VISIBILITY_PROCESSOR);
+		createEAttribute(ySubTypeVisibilityProcessorEClass, YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE_QUALIFIED_NAME);
+		createEAttribute(ySubTypeVisibilityProcessorEClass, YSUB_TYPE_VISIBILITY_PROCESSOR__TYPE);
+		createEReference(ySubTypeVisibilityProcessorEClass, YSUB_TYPE_VISIBILITY_PROCESSOR__TARGET);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		VisibilityPackage theVisibilityPackage = (VisibilityPackage)EPackage.Registry.INSTANCE.getEPackage(VisibilityPackage.eNS_URI);
+		CoreModelPackage theCoreModelPackage = (CoreModelPackage)EPackage.Registry.INSTANCE.getEPackage(CoreModelPackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		yAuthorizationVisibilityProcessorEClass.getESuperTypes().add(theVisibilityPackage.getYVisibilityProcessor());
+		ySubTypeVisibilityProcessorEClass.getESuperTypes().add(theVisibilityPackage.getYVisibilityProcessor());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(yAuthorizationVisibilityProcessorEClass, YAuthorizationVisibilityProcessor.class, "YAuthorizationVisibilityProcessor", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		initEClass(ySubTypeVisibilityProcessorEClass, YSubTypeVisibilityProcessor.class, "YSubTypeVisibilityProcessor", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getYSubTypeVisibilityProcessor_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, YSubTypeVisibilityProcessor.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		EGenericType g1 = createEGenericType(ecorePackage.getEJavaClass());
+		EGenericType g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEAttribute(getYSubTypeVisibilityProcessor_Type(), g1, "type", null, 0, 1, YSubTypeVisibilityProcessor.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getYSubTypeVisibilityProcessor_Target(), theCoreModelPackage.getYEmbeddable(), null, "target", null, 1, 1, YSubTypeVisibilityProcessor.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/util/YVisibilityAdapterFactory.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/util/YVisibilityAdapterFactory.java
new file mode 100644
index 0000000..227e4c4
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/util/YVisibilityAdapterFactory.java
@@ -0,0 +1,213 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage
+ * @generated
+ */
+public class YVisibilityAdapterFactory extends AdapterFactoryImpl {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static YVisibilityPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YVisibilityAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = YVisibilityPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc --> This implementation returns <code>true</code> if
+	 * the object is either the model's package or is an instance object of the
+	 * model. <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected YVisibilitySwitch<Adapter> modelSwitch =
+		new YVisibilitySwitch<Adapter>() {
+			@Override
+			public Adapter caseYAuthorizationVisibilityProcessor(YAuthorizationVisibilityProcessor object) {
+				return createYAuthorizationVisibilityProcessorAdapter();
+			}
+			@Override
+			public Adapter caseYSubTypeVisibilityProcessor(YSubTypeVisibilityProcessor object) {
+				return createYSubTypeVisibilityProcessorAdapter();
+			}
+			@Override
+			public Adapter caseYTaggable(YTaggable object) {
+				return createYTaggableAdapter();
+			}
+			@Override
+			public Adapter caseYElement(YElement object) {
+				return createYElementAdapter();
+			}
+			@Override
+			public Adapter caseYVisibilityProcessor(YVisibilityProcessor object) {
+				return createYVisibilityProcessorAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor <em>YAuthorization Visibility Processor</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor
+	 * @generated
+	 */
+	public Adapter createYAuthorizationVisibilityProcessorAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor <em>YSub Type Visibility Processor</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor
+	 * @generated
+	 */
+	public Adapter createYSubTypeVisibilityProcessorAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YTaggable <em>YTaggable</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YTaggable
+	 * @generated
+	 */
+	public Adapter createYTaggableAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.core.YElement <em>YElement</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.core.YElement
+	 * @generated
+	 */
+	public Adapter createYElementAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor <em>YVisibility Processor</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor
+	 * @generated
+	 */
+	public Adapter createYVisibilityProcessorAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/util/YVisibilitySwitch.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/util/YVisibilitySwitch.java
new file mode 100644
index 0000000..909ddf2
--- /dev/null
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/visibility/util/YVisibilitySwitch.java
@@ -0,0 +1,202 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Florian Pirchner - Initial implementation
+ * 
+ */
+package org.eclipse.osbp.ecview.extension.model.visibility.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.osbp.ecview.core.common.model.core.YElement;
+import org.eclipse.osbp.ecview.core.common.model.core.YTaggable;
+import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YAuthorizationVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YSubTypeVisibilityProcessor;
+import org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage;
+
+/**
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance
+ * hierarchy. It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the
+ * inheritance hierarchy until a non-null result is returned, which is the
+ * result of the switch. <!-- end-user-doc -->
+ * @see org.eclipse.osbp.ecview.extension.model.visibility.YVisibilityPackage
+ * @generated
+ */
+public class YVisibilitySwitch<T> extends Switch<T> {
+	
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	public static final String copyright = "All rights reserved by Loetz GmbH und CoKG Heidelberg 2015.\n\nContributors:\n      Florian Pirchner - initial API and implementation";
+
+	/**
+	 * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->.
+	 *
+	 * @generated
+	 */
+	protected static YVisibilityPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public YVisibilitySwitch() {
+		if (modelPackage == null) {
+			modelPackage = YVisibilityPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 *
+	 * @param ePackage
+	 *            the e package
+	 * @return whether this is a switch for the given package.
+	 * @parameter ePackage the package in question.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case YVisibilityPackage.YAUTHORIZATION_VISIBILITY_PROCESSOR: {
+				YAuthorizationVisibilityProcessor yAuthorizationVisibilityProcessor = (YAuthorizationVisibilityProcessor)theEObject;
+				T result = caseYAuthorizationVisibilityProcessor(yAuthorizationVisibilityProcessor);
+				if (result == null) result = caseYVisibilityProcessor(yAuthorizationVisibilityProcessor);
+				if (result == null) result = caseYElement(yAuthorizationVisibilityProcessor);
+				if (result == null) result = caseYTaggable(yAuthorizationVisibilityProcessor);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case YVisibilityPackage.YSUB_TYPE_VISIBILITY_PROCESSOR: {
+				YSubTypeVisibilityProcessor ySubTypeVisibilityProcessor = (YSubTypeVisibilityProcessor)theEObject;
+				T result = caseYSubTypeVisibilityProcessor(ySubTypeVisibilityProcessor);
+				if (result == null) result = caseYVisibilityProcessor(ySubTypeVisibilityProcessor);
+				if (result == null) result = caseYElement(ySubTypeVisibilityProcessor);
+				if (result == null) result = caseYTaggable(ySubTypeVisibilityProcessor);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YAuthorization Visibility Processor</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YAuthorization Visibility Processor</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYAuthorizationVisibilityProcessor(YAuthorizationVisibilityProcessor object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YSub Type Visibility Processor</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YSub Type Visibility Processor</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYSubTypeVisibilityProcessor(YSubTypeVisibilityProcessor object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YTaggable</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYTaggable(YTaggable object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YElement</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYElement(YElement object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>YVisibility Processor</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>YVisibility Processor</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseYVisibilityProcessor(YVisibilityProcessor object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+}
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..250cf19
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+# 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.tycho</artifactId>
+        <version>0.9.0-SNAPSHOT</version>
+        <relativePath/>
+    </parent>
+
+    <groupId>org.eclipse.osbp.ecview.extension.api</groupId>
+    <artifactId>org.eclipse.osbp.ecview.extension.api.aggregator</artifactId>
+    <version>0.9.0-SNAPSHOT</version>
+    <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.ecview.extension.api</module>
+        <module>org.eclipse.osbp.ecview.extension.editparts</module>
+        <module>org.eclipse.osbp.ecview.extension.grid.editparts</module>
+        <module>org.eclipse.osbp.ecview.extension.grid.model</module>
+        <module>org.eclipse.osbp.ecview.extension.grid.model.edit</module>
+        <module>org.eclipse.osbp.ecview.extension.model</module>
+        <module>org.eclipse.osbp.ecview.extension.model.edit</module>
+        <module>org.eclipse.osbp.ecview.extension.api.feature</module>
+    </modules>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-javadoc-plugin</artifactId>
+                    <configuration>
+                        <skip>true</skip>
+                    </configuration>
+                </plugin>
+                <plugin>
+                    <groupId>org.eclipse.tycho</groupId>
+                    <artifactId>target-platform-configuration</artifactId>
+                    <version>${tycho-version}</version>
+                    <configuration>
+                        <filters>
+                            <filter>
+                                <type>eclipse-plugin</type>
+                                <id>org.apache.aries.transaction.manager</id>
+                                <restrictTo>
+                                    <!--  use a range that does not exist, we can not mix removeall and versionRange -->
+                                    <versionRange>[0.5.0,0.5.1)</versionRange>
+                                </restrictTo>
+                            </filter>
+                        </filters>
+                        <resolver>p2</resolver>
+                        <pomDependencies>consider</pomDependencies>
+                        <environments>
+                            <environment>
+                                <os>win32</os>
+                                <ws>win32</ws>
+                                <arch>x86_64</arch>
+                            </environment>
+                            <environment>
+                                <os>linux</os>
+                                <ws>gtk</ws>
+                                <arch>x86</arch>
+                            </environment>
+                            <environment>
+                                <os>linux</os>
+                                <ws>gtk</ws>
+                                <arch>x86_64</arch>
+                            </environment>
+                            <environment>
+                                <os>macosx</os>
+                                <ws>cocoa</ws>
+                                <arch>x86_64</arch>
+                            </environment>
+                        </environments>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+</project>
