Exemplo n.º 1
0
        //get the default time step
        //TODO: obtain the time step from 'Variable' class instead
        public static TimeStep GetDefaultTimeStep(VariableEnum v, TimeInterval interval)
        {
            int periodLength = (int)interval.Length.TotalDays;

            switch (v)
            {
                case VariableEnum.Stage:
                case VariableEnum.Discharge:
                    return (periodLength > 300) ? TimeStep.Day : TimeStep.Hour;
                case VariableEnum.Temperature:
                    return (periodLength > 31) ? TimeStep.Day : TimeStep.Hour;
                case VariableEnum.PrecipHour:
                    return TimeStep.Hour;
                default:
                    return TimeStep.Day;
            }
        }
Exemplo n.º 2
0
        protected virtual void AddVariable(SerializedProperty variables, int index, VariableEnum type)
        {
            if (index < 0 || index > variables.arraySize)
            {
                return;
            }

            variables.serializedObject.Update();
            variables.InsertArrayElementAtIndex(index);
            SerializedProperty variableProperty = variables.GetArrayElementAtIndex(index);

            variableProperty.FindPropertyRelative("variableType").enumValueIndex = (int)type;

            variableProperty.FindPropertyRelative("name").stringValue = "";
            variableProperty.FindPropertyRelative("objectValue").objectReferenceValue = null;
            variableProperty.FindPropertyRelative("dataValue").stringValue            = "";

            variables.serializedObject.ApplyModifiedProperties();
            GUI.FocusControl(null);
        }
Exemplo n.º 3
0
 public static Variable GetItemByEnum(VariableEnum varEnum)
 {
     return new Variable(selectRow("enum='" + varEnum + "'"));
 }
Exemplo n.º 4
0
 // set the metadata in page header from local resource file!
 private void setMetaData(VariableEnum varEnum)
 {
     string varName = varEnum.ToString() + ".text";
     // meta_language
     Master.MetaLanguage = String.Format("<meta http-equiv='content-language' content='{0}' />",
         Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName);
     // meta_description
     Master.MetaDescription = "<meta name='description' content='" +
         GetLocalResourceObject("MetaDescription_" + varName) + "' />";
     // meta_keywords
     Master.MetaKeywords = "<meta name='keywords' content='" +
         GetLocalResourceObject("MetaKeywords_" + varName) + "' />";
 }
Exemplo n.º 5
0
    // sets initial values to dropdownlists in the page form
    private void initialize(VariableEnum varEnum)
    {
        string cultStr = Thread.CurrentThread.CurrentCulture.ToString();

        SetNavigationMenu();

        string[] variableList;
        variableList = new string[4] { Resources.global.Var_Snow, Resources.global.Var_Precip, Resources.global.Var_Stage, Resources.global.Var_Discharge };

        int orderListCount = 4;
        Dictionary<int,string> orderList = new Dictionary<int,string>();

        for ( int i = 0; i < orderListCount; ++i )
        {
            // special case: recognize river/territory
            if ( i == 1 & ( varEnum == VariableEnum.Stage | varEnum == VariableEnum.Discharge ) )
            {
                orderList.Add(i, GetLocalResourceObject("StationOrderType_River").ToString());
            }
            else
            {
                orderList.Add(i, GetLocalResourceObject("StationOrderType_" + ( i + 1 ).ToString()).ToString());
            }
        }

        select_station_type.DataSource = variableList;
        select_station_type.DataBind();
        select_order.DataSource = orderList;
        select_order.DataTextField = "Value";
        select_order.DataValueField = "Key";
        select_order.DataBind();

        if ( varEnum == VariableEnum.Stage | varEnum == VariableEnum.Discharge )
        {
            th_location.Text = GetLocalResourceObject("LocationHeader2.Text").ToString();
        }
    }
Exemplo n.º 6
0
        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            EditorGUI.BeginProperty(position, label, property);

            var name         = property.FindPropertyRelative("name");
            var objectValue  = property.FindPropertyRelative("objectValue");
            var dataValue    = property.FindPropertyRelative("dataValue");
            var variableType = property.FindPropertyRelative("variableType");

            float y      = position.y;
            float x      = position.x;
            float height = GetPropertyHeight(property, label);
            float width  = position.width - HORIZONTAL_GAP * 2;

            Rect nameRect  = new Rect(x, y, Mathf.Min(200, width * 0.4f), height);
            Rect typeRect  = new Rect(nameRect.xMax + HORIZONTAL_GAP, y, Mathf.Min(120, width * 0.2f), height);
            Rect valueRect = new Rect(typeRect.xMax + HORIZONTAL_GAP, y, position.xMax - typeRect.xMax - HORIZONTAL_GAP, height);

            EditorGUI.PropertyField(nameRect, name, GUIContent.none);

            VariableEnum variableTypeValue = (VariableEnum)variableType.enumValueIndex;

            if (variableTypeValue == VariableEnum.Component)
            {
                int index = 0;
                List <System.Type> types = new List <System.Type>();
                var component            = (Component)objectValue.objectReferenceValue;
                if (component != null)
                {
                    GameObject go = component.gameObject;
                    foreach (var c in go.GetComponents <Component>())
                    {
                        if (!types.Contains(c.GetType()))
                        {
                            types.Add(c.GetType());
                        }
                    }

                    for (int i = 0; i < types.Count; i++)
                    {
                        if (component.GetType().Equals(types[i]))
                        {
                            index = i;
                            break;
                        }
                    }
                }

                if (types.Count <= 0)
                {
                    types.Add(typeof(Transform));
                }

                List <GUIContent> contents = new List <GUIContent>();
                foreach (var t in types)
                {
                    contents.Add(new GUIContent(t.Name, t.FullName));
                }

                EditorGUI.BeginChangeCheck();
                var newIndex = EditorGUI.Popup(typeRect, GUIContent.none, index, contents.ToArray(), EditorStyles.popup);
                if (EditorGUI.EndChangeCheck())
                {
                    if (component != null)
                    {
                        objectValue.objectReferenceValue = component.gameObject.GetComponent(types[newIndex]);
                    }
                    else
                    {
                        objectValue.objectReferenceValue = null;
                    }
                }
            }
            else
            {
                EditorGUI.LabelField(typeRect, variableTypeValue.ToString());
            }

            switch (variableTypeValue)
            {
            case VariableEnum.Component:
                EditorGUI.BeginChangeCheck();
                objectValue.objectReferenceValue = EditorGUI.ObjectField(valueRect, GUIContent.none, objectValue.objectReferenceValue, typeof(UnityEngine.Component), true);
                if (EditorGUI.EndChangeCheck())
                {
                    if (string.IsNullOrEmpty(name.stringValue) && objectValue.objectReferenceValue != null)
                    {
                        name.stringValue = NormalizeName(objectValue.objectReferenceValue.name);
                    }
                }
                break;

            case VariableEnum.GameObject:
                EditorGUI.BeginChangeCheck();
                objectValue.objectReferenceValue = EditorGUI.ObjectField(valueRect, GUIContent.none, objectValue.objectReferenceValue, typeof(UnityEngine.GameObject), true);
                if (EditorGUI.EndChangeCheck())
                {
                    if (string.IsNullOrEmpty(name.stringValue) && objectValue.objectReferenceValue != null)
                    {
                        name.stringValue = NormalizeName(objectValue.objectReferenceValue.name);
                    }
                }
                break;

            case VariableEnum.Object:
                EditorGUI.BeginChangeCheck();
                objectValue.objectReferenceValue = EditorGUI.ObjectField(valueRect, GUIContent.none, objectValue.objectReferenceValue, typeof(UnityEngine.Object), true);
                if (EditorGUI.EndChangeCheck())
                {
                    if (string.IsNullOrEmpty(name.stringValue) && objectValue.objectReferenceValue != null)
                    {
                        name.stringValue = NormalizeName(objectValue.objectReferenceValue.name);
                    }
                }
                break;

            case VariableEnum.Color:
                Color color = Utility.Converter.ToColor(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
                color = EditorGUI.ColorField(valueRect, GUIContent.none, color);
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(color);
                }
                break;

            case VariableEnum.Vector2:
                Vector2 vector2 = Utility.Converter.ToVector2(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
                vector2 = EditorGUI.Vector2Field(valueRect, GUIContent.none, vector2);
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(vector2);
                }
                break;

            case VariableEnum.Vector3:
                Vector3 vector3 = Utility.Converter.ToVector3(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
                vector3 = EditorGUI.Vector3Field(valueRect, GUIContent.none, vector3);
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(vector3);
                }
                break;

            case VariableEnum.Vector4:
                Vector4 vector4 = Utility.Converter.ToVector4(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
#if UNITY_5_6_OR_NEWER
                vector4 = EditorGUI.Vector4Field(valueRect, GUIContent.none, vector4);
#else
                var tmpRect = valueRect;
                tmpRect.y -= height;
                vector4    = EditorGUI.Vector4Field(tmpRect, "", vector4);
#endif
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(vector4);
                }
                break;

            case VariableEnum.Boolean:
                bool b = Utility.Converter.ToBoolean(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
                b = EditorGUI.Toggle(valueRect, GUIContent.none, b);
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(b);
                }
                break;

            case VariableEnum.Float:
                float f = Utility.Converter.ToSingle(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
                f = EditorGUI.FloatField(valueRect, GUIContent.none, f);
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(f);
                }
                break;

            case VariableEnum.Integer:
                int i = Utility.Converter.ToInt32(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
                i = EditorGUI.IntField(valueRect, GUIContent.none, i);
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(i);
                }
                break;

            case VariableEnum.String:
                string s = Utility.Converter.ToString(dataValue.stringValue);
                EditorGUI.BeginChangeCheck();
                s = EditorGUI.TextField(valueRect, GUIContent.none, s);
                if (EditorGUI.EndChangeCheck())
                {
                    dataValue.stringValue = Utility.Converter.GetString(s);
                }
                break;

            default:
                break;
            }
            EditorGUI.EndProperty();
        }
Exemplo n.º 7
0
        /// <summary>
        /// Gets data for the specified variable with conversion or rounding applied.
        /// </summary>
        /// <param name="isMetricUnits">Returns data in metric units if true, english units if false</param>
        /// <param name="useRound">Returns data with default rounding applied for the variable if true, no rounding if false</param>
        /// <param name="variableTypeEnum">Determines how to convert the value</param>
        /// <param name="variableEnum">Determines the variable value to return</param>
        /// <returns>Value of the variable</returns>
        public double?ValueForVariable(bool isMetricUnits, bool useRound, VariableTypeEnum variableTypeEnum, VariableEnum variableEnum)
        {
            double?value = null;

            switch (variableEnum)
            {
            case VariableEnum.Precip_TB3_Tot:
                value = this.PrecipTb3Tot;
                break;

            case VariableEnum.Precip_TX_Tot:
                value = this.PrecipTxTot;
                break;

            case VariableEnum.Precip_TB3_Today:
                value = this.PrecipTb3Today;
                break;

            case VariableEnum.Precip_TX_Today:
                value = this.PrecipTxToday;
                break;

            case VariableEnum.SoilSfcT:
                value = this.SoilSfcT;
                break;

            case VariableEnum.SoilT_5cm:
                value = this.SoilT5cm;
                break;

            case VariableEnum.SoilT_10cm:
                value = this.SoilT10cm;
                break;

            case VariableEnum.SoilT_20cm:
                value = this.SoilT20cm;
                break;

            case VariableEnum.SoilT_50cm:
                value = this.SoilT50cm;
                break;

            case VariableEnum.SoilT_100cm:
                value = this.SoilT100cm;
                break;

            case VariableEnum.Temp_C:
                value = this.TempC;
                break;

            case VariableEnum.AirT_1pt5m:
                value = this.AirT1pt5m;
                break;

            case VariableEnum.AirT_2m:
                value = this.AirT2m;
                break;

            case VariableEnum.AirT_9pt5m:
                value = this.AirT9pt5m;
                break;

            case VariableEnum.AirT_10m:
                value = this.AirT10m;
                break;

            case VariableEnum.SoilCond_tc:
                value = this.SoilCondTc;
                break;

            case VariableEnum.SoilWaCond_tc:
                value = this.SoilWaCondTc;
                break;

            case VariableEnum.wfv:
                value = this.Wfv;
                break;

            case VariableEnum.RH_2m:
                value = this.Rh2m;
                break;

            case VariableEnum.RH_10m:
                value = this.Rh10m;
                break;

            case VariableEnum.Pressure_1:
                value = this.Pressure1;
                break;

            case VariableEnum.Pressure_2:
                value = this.Pressure2;
                break;

            case VariableEnum.TotalRadn:
                value = this.TotalRadn;
                break;

            case VariableEnum.QuantRadn:
                value = this.QuantRadn;
                break;

            case VariableEnum.WndDir_2m:
                value = this.WndDir2m;
                break;

            case VariableEnum.WndDir_10m:
                value = this.WndDir10m;
                break;

            case VariableEnum.WndSpd_2m:
                value = this.WndSpd2m;
                break;

            case VariableEnum.WndSpd_10m:
                value = this.WndSpd10m;
                break;

            case VariableEnum.WndSpd_Vert:
                value = this.WndSpdVert;
                break;

            case VariableEnum.WndSpd_2m_Max:
                value = this.WndSpd2mMax;
                break;

            case VariableEnum.WndSpd_10m_Max:
                value = this.WndSpd10mMax;
                break;

            case VariableEnum.Batt:
                value = this.Batt;
                break;

            case VariableEnum.Door:
                value = this.Door;
                break;

            default:
                break;
            }

            if (!isMetricUnits && value.HasValue)
            {
                switch (variableTypeEnum)
                {
                case VariableTypeEnum.Minute_Precipitation:
                case VariableTypeEnum.Total_Precipitation:
                    value = value.Value * Constant.mm2Inches;
                    break;

                case VariableTypeEnum.Temperature:
                    value = value.Value * Constant.nineFifths + 32;
                    break;

                case VariableTypeEnum.Pressure:
                    value = value.Value * Constant.mb2InHg;
                    break;

                case VariableTypeEnum.Total_Radiation:
                    value = value.Value * Constant.wpsqm2lymin;
                    break;

                case VariableTypeEnum.Speed:
                case VariableTypeEnum.Vertical_Speed:
                    value = value.Value * Constant.mps2Mph;
                    break;

                default:
                    break;
                }
            }

            if (variableTypeEnum == VariableTypeEnum.Water_Content && value.HasValue)
            {
                value = Math.Round(value.Value * 100, 2);
            }

            if (useRound && value.HasValue)
            {
                switch (variableEnum)
                {
                case VariableEnum.Precip_TB3_Tot:
                    value = Math.Round(value.Value, 3);
                    break;

                case VariableEnum.Precip_TX_Tot:
                    value = Math.Round(value.Value, 3);
                    break;

                case VariableEnum.Precip_TB3_Today:
                    value = Math.Round(value.Value, 3);
                    break;

                case VariableEnum.Precip_TX_Today:
                    value = Math.Round(value.Value, 3);
                    break;

                case VariableEnum.SoilSfcT:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.SoilT_5cm:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.SoilT_10cm:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.SoilT_20cm:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.SoilT_50cm:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.SoilT_100cm:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.Temp_C:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.AirT_1pt5m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.AirT_2m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.AirT_9pt5m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.AirT_10m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.SoilCond_tc:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.SoilWaCond_tc:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.wfv:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.RH_2m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.RH_10m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.Pressure_1:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.Pressure_2:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.TotalRadn:
                    value = Math.Round(value.Value, 5);
                    break;

                case VariableEnum.QuantRadn:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.WndDir_2m:
                    value = Math.Round(value.Value, 1);
                    break;

                case VariableEnum.WndDir_10m:
                    value = Math.Round(value.Value, 1);
                    break;

                case VariableEnum.WndSpd_2m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.WndSpd_10m:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.WndSpd_Vert:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.WndSpd_2m_Max:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.WndSpd_10m_Max:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.Batt:
                    value = Math.Round(value.Value, 2);
                    break;

                case VariableEnum.Door:
                    break;

                default:
                    break;
                }
            }

            return(value);
        }
Exemplo n.º 8
0
        private void SetupGrid(GraphPane myPane, VariableEnum v)
        {
            //first do common grid settings
            myPane.XAxis.MajorGrid.DashOn = 6.0f;
            myPane.XAxis.MajorGrid.DashOff = 2.0f;
            myPane.XAxis.MajorGrid.Color = Color.LightGray;
            myPane.XAxis.MajorGrid.IsVisible = true;

            myPane.YAxis.MajorGrid.Color = Color.LightGray;
            myPane.YAxis.MajorGrid.DashOn = 6.0f;
            myPane.YAxis.MajorGrid.DashOff = 2.0f;
            myPane.YAxis.MajorGrid.IsVisible = true;

            //special variable-specific settings
            switch ( v )
            {
                case VariableEnum.Snow:
                    myPane.XAxis.MajorGrid.IsVisible = false;
                    break;
                default:
                    break;
            }
        }