/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * All rights reserved. This program and the accompanying materials           
 * are made available under the terms of the Eclipse Public License 2.0        
 * which accompanies this distribution, and is available at                  
 * https://www.eclipse.org/legal/epl-2.0/                                 
 *                                 
 * SPDX-License-Identifier: EPL-2.0                                 
 *                                                                            
 * Contributors:   
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation 
 */
 package org.eclipse.osbp.infogrid.model.gridsource.style;

import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;

/**
 * <!-- 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.infogrid.model.gridsource.style.CxGridStyleFactory
 * @model kind="package"
 * @generated
 */
public interface CxGridStylePackage extends EPackage {
	/**
	 * The package name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNAME = "style";

	/**
	 * The package namespace URI.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_URI = "http://osbp.eclipse.org/gridsource/v1/core/style";

	/**
	 * The package namespace name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_PREFIX = "style";

	/**
	 * The singleton instance of the package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	CxGridStylePackage eINSTANCE = org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl.init();

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropStyleImpl <em>Cx Grid Prop Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropStyle()
	 * @generated
	 */
	int CX_GRID_PROP_STYLE = 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_STYLE_FEATURE_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropHtmlStyleImpl <em>Cx Grid Prop Html Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropHtmlStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropHtmlStyle()
	 * @generated
	 */
	int CX_GRID_PROP_HTML_STYLE = 1;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Html Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_HTML_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropTextStyleImpl <em>Cx Grid Prop Text Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropTextStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropTextStyle()
	 * @generated
	 */
	int CX_GRID_PROP_TEXT_STYLE = 2;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Text Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_TEXT_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropButtonStyleImpl <em>Cx Grid Prop Button Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropButtonStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropButtonStyle()
	 * @generated
	 */
	int CX_GRID_PROP_BUTTON_STYLE = 3;

	/**
	 * The feature id for the '<em><b>Event Topic</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_BUTTON_STYLE__EVENT_TOPIC = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Button Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_BUTTON_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropProgressbarStyleImpl <em>Cx Grid Prop Progressbar Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropProgressbarStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropProgressbarStyle()
	 * @generated
	 */
	int CX_GRID_PROP_PROGRESSBAR_STYLE = 4;

	/**
	 * The feature id for the '<em><b>Max Value</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PROGRESSBAR_STYLE__MAX_VALUE = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Progressbar Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PROGRESSBAR_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropSparklineStyleImpl <em>Cx Grid Prop Sparkline Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropSparklineStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropSparklineStyle()
	 * @generated
	 */
	int CX_GRID_PROP_SPARKLINE_STYLE = 5;

	/**
	 * The feature id for the '<em><b>Field</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_SPARKLINE_STYLE__FIELD = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Sparkline Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_SPARKLINE_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;


	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBooleanStyleImpl <em>Cx Grid Prop Boolean Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBooleanStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropBooleanStyle()
	 * @generated
	 */
	int CX_GRID_PROP_BOOLEAN_STYLE = 6;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Boolean Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_BOOLEAN_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;


	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropNumberStyleImpl <em>Cx Grid Prop Number Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropNumberStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropNumberStyle()
	 * @generated
	 */
	int CX_GRID_PROP_NUMBER_STYLE = 7;

	/**
	 * The feature id for the '<em><b>Number Format</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_NUMBER_STYLE__NUMBER_FORMAT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Number Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_NUMBER_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;


	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBlobImageStyleImpl <em>Cx Grid Prop Blob Image Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBlobImageStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropBlobImageStyle()
	 * @generated
	 */
	int CX_GRID_PROP_BLOB_IMAGE_STYLE = 8;

	/**
	 * The feature id for the '<em><b>Configs</b></em>' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_BLOB_IMAGE_STYLE__CONFIGS = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Blob Image Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_BLOB_IMAGE_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropImageStyleImpl <em>Cx Grid Prop Image Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropImageStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropImageStyle()
	 * @generated
	 */
	int CX_GRID_PROP_IMAGE_STYLE = 9;

	/**
	 * The feature id for the '<em><b>Event Topic</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_IMAGE_STYLE__EVENT_TOPIC = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Configs</b></em>' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_IMAGE_STYLE__CONFIGS = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Image Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_IMAGE_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 2;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropIndicatorStyleImpl <em>Cx Grid Prop Indicator Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropIndicatorStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropIndicatorStyle()
	 * @generated
	 */
	int CX_GRID_PROP_INDICATOR_STYLE = 10;

	/**
	 * The feature id for the '<em><b>Event Topic</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_INDICATOR_STYLE__EVENT_TOPIC = CX_GRID_PROP_STYLE_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_PROP_INDICATOR_STYLE__GREEN_STARTS = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Red Ends</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_INDICATOR_STYLE__RED_ENDS = CX_GRID_PROP_STYLE_FEATURE_COUNT + 2;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Indicator Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_INDICATOR_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 3;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropDateStyleImpl <em>Cx Grid Prop Date Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropDateStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropDateStyle()
	 * @generated
	 */
	int CX_GRID_PROP_DATE_STYLE = 11;

	/**
	 * The feature id for the '<em><b>Date Format</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_DATE_STYLE__DATE_FORMAT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Date Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_DATE_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;


	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigImpl <em>Config</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridStyleConfig()
	 * @generated
	 */
	int CX_GRID_STYLE_CONFIG = 12;

	/**
	 * The number of structural features of the '<em>Config</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_FEATURE_COUNT = 0;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigStringToResourceImpl <em>Config String To Resource</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigStringToResourceImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridStyleConfigStringToResource()
	 * @generated
	 */
	int CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE = 13;

	/**
	 * The feature id for the '<em><b>Value</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE__VALUE = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Compare</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE__COMPARE = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Resource Theme Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE__RESOURCE_THEME_PATH = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 2;

	/**
	 * The number of structural features of the '<em>Config String To Resource</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE_FEATURE_COUNT = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 3;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigNumericToResourceImpl <em>Config Numeric To Resource</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigNumericToResourceImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridStyleConfigNumericToResource()
	 * @generated
	 */
	int CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE = 14;

	/**
	 * The feature id for the '<em><b>Value</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE__VALUE = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Compare</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE__COMPARE = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Resource Theme Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE__RESOURCE_THEME_PATH = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 2;

	/**
	 * The number of structural features of the '<em>Config Numeric To Resource</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE_FEATURE_COUNT = CX_GRID_STYLE_CONFIG_FEATURE_COUNT + 3;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridEventTopicAble <em>Cx Grid Event Topic Able</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridEventTopicAble
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridEventTopicAble()
	 * @generated
	 */
	int CX_GRID_EVENT_TOPIC_ABLE = 15;

	/**
	 * The feature id for the '<em><b>Event Topic</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_EVENT_TOPIC_ABLE__EVENT_TOPIC = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Cx Grid Event Topic Able</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_EVENT_TOPIC_ABLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropQuantityStyleImpl <em>Cx Grid Prop Quantity Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropQuantityStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropQuantityStyle()
	 * @generated
	 */
	int CX_GRID_PROP_QUANTITY_STYLE = 16;

	/**
	 * The feature id for the '<em><b>Value Property Path</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_QUANTITY_STYLE__VALUE_PROPERTY_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Value Property Dot Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_QUANTITY_STYLE__VALUE_PROPERTY_DOT_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Value Number Format</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_QUANTITY_STYLE__VALUE_NUMBER_FORMAT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 2;

	/**
	 * The feature id for the '<em><b>Uom Property Path</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_QUANTITY_STYLE__UOM_PROPERTY_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 3;

	/**
	 * The feature id for the '<em><b>Uom Property Dot Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_QUANTITY_STYLE__UOM_PROPERTY_DOT_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 4;

	/**
	 * The feature id for the '<em><b>Html Pattern</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_QUANTITY_STYLE__HTML_PATTERN = CX_GRID_PROP_STYLE_FEATURE_COUNT + 5;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Quantity Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_QUANTITY_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 6;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropPriceStyleImpl <em>Cx Grid Prop Price Style</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropPriceStyleImpl
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropPriceStyle()
	 * @generated
	 */
	int CX_GRID_PROP_PRICE_STYLE = 17;

	/**
	 * The feature id for the '<em><b>Value Property Path</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PRICE_STYLE__VALUE_PROPERTY_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 0;

	/**
	 * The feature id for the '<em><b>Value Property Dot Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PRICE_STYLE__VALUE_PROPERTY_DOT_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 1;

	/**
	 * The feature id for the '<em><b>Value Number Format</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PRICE_STYLE__VALUE_NUMBER_FORMAT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 2;

	/**
	 * The feature id for the '<em><b>Currency Property Path</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PRICE_STYLE__CURRENCY_PROPERTY_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 3;

	/**
	 * The feature id for the '<em><b>Currency Property Dot Path</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PRICE_STYLE__CURRENCY_PROPERTY_DOT_PATH = CX_GRID_PROP_STYLE_FEATURE_COUNT + 4;

	/**
	 * The feature id for the '<em><b>Html Pattern</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PRICE_STYLE__HTML_PATTERN = CX_GRID_PROP_STYLE_FEATURE_COUNT + 5;

	/**
	 * The number of structural features of the '<em>Cx Grid Prop Price Style</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CX_GRID_PROP_PRICE_STYLE_FEATURE_COUNT = CX_GRID_PROP_STYLE_FEATURE_COUNT + 6;

	/**
	 * The meta object id for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridCompare <em>Cx Grid Compare</em>}' enum.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridCompare
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridCompare()
	 * @generated
	 */
	int CX_GRID_COMPARE = 18;


	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropStyle <em>Cx Grid Prop Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropStyle
	 * @generated
	 */
	EClass getCxGridPropStyle();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropHtmlStyle <em>Cx Grid Prop Html Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Html Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropHtmlStyle
	 * @generated
	 */
	EClass getCxGridPropHtmlStyle();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropTextStyle <em>Cx Grid Prop Text Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Text Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropTextStyle
	 * @generated
	 */
	EClass getCxGridPropTextStyle();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropButtonStyle <em>Cx Grid Prop Button Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Button Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropButtonStyle
	 * @generated
	 */
	EClass getCxGridPropButtonStyle();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropProgressbarStyle <em>Cx Grid Prop Progressbar Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Progressbar Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropProgressbarStyle
	 * @generated
	 */
	EClass getCxGridPropProgressbarStyle();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropProgressbarStyle#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.infogrid.model.gridsource.style.CxGridPropProgressbarStyle#getMaxValue()
	 * @see #getCxGridPropProgressbarStyle()
	 * @generated
	 */
	EAttribute getCxGridPropProgressbarStyle_MaxValue();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropSparklineStyle <em>Cx Grid Prop Sparkline Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Sparkline Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropSparklineStyle
	 * @generated
	 */
	EClass getCxGridPropSparklineStyle();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropSparklineStyle#getField <em>Field</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Field</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropSparklineStyle#getField()
	 * @see #getCxGridPropSparklineStyle()
	 * @generated
	 */
	EReference getCxGridPropSparklineStyle_Field();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropBooleanStyle <em>Cx Grid Prop Boolean Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Boolean Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropBooleanStyle
	 * @generated
	 */
	EClass getCxGridPropBooleanStyle();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropNumberStyle <em>Cx Grid Prop Number Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Number Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropNumberStyle
	 * @generated
	 */
	EClass getCxGridPropNumberStyle();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropNumberStyle#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.infogrid.model.gridsource.style.CxGridPropNumberStyle#getNumberFormat()
	 * @see #getCxGridPropNumberStyle()
	 * @generated
	 */
	EAttribute getCxGridPropNumberStyle_NumberFormat();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropBlobImageStyle <em>Cx Grid Prop Blob Image Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Blob Image Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropBlobImageStyle
	 * @generated
	 */
	EClass getCxGridPropBlobImageStyle();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropBlobImageStyle#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.infogrid.model.gridsource.style.CxGridPropBlobImageStyle#getConfigs()
	 * @see #getCxGridPropBlobImageStyle()
	 * @generated
	 */
	EReference getCxGridPropBlobImageStyle_Configs();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropImageStyle <em>Cx Grid Prop Image Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Image Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropImageStyle
	 * @generated
	 */
	EClass getCxGridPropImageStyle();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropImageStyle#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.infogrid.model.gridsource.style.CxGridPropImageStyle#getConfigs()
	 * @see #getCxGridPropImageStyle()
	 * @generated
	 */
	EReference getCxGridPropImageStyle_Configs();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropIndicatorStyle <em>Cx Grid Prop Indicator Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Indicator Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropIndicatorStyle
	 * @generated
	 */
	EClass getCxGridPropIndicatorStyle();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropIndicatorStyle#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.infogrid.model.gridsource.style.CxGridPropIndicatorStyle#getGreenStarts()
	 * @see #getCxGridPropIndicatorStyle()
	 * @generated
	 */
	EAttribute getCxGridPropIndicatorStyle_GreenStarts();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropIndicatorStyle#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.infogrid.model.gridsource.style.CxGridPropIndicatorStyle#getRedEnds()
	 * @see #getCxGridPropIndicatorStyle()
	 * @generated
	 */
	EAttribute getCxGridPropIndicatorStyle_RedEnds();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropDateStyle <em>Cx Grid Prop Date Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Date Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropDateStyle
	 * @generated
	 */
	EClass getCxGridPropDateStyle();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropDateStyle#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.infogrid.model.gridsource.style.CxGridPropDateStyle#getDateFormat()
	 * @see #getCxGridPropDateStyle()
	 * @generated
	 */
	EAttribute getCxGridPropDateStyle_DateFormat();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfig <em>Config</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Config</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfig
	 * @generated
	 */
	EClass getCxGridStyleConfig();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource <em>Config String To Resource</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Config String To Resource</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource
	 * @generated
	 */
	EClass getCxGridStyleConfigStringToResource();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource#getValue <em>Value</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Value</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource#getValue()
	 * @see #getCxGridStyleConfigStringToResource()
	 * @generated
	 */
	EAttribute getCxGridStyleConfigStringToResource_Value();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource#getCompare <em>Compare</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Compare</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource#getCompare()
	 * @see #getCxGridStyleConfigStringToResource()
	 * @generated
	 */
	EAttribute getCxGridStyleConfigStringToResource_Compare();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource#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.infogrid.model.gridsource.style.CxGridStyleConfigStringToResource#getResourceThemePath()
	 * @see #getCxGridStyleConfigStringToResource()
	 * @generated
	 */
	EAttribute getCxGridStyleConfigStringToResource_ResourceThemePath();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource <em>Config Numeric To Resource</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Config Numeric To Resource</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource
	 * @generated
	 */
	EClass getCxGridStyleConfigNumericToResource();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource#getValue <em>Value</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Value</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource#getValue()
	 * @see #getCxGridStyleConfigNumericToResource()
	 * @generated
	 */
	EAttribute getCxGridStyleConfigNumericToResource_Value();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource#getCompare <em>Compare</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Compare</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource#getCompare()
	 * @see #getCxGridStyleConfigNumericToResource()
	 * @generated
	 */
	EAttribute getCxGridStyleConfigNumericToResource_Compare();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource#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.infogrid.model.gridsource.style.CxGridStyleConfigNumericToResource#getResourceThemePath()
	 * @see #getCxGridStyleConfigNumericToResource()
	 * @generated
	 */
	EAttribute getCxGridStyleConfigNumericToResource_ResourceThemePath();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridEventTopicAble <em>Cx Grid Event Topic Able</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Event Topic Able</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridEventTopicAble
	 * @generated
	 */
	EClass getCxGridEventTopicAble();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridEventTopicAble#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.infogrid.model.gridsource.style.CxGridEventTopicAble#getEventTopic()
	 * @see #getCxGridEventTopicAble()
	 * @generated
	 */
	EAttribute getCxGridEventTopicAble_EventTopic();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle <em>Cx Grid Prop Quantity Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Quantity Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle
	 * @generated
	 */
	EClass getCxGridPropQuantityStyle();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getValuePropertyPath <em>Value Property Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Value Property Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getValuePropertyPath()
	 * @see #getCxGridPropQuantityStyle()
	 * @generated
	 */
	EReference getCxGridPropQuantityStyle_ValuePropertyPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getValuePropertyDotPath <em>Value Property Dot Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Value Property Dot Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getValuePropertyDotPath()
	 * @see #getCxGridPropQuantityStyle()
	 * @generated
	 */
	EAttribute getCxGridPropQuantityStyle_ValuePropertyDotPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getValueNumberFormat <em>Value Number Format</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Value Number Format</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getValueNumberFormat()
	 * @see #getCxGridPropQuantityStyle()
	 * @generated
	 */
	EAttribute getCxGridPropQuantityStyle_ValueNumberFormat();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getUomPropertyPath <em>Uom Property Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Uom Property Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getUomPropertyPath()
	 * @see #getCxGridPropQuantityStyle()
	 * @generated
	 */
	EReference getCxGridPropQuantityStyle_UomPropertyPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getUomPropertyDotPath <em>Uom Property Dot Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Uom Property Dot Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getUomPropertyDotPath()
	 * @see #getCxGridPropQuantityStyle()
	 * @generated
	 */
	EAttribute getCxGridPropQuantityStyle_UomPropertyDotPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle#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.infogrid.model.gridsource.style.CxGridPropQuantityStyle#getHtmlPattern()
	 * @see #getCxGridPropQuantityStyle()
	 * @generated
	 */
	EAttribute getCxGridPropQuantityStyle_HtmlPattern();

	/**
	 * Returns the meta object for class '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle <em>Cx Grid Prop Price Style</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Cx Grid Prop Price Style</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle
	 * @generated
	 */
	EClass getCxGridPropPriceStyle();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getValuePropertyPath <em>Value Property Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Value Property Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getValuePropertyPath()
	 * @see #getCxGridPropPriceStyle()
	 * @generated
	 */
	EReference getCxGridPropPriceStyle_ValuePropertyPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getValuePropertyDotPath <em>Value Property Dot Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Value Property Dot Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getValuePropertyDotPath()
	 * @see #getCxGridPropPriceStyle()
	 * @generated
	 */
	EAttribute getCxGridPropPriceStyle_ValuePropertyDotPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getValueNumberFormat <em>Value Number Format</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Value Number Format</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getValueNumberFormat()
	 * @see #getCxGridPropPriceStyle()
	 * @generated
	 */
	EAttribute getCxGridPropPriceStyle_ValueNumberFormat();

	/**
	 * Returns the meta object for the containment reference '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getCurrencyPropertyPath <em>Currency Property Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference '<em>Currency Property Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getCurrencyPropertyPath()
	 * @see #getCxGridPropPriceStyle()
	 * @generated
	 */
	EReference getCxGridPropPriceStyle_CurrencyPropertyPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getCurrencyPropertyDotPath <em>Currency Property Dot Path</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Currency Property Dot Path</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#getCurrencyPropertyDotPath()
	 * @see #getCxGridPropPriceStyle()
	 * @generated
	 */
	EAttribute getCxGridPropPriceStyle_CurrencyPropertyDotPath();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle#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.infogrid.model.gridsource.style.CxGridPropPriceStyle#getHtmlPattern()
	 * @see #getCxGridPropPriceStyle()
	 * @generated
	 */
	EAttribute getCxGridPropPriceStyle_HtmlPattern();

	/**
	 * Returns the meta object for enum '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridCompare <em>Cx Grid Compare</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for enum '<em>Cx Grid Compare</em>'.
	 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridCompare
	 * @generated
	 */
	EEnum getCxGridCompare();

	/**
	 * 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
	 */
	CxGridStyleFactory getCxGridStyleFactory();

	/**
	 * <!-- 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.infogrid.model.gridsource.style.impl.CxGridPropStyleImpl <em>Cx Grid Prop Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_STYLE = eINSTANCE.getCxGridPropStyle();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropHtmlStyleImpl <em>Cx Grid Prop Html Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropHtmlStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropHtmlStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_HTML_STYLE = eINSTANCE.getCxGridPropHtmlStyle();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropTextStyleImpl <em>Cx Grid Prop Text Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropTextStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropTextStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_TEXT_STYLE = eINSTANCE.getCxGridPropTextStyle();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropButtonStyleImpl <em>Cx Grid Prop Button Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropButtonStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropButtonStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_BUTTON_STYLE = eINSTANCE.getCxGridPropButtonStyle();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropProgressbarStyleImpl <em>Cx Grid Prop Progressbar Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropProgressbarStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropProgressbarStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_PROGRESSBAR_STYLE = eINSTANCE.getCxGridPropProgressbarStyle();

		/**
		 * The meta object literal for the '<em><b>Max Value</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_PROGRESSBAR_STYLE__MAX_VALUE = eINSTANCE.getCxGridPropProgressbarStyle_MaxValue();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropSparklineStyleImpl <em>Cx Grid Prop Sparkline Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropSparklineStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropSparklineStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_SPARKLINE_STYLE = eINSTANCE.getCxGridPropSparklineStyle();

		/**
		 * The meta object literal for the '<em><b>Field</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_PROP_SPARKLINE_STYLE__FIELD = eINSTANCE.getCxGridPropSparklineStyle_Field();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBooleanStyleImpl <em>Cx Grid Prop Boolean Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBooleanStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropBooleanStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_BOOLEAN_STYLE = eINSTANCE.getCxGridPropBooleanStyle();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropNumberStyleImpl <em>Cx Grid Prop Number Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropNumberStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropNumberStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_NUMBER_STYLE = eINSTANCE.getCxGridPropNumberStyle();

		/**
		 * The meta object literal for the '<em><b>Number Format</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_NUMBER_STYLE__NUMBER_FORMAT = eINSTANCE.getCxGridPropNumberStyle_NumberFormat();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBlobImageStyleImpl <em>Cx Grid Prop Blob Image Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropBlobImageStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropBlobImageStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_BLOB_IMAGE_STYLE = eINSTANCE.getCxGridPropBlobImageStyle();

		/**
		 * The meta object literal for the '<em><b>Configs</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_PROP_BLOB_IMAGE_STYLE__CONFIGS = eINSTANCE.getCxGridPropBlobImageStyle_Configs();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropImageStyleImpl <em>Cx Grid Prop Image Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropImageStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropImageStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_IMAGE_STYLE = eINSTANCE.getCxGridPropImageStyle();

		/**
		 * The meta object literal for the '<em><b>Configs</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_PROP_IMAGE_STYLE__CONFIGS = eINSTANCE.getCxGridPropImageStyle_Configs();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropIndicatorStyleImpl <em>Cx Grid Prop Indicator Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropIndicatorStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropIndicatorStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_INDICATOR_STYLE = eINSTANCE.getCxGridPropIndicatorStyle();

		/**
		 * The meta object literal for the '<em><b>Green Starts</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_INDICATOR_STYLE__GREEN_STARTS = eINSTANCE.getCxGridPropIndicatorStyle_GreenStarts();

		/**
		 * The meta object literal for the '<em><b>Red Ends</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_INDICATOR_STYLE__RED_ENDS = eINSTANCE.getCxGridPropIndicatorStyle_RedEnds();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropDateStyleImpl <em>Cx Grid Prop Date Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropDateStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropDateStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_DATE_STYLE = eINSTANCE.getCxGridPropDateStyle();

		/**
		 * The meta object literal for the '<em><b>Date Format</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_DATE_STYLE__DATE_FORMAT = eINSTANCE.getCxGridPropDateStyle_DateFormat();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigImpl <em>Config</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridStyleConfig()
		 * @generated
		 */
		EClass CX_GRID_STYLE_CONFIG = eINSTANCE.getCxGridStyleConfig();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigStringToResourceImpl <em>Config String To Resource</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigStringToResourceImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridStyleConfigStringToResource()
		 * @generated
		 */
		EClass CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE = eINSTANCE.getCxGridStyleConfigStringToResource();

		/**
		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE__VALUE = eINSTANCE.getCxGridStyleConfigStringToResource_Value();

		/**
		 * The meta object literal for the '<em><b>Compare</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE__COMPARE = eINSTANCE.getCxGridStyleConfigStringToResource_Compare();

		/**
		 * The meta object literal for the '<em><b>Resource Theme Path</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_STYLE_CONFIG_STRING_TO_RESOURCE__RESOURCE_THEME_PATH = eINSTANCE.getCxGridStyleConfigStringToResource_ResourceThemePath();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigNumericToResourceImpl <em>Config Numeric To Resource</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStyleConfigNumericToResourceImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridStyleConfigNumericToResource()
		 * @generated
		 */
		EClass CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE = eINSTANCE.getCxGridStyleConfigNumericToResource();

		/**
		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE__VALUE = eINSTANCE.getCxGridStyleConfigNumericToResource_Value();

		/**
		 * The meta object literal for the '<em><b>Compare</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE__COMPARE = eINSTANCE.getCxGridStyleConfigNumericToResource_Compare();

		/**
		 * The meta object literal for the '<em><b>Resource Theme Path</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_STYLE_CONFIG_NUMERIC_TO_RESOURCE__RESOURCE_THEME_PATH = eINSTANCE.getCxGridStyleConfigNumericToResource_ResourceThemePath();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridEventTopicAble <em>Cx Grid Event Topic Able</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridEventTopicAble
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridEventTopicAble()
		 * @generated
		 */
		EClass CX_GRID_EVENT_TOPIC_ABLE = eINSTANCE.getCxGridEventTopicAble();

		/**
		 * The meta object literal for the '<em><b>Event Topic</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_EVENT_TOPIC_ABLE__EVENT_TOPIC = eINSTANCE.getCxGridEventTopicAble_EventTopic();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropQuantityStyleImpl <em>Cx Grid Prop Quantity Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropQuantityStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropQuantityStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_QUANTITY_STYLE = eINSTANCE.getCxGridPropQuantityStyle();

		/**
		 * The meta object literal for the '<em><b>Value Property Path</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_PROP_QUANTITY_STYLE__VALUE_PROPERTY_PATH = eINSTANCE.getCxGridPropQuantityStyle_ValuePropertyPath();

		/**
		 * The meta object literal for the '<em><b>Value Property Dot Path</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_QUANTITY_STYLE__VALUE_PROPERTY_DOT_PATH = eINSTANCE.getCxGridPropQuantityStyle_ValuePropertyDotPath();

		/**
		 * The meta object literal for the '<em><b>Value Number Format</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_QUANTITY_STYLE__VALUE_NUMBER_FORMAT = eINSTANCE.getCxGridPropQuantityStyle_ValueNumberFormat();

		/**
		 * The meta object literal for the '<em><b>Uom Property Path</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_PROP_QUANTITY_STYLE__UOM_PROPERTY_PATH = eINSTANCE.getCxGridPropQuantityStyle_UomPropertyPath();

		/**
		 * The meta object literal for the '<em><b>Uom Property Dot Path</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_QUANTITY_STYLE__UOM_PROPERTY_DOT_PATH = eINSTANCE.getCxGridPropQuantityStyle_UomPropertyDotPath();

		/**
		 * The meta object literal for the '<em><b>Html Pattern</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_QUANTITY_STYLE__HTML_PATTERN = eINSTANCE.getCxGridPropQuantityStyle_HtmlPattern();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropPriceStyleImpl <em>Cx Grid Prop Price Style</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridPropPriceStyleImpl
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridPropPriceStyle()
		 * @generated
		 */
		EClass CX_GRID_PROP_PRICE_STYLE = eINSTANCE.getCxGridPropPriceStyle();

		/**
		 * The meta object literal for the '<em><b>Value Property Path</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_PROP_PRICE_STYLE__VALUE_PROPERTY_PATH = eINSTANCE.getCxGridPropPriceStyle_ValuePropertyPath();

		/**
		 * The meta object literal for the '<em><b>Value Property Dot Path</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_PRICE_STYLE__VALUE_PROPERTY_DOT_PATH = eINSTANCE.getCxGridPropPriceStyle_ValuePropertyDotPath();

		/**
		 * The meta object literal for the '<em><b>Value Number Format</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_PRICE_STYLE__VALUE_NUMBER_FORMAT = eINSTANCE.getCxGridPropPriceStyle_ValueNumberFormat();

		/**
		 * The meta object literal for the '<em><b>Currency Property Path</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CX_GRID_PROP_PRICE_STYLE__CURRENCY_PROPERTY_PATH = eINSTANCE.getCxGridPropPriceStyle_CurrencyPropertyPath();

		/**
		 * The meta object literal for the '<em><b>Currency Property Dot Path</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_PRICE_STYLE__CURRENCY_PROPERTY_DOT_PATH = eINSTANCE.getCxGridPropPriceStyle_CurrencyPropertyDotPath();

		/**
		 * The meta object literal for the '<em><b>Html Pattern</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CX_GRID_PROP_PRICE_STYLE__HTML_PATTERN = eINSTANCE.getCxGridPropPriceStyle_HtmlPattern();

		/**
		 * The meta object literal for the '{@link org.eclipse.osbp.infogrid.model.gridsource.style.CxGridCompare <em>Cx Grid Compare</em>}' enum.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.CxGridCompare
		 * @see org.eclipse.osbp.infogrid.model.gridsource.style.impl.CxGridStylePackageImpl#getCxGridCompare()
		 * @generated
		 */
		EEnum CX_GRID_COMPARE = eINSTANCE.getCxGridCompare();

	}

} //CxGridStylePackage
