public ABS_Layer(LayerType T_in, double depth_in, double Flow_Resistance, double _porosity, double YoungsModulus, double density, double PoissonsRatio, double tortuosity, double Viscous_Characteristic_Length, double Thermal_Permeability, double SpeedofSound)
 {
     T = T_in;
     depth = depth_in;
     Flow_Resist = Flow_Resistance;
     porosity = _porosity;
 }

 public ILayer CreateLayer(int neurons, LayerType type)
 {
     var layer = new Layer();
     layer.Type = type;
     layer.Neurons = (List<INeuron>) neuronFactory.CreateNeuronCollection(neurons);
     return layer;
 }

 public ColorLayer(LayerType type,
 DataUsed dataused,
 Interp interp,
 ProcessLayer calcdata,
 IGradientMap gr,
 double param1 = 0,
 double param2 = 0,
 double cycle = 1,
 double alpha = 1,
 double saturation = 1,
 double value = 1,
 LayerExtra alphaextr = LayerExtra.LAYER_EXTRA_NORMAL,
 LayerExtra saturationextr = LayerExtra.LAYER_EXTRA_NORMAL,
 LayerExtra valueextr = LayerExtra.LAYER_EXTRA_NORMAL)
 {
     c_type = type;
       c_dataused = dataused;
       c_interp = interp;
       c_valueextr = valueextr;
       c_saturationextr = saturationextr;
       c_alphaextr = alphaextr;
       c_param1 = param1;
       c_param2 = param2;
       c_value = value;
       c_saturation = saturation;
       c_alpha = alpha;
       c_cycle = cycle;
       c_calcdata = calcdata;
       c_gr = gr;
 }

 private Color GetLayerColor(LayerType fx)
 {
     Color color = null;
     switch (fx)
     {
         case LayerType.f1:
             color = Color.FromColorIndex(ColorMethod.ByAci, 7);
             break;
         case LayerType.f2:
             color = Color.FromColorIndex(ColorMethod.ByAci, 210);
             break;
         case LayerType.f3:
             color = Color.FromColorIndex(ColorMethod.ByAci, 1);
             break;
         case LayerType.f4:
             color = Color.FromColorIndex(ColorMethod.ByAci, 70);
             break;
         case LayerType.f5:
             color = Color.FromColorIndex(ColorMethod.ByAci, 132);
             break;
         case LayerType.f6:
             color = Color.FromColorIndex(ColorMethod.ByAci, 132);
             break;
         case LayerType.AC:
             color = Color.FromColorIndex(ColorMethod.ByAci, 1);
             break;
     }
     return color;
 }

 /// <summary>
 /// Constructor for Drawing PolyLines and Polygons
 /// </summary>
 /// <param name="layerType"></param>
 /// <param name="x"></param>
 /// <param name="y"></param>
 /// <param name="bEditingStarted"></param>
 /// <param name="mainControler"></param>
 public DrawAction(LayerType layerType, double x, double y, bool bEditingStarted, MainControler mainControler)
 {
     this.layerType = layerType;
     this.mainControler = mainControler;
     this.x = x;
     this.y = y;
     this.bEditingStarted = bEditingStarted;
 }

 private void CreateIfDoesntExists(string layerName, LayerType fx, bool isPlottable)
 {
     Transaction trans = db.TransactionManager.StartTransaction();
     using (trans)
     {
         CreateIfDoesntExists(trans, layerName, fx, isPlottable);
         trans.Commit();
     }
 }

 GameObject CreateLayerGameObject(string name, LayerType type)
 {
     GameObject layer = new GameObject(name);
     layer.transform.parent = mParent.transform;
     layer.transform.localPosition = new Vector3(0,0,((int)type) * -1);
     layer.transform.localEulerAngles = Vector3.zero;
     layer.transform.localScale = Vector3.one;
     return layer;
 }

		/// <summary>
		/// Called when [element changed].
		/// </summary>
		/// <param name="e">The e.</param>
		protected override void OnElementChanged(ElementChangedEventArgs<Image> e)
		{
			base.OnElementChanged(e);

			if (e.OldElement == null && (int)Android.OS.Build.VERSION.SdkInt < 15)
			{
				LayerType it = new LayerType ();
				SetLayerType(it, null);
			}
		}

 public LayerControl(string name, bool visible, LayerType type)
 {
     this.visible = visible;
     this.type = type;
     this.Initialize();
     this.Index = "0";
     this.Name = name;
     this.Text = name;
     this.Selected = false;
 }

    GameObject CreateLayerTypeObject(string name, LayerType lType)
    {
        GameObject layer = new GameObject(name);
        layer.transform.SetParent(layerParent);
        layer.transform.localEulerAngles = Vector3.zero;
        layer.transform.localScale = Vector3.one;
        layer.transform.localPosition = new Vector3(0, 0, (int)lType);

        return layer;
    }

        public GameTileLayer(int width, int height, LayerType.LayerTypesEnum layerType)
            : base(width, height, layerType)
        {
            m_layerLayout = new GameTile[width, height];

            //Set tile layer layout to be empty
            for (int x = 0; x < m_layoutWidth; x++)
                for (int y = 0; y < m_layoutHeight; y++)
                    m_layerLayout[x, y] = new GameTile(EMPTYTILEINDEX, new Point(x * TileWidth, y * TileHeight));
        }

        public TileLayer(int width, int height, LayerType.LayerTypesEnum layerType)
        {
            m_tileTextureList = new List<Texture2D>();

            m_layoutWidth = width;
            m_layoutHeight = height;

            m_layerType = layerType;

            m_alphaChannel = 1.0f;
        }

 private LayerTableRecord GetLayer(string layerName, LayerType fx, bool isPlottable, Transaction trans)
 {
     LayerTableRecord ltr = new LayerTableRecord();
     ltr.Name = layerName;
     Color color = GetLayerColor(fx);
     ltr.Color = color;
     LinetypeTable ltt = trans.GetObject(db.LinetypeTableId, OpenMode.ForRead) as LinetypeTable;
     ltr.LinetypeObjectId = ltt["Continuous"];
     ltr.IsPlottable = isPlottable;
     return ltr;
 }

        public void deleteLayer(LayerType layerType)
        {
            layers[(int)layerType].isSet = false;

            layers[(int)layerType].breakLinks();

            if (layerType == LayerType.SILICON_N ^ layerType == LayerType.SILICON_P)
                via = false;

            draw();
        }

        //---------------------------------------------------------------------
        public Layer(LayerName name, LayerType type)
        {
            this.name = name;
            this.type = type;
            this.carbon = 0.0;
            this.nitrogen = 0.0;

            this.decayValue = 0.0;
            this.fractionLignin = 0.0;

            this.netMineralization = 0.0;
            this.grossMineralization = 0.0;
        }

        public EditorTileLayer(int width, int height, LayerType.LayerTypesEnum layerType)
            : base(width, height, layerType)
        {
            m_layerLayout = new EditorTile[width, height];

            //Set tile layer layout to be empty
            for (int x = 0; x < m_layoutWidth; x++)
                for (int y = 0; y < m_layoutHeight; y++)
                    m_layerLayout[x, y] = new EditorTile(EMPTYTILEINDEX, new Point(x * TileWidth, y * TileHeight));

            //initialize tile rectangle, only it's position will be changing in draws, not it's width or height unless tilewidth, or tileheight we changed
            m_tileRectangle = new Rectangle(0, 0, TileLayer.TileWidth, TileLayer.TileHeight);
        }

    public void SetLayer(GameObject current,LayerType type)
    {
        if(mLayerDic.Count < Enum.GetNames(typeof(LayerType)).Length){
            LayerInit();
        }

        current.transform.parent = mLayerDic[type].transform;
        UIPanel[] panelArr = current.GetComponentsInChildren<UIPanel>(true);

        foreach(UIPanel panel in panelArr){
            panel.depth += (int)type;
        }
    }

        private void LayerPane_ItemTypeChanged(object sender, int index, LayerType type)
        {
            if (this.ActiveMapPanel != null)
            {
                GameMapLayer layer = this.ActiveMapPanel.Map.GetLayerAt(index);

                if (layer != null)
                {
                    layer.Type = type;
                }
                else throw new NullReferenceException("Tentative de modification du type d'un objet inexistant");
            }
            else throw new NullReferenceException("Tentative de modification d'un control enfant inexistant");
        }

 /// <summary>
 /// 设置Layer
 /// </summary>
 /// <param name="obj"></param>
 /// <param name="lType"></param>
 public void SetLayer(GameObject obj, LayerType lType)
 {
     int nums = Enum.GetNames(typeof(LayerType)).Length;
     if (layerTypeDict.Count < nums)
     {
         InitLayerType();
     }
     obj.transform.SetParent(layerTypeDict[lType].transform);
     UIPanel[] panels = obj.GetComponentsInChildren<UIPanel>(true);
     foreach (UIPanel panel in panels)
     {
         panel.depth += (int)lType;
     }
 }

    public static string LayerTypeToString(LayerType type)
    {
        switch(type)
        {
            case LayerType.Actor:
                return "Actor";
            case LayerType.Mothership:
                return "Mothership";
            case LayerType.Projectile:
                return "Projectile";
        }

        return "Invalid";
    }