/// <summary>
 /// Initializes a new instance of the <see cref="IModelo2D"/> class.
 /// </summary>
 /// <param name="ModelType">Type of the model.</param>
 public IModelo2D(ModelType ModelType)
 {
     this.ModelType = ModelType;
     LayerDepth = 0;
     SourceRectangle = null;
     Rotation = 0;
 }

 public MyModel(Project1Game game, VertexPositionColor[] shapeArray, String textureName)
 {
     this.vertices = Buffer.Vertex.New(game.GraphicsDevice, shapeArray);
     this.inputLayout = VertexInputLayout.New<VertexPositionColor>(0);
     vertexStride = Utilities.SizeOf<VertexPositionColor>();
     modelType = ModelType.Colored;
 }

        public static void GenConvertToModel(StringBuilder builder, ModelType Model)
        {
            string ModelName = Model.Name.Value;

            builder.AppendLine(GeneratorUtil.TabString(1) + @"public static " + ModelName + " " + GetConvertName(Model.Name.Value) + "(DataRow row )");
            builder.AppendLine(GeneratorUtil.TabString(1) + "{");
            builder.AppendLine(GeneratorUtil.TabString(2)   + ModelName + " info = new " + ModelName + "();");
            foreach (FieldType field in Model.MyFields)
            {
                string systemType = field.SystemType.Value;
                string fieldName = field.Name.Value;
                string columnName = field.ColumnName.Value;

                builder.AppendLine(GeneratorUtil.TabString(2) + "if ( row[\"" + columnName + "\"] == DBNull.Value)");
                builder.AppendLine(GeneratorUtil.TabString(2) + "{");
                if (!field.NullAble.Value)
                {
                    builder.AppendLine(GeneratorUtil.TabString(3) + "info." + fieldName + " = default(" + systemType + ");");
                }
                builder.AppendLine(GeneratorUtil.TabString(2) + "}");
                builder.AppendLine(GeneratorUtil.TabString(2) + "else");
                builder.AppendLine(GeneratorUtil.TabString(2) + "{");
                builder.AppendLine(GeneratorUtil.TabString(3) + "info." + fieldName + " = (" + systemType + ")row[\"" + columnName + "\"];");
                builder.AppendLine(GeneratorUtil.TabString(2) + "}");
            }
            builder.AppendLine(GeneratorUtil.TabString(2) + "return info;");
            builder.AppendLine(GeneratorUtil.TabString(1) + "}");
        }

    public HandRepresentation(int handID, Hand hand, Chirality chirality, ModelType modelType) {
      HandID = handID;
      this.MostRecentHand = hand;
      this.RepChirality = chirality;
      this.RepType = modelType;

    }

        public NewDbContextTemplateModel(string dbContextName, ModelType modelType)
        {
            if (dbContextName == null)
            {
                throw new ArgumentNullException(nameof(dbContextName));
            }

            if (modelType == null)
            {
                throw new ArgumentNullException(nameof(modelType));
            }

            var modelNamespace = modelType.Namespace;

            ModelTypeName = modelType.Name;
            RequiredNamespaces = new HashSet<string>();

            var classNameModel = new ClassNameModel(dbContextName);

            DbContextTypeName = classNameModel.ClassName;
            DbContextNamespace = classNameModel.NamespaceName;

            if (!string.IsNullOrEmpty(modelNamespace) &&
                !string.Equals(modelNamespace, DbContextNamespace, StringComparison.Ordinal))
            {
                RequiredNamespaces.Add(modelNamespace);
            }
        }

 internal JsonInstance(ModelType type, string id)
 {
     this.Type = type;
     this.Id = id;
     this.instance = new ModelInstance(this);
     instanceProperties = new object[Type.Properties.Count];
 }

 public static bool IsASupportedModelType(ModelType modelType)
 {
     switch(modelType)
     {
         case ModelType.Truss1D:
             return false;
         case ModelType.Beam1D:
             return true;
         case ModelType.Truss2D:
             return false;
         case ModelType.Frame2D:
             return true;
         case ModelType.Slab2D:
             return true;
         case ModelType.Membrane2D:
             return false;
         case ModelType.Truss3D:
             return false;
         case ModelType.Membrane3D:
             return false;
         case ModelType.MultiStorey2DSlab:
             return true;
         case ModelType.Full3D:
             return true;
         default:
             throw new NotImplementedException(string.Format(
                 System.Globalization.CultureInfo.InvariantCulture,
                 "Linear3DBeam.IsSupportedModelType(ModelType) has not been defined for a model type of {0}",
                 modelType));
     }
 }

        private async void LoadData(Uri location, ModelType modelType = ModelType.Line)
        {
            if (HttpClient != null)
            {
                _httpClient.BaseAddress = location;
                var response = await _httpClient.GetAsync(_httpClient.BaseAddress);
                response.EnsureSuccessStatusCode();
                var jsonResult = response.Content.ReadAsStringAsync().Result;

                var resultArray = JsonConvert.DeserializeObject(jsonResult);
                var result = resultArray as JArray;

                switch (modelType)
                {
                    case ModelType.Line:                        
                        foreach (JObject jsonObj in result)
                        {
                            Line line = JsonConvert.DeserializeObject<Line>(jsonObj.ToString());
                            Lines.Add(line);
                        }                        
                        break;

                    case ModelType.Stop:
                        foreach (var jsonObj in result)
                        {
                            var stop = JsonConvert.DeserializeObject<Stop>(jsonObj.ToString());
                            Stops.Add(stop);
                        }
                        break;

                    default:
                        break;
                }
            }
        }

        public override HandRepresentation MakeHandRepresentation(Leap.Hand hand, ModelType modelType)
        {
            HandRepresentation handRep = null;
              for (int i = 0; i < ModelPool.Count; i++) {
            IHandModel model = ModelPool[i];

            bool isCorrectHandedness;
            if(model.Handedness == Chirality.Either) {
              isCorrectHandedness = true;
            } else {
              Chirality handChirality = hand.IsRight ? Chirality.Right : Chirality.Left;
              isCorrectHandedness = model.Handedness == handChirality;
            }

            bool isCorrectModelType;
            isCorrectModelType = model.HandModelType == modelType;

            if(isCorrectHandedness && isCorrectModelType) {
              ModelPool.RemoveAt(i);
              handRep = new HandProxy(this, model, hand);
              break;
            }
              }
              return handRep;
        }

 public MyModel(LabGame game, VertexPositionColor[] shapeArray, String textureName, float collisionRadius)
 {
     this.vertices = Buffer.Vertex.New(game.GraphicsDevice, shapeArray);
     this.inputLayout = VertexInputLayout.New<VertexPositionColor>(0);
     vertexStride = Utilities.SizeOf<VertexPositionColor>();
     modelType = ModelType.Colored;
     this.collisionRadius = collisionRadius;
 }

 protected ModelMethodParameter(ModelMethod method, string name, Type parameterType, ModelType referenceType, bool isList)
 {
     this.Method = method;
     this.Name = name;
     this.ParameterType = parameterType;
     this.ReferenceType = referenceType;
     this.IsList = isList;
 }

 private void SaveResearchInfo(Guid researchID, 
     string researchName,
     ResearchType rType,
     ModelType mType,
     int realizationCount)
 {
     throw new NotImplementedException();
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="dsElementName"></param>
 /// <param name="dataType"></param>
 /// <param name="alias"></param>
 /// <param name="allowsNull"></param>
 public DisplaySetServiceArgumentInfo(string name, string dsElementName, ModelType dataType, string alias, bool allowsNull)
 {
     mName = name;
     mDSElementName = dsElementName;
     mDataType = dataType;
     mAlias = alias;
     mAllowsNull = allowsNull;
 }

 public HandProxy(HandPool parent, Hand hand, Chirality repChirality, ModelType repType) :
   base(hand.Id, hand, repChirality, repType)
 {
   this.parent = parent;
   this.RepChirality = repChirality;
   this.RepType = repType;
   this.MostRecentHand = hand;
 }

        /// <summary>
        /// Constructor
        /// </summary>
        public ModelInfo(string projectId, string modelId, List<Guid> elementIds, ModelType modelType)
        {
            ProjectId = projectId;
            ModelId = modelId;
            ElementIds = elementIds;
            ModelType = modelType;

            _controller = DataController.Instance;
        }

        /// <summary>
        /// Apply display format by default for all data types
        /// All the values will be shown using those formats
        /// </summary>
        /// <param name="value">Value.</param>
        /// <param name="dataType">Data type.</param>
        /// <returns>string.</returns>
        public static string ApplyDisplayFormat(object value, ModelType dataType)
        {
            if (value == null)
            {
                return string.Empty;
            }
            try
            {
                string format = GetDefaultDisplayMask(dataType);
                switch (dataType)
                {
                    case ModelType.Date:
                        DateTime DateAux = System.Convert.ToDateTime(value, CultureManager.Culture);
                        return DateAux.ToString(format);

                    case ModelType.DateTime:
                        DateTime DateTimeAux = System.Convert.ToDateTime(value, CultureManager.Culture);
                        return DateTimeAux.ToString(format);

                    case ModelType.Time:
                        DateTime TimeAux = System.Convert.ToDateTime(value.ToString(), CultureManager.Culture);
                        return TimeAux.ToString(format);

                    case ModelType.Autonumeric:
                    case ModelType.Int:
                        int IntAux = System.Convert.ToInt32(value);
                        return IntAux.ToString(format);

                    case ModelType.Nat:
                        UInt32 NatAux = System.Convert.ToUInt32(value);
                        return NatAux.ToString(format);

                    case ModelType.Real:
                        Decimal RealAux = System.Convert.ToDecimal(value);
                        return RealAux.ToString(format);

                    case ModelType.String:
                    case ModelType.Password:
                    case ModelType.Blob:
                    case ModelType.Text:
                        string StringAux = System.Convert.ToString(value);
                        return StringAux.ToString(CultureManager.Culture);

                    case ModelType.Bool:
                        bool BoolAux = System.Convert.ToBoolean(value);
                        return BoolAux.ToString(CultureManager.Culture);

                    default:
                        return value.ToString();
                }
            }
            catch
            {
                return value.ToString();
            }
        }

 public GH_Model(ModelType modelType)
 {
     this.ModelType = modelType;
     this.Model = new FiniteElementModel(ModelType);
     this.Nodes = new List<FiniteElementNode>();
     this.Points = new List<Point3d>();
     this.Results = null;
     this.Elements = new List<GH_Element>();
     this.Loads = new List<GH_Load>();
     this.Supports = new List<GH_Support>();
 }

        /// <summary>
        /// Creates a new <see cref="ModelSource"/> for the specified root type and path.
        /// </summary>
        /// <param name="rootType">The root type name, which is required for instance paths</param>
        /// <param name="path">The source path, which is either an instance path or a static path</param>
        public ModelSource(ModelType rootType, string path)
        {
            // Raise an error if the specified path is not valid
            if (!pathValidation.IsMatch(path))
                throw new ArgumentException("The specified path, '" + path + "', was not valid path syntax.");

            // Raise an error if the specified path is not valid
            ModelProperty property;
            if (!InitializeFromTypeAndPath(rootType, path, out property))
                throw new ArgumentException("The specified path, '" + path + "', was not valid for the root type of '" + rootType.Name + "'.", "path");
        }

        /// <summary>
        /// Retrieves available analyze options for specified research type and model type.
        /// </summary>
        /// <param name="rt">Research type.</param>
        /// <param name="mt">Model type.</param>
        /// <returns>Available analyze options.</returns>
        /// <note>Analyze option is available for research, if it is available 
        /// both for research type and model type.</note>
        public static AnalyzeOption GetAvailableAnalyzeOptions(ResearchType rt, ModelType mt)
        {
            ResearchTypeInfo[] rInfo = (ResearchTypeInfo[])rt.GetType().GetField(rt.ToString()).GetCustomAttributes(typeof(ResearchTypeInfo), false);
            Type researchType = Type.GetType(rInfo[0].Implementation, true);

            AvailableAnalyzeOption rAvailableOptions = ((AvailableAnalyzeOption[])researchType.GetCustomAttributes(typeof(AvailableAnalyzeOption), true))[0];

            ModelTypeInfo[] mInfo = (ModelTypeInfo[])mt.GetType().GetField(mt.ToString()).GetCustomAttributes(typeof(ModelTypeInfo), false);
            Type modelType = Type.GetType(mInfo[0].Implementation, true);

            AvailableAnalyzeOption mAvailableOptions = ((AvailableAnalyzeOption[])modelType.GetCustomAttributes(typeof(AvailableAnalyzeOption), true))[0];

            return rAvailableOptions.Options & mAvailableOptions.Options;
        }

        public ModelTypeInfo GetModelTypeInfo(ModelType type)
        {
            // Create the set of type instance information if not initialized
            if (Instances == null)
                Instances = new Dictionary<string, ModelTypeInfo>();

            // Get or initialize the model type instance information store
            ModelTypeInfo typeInfo;
            if (!Instances.TryGetValue(type.Name, out typeInfo))
                Instances[type.Name] = typeInfo = new ModelTypeInfo();

            // Return the requested value
            return typeInfo;
        }