예제 #1
0
 public ETimelineGroupPanel()
 {
     this.timglineGroup = SkillEditTempData.editingSkill;
     for (int i = 0; i < timglineGroup.TimeLines.Count; i++)
     {
         eTimelines.Add(new ETimeline(this, timglineGroup.TimeLines[i]));
     }
 }
예제 #2
0
    public TimeLineGroup Create(Type t)
    {
        TimeLineGroup tg = Activator.CreateInstance(t) as TimeLineGroup;

        tg.TimeLines.Add(new TimeLine());
        tg.TimeLines.Add(new TimeLine());
        SetName(tg);
        SetID(tg);
        SetPath(tg);
        return(tg);
    }
예제 #3
0
        public void Init(atriumBE.FileManager fm, DateTime rangeStartDate, DateTime rangeEndDate)
        {
            if (myFM == null)
            {
                myFM = fm;

                TimeLineGroup group = new TimeLineGroup(this.timeLine1.Fields["ContactId"]);
                timeLine1.Groups.Add(group);
            }

            UIHelper.ComboBoxInit("AppointmentNotification", ReminderDropDown, myFM);


            //JLL 2013-09-27 Translation for 2013/10 Build
            lblTZ.Text     = UIHelper.GetTimeZoneLabel();// TimeZoneInfo.Local.StandardName;
            RangeStartDate = rangeStartDate;
            RangeEndDate   = rangeEndDate;

            timeLine1.FirstDate = DateTime.Now.AddHours(-2);
            timeLine1.MinDate   = DateTime.Today;
        }
예제 #4
0
    void OnGUI()
    {
        var popups = new List <string>();

        for (int i = 0; i < SkillEditorUtility.skillTypes.Count; i++)
        {
            var type = SkillEditorUtility.skillTypes[i];
            popups.Add(type.FullName);
        }
        for (int i = 0; i < SkillEditorUtility.buffTypes.Count; i++)
        {
            var type = SkillEditorUtility.buffTypes[i];
            popups.Add(type.FullName);
        }
        for (int i = 0; i < SkillEditorUtility.eventTypes.Count; i++)
        {
            var type = SkillEditorUtility.eventTypes[i];
            popups.Add(type.FullName);
        }
        GUILayout.BeginVertical();
        GUILayout.BeginHorizontal();
        GUILayout.Label("名字");
        skillname = GUILayout.TextField(skillname, GUILayout.MinWidth(100));
        GUILayout.EndHorizontal();
        GUILayout.BeginHorizontal();
        GUILayout.Label("ID");
        id = GUILayout.TextField(id, GUILayout.MinWidth(100));
        GUILayout.EndHorizontal();
        GUILayout.BeginHorizontal();
        GUILayout.Label("路径");
        skillpath = GUILayout.TextField(skillpath, GUILayout.MinWidth(100));
        GUILayout.EndHorizontal();
        GUILayout.BeginHorizontal();
        GUILayout.Label("创建类型");
        selectedIndex = EditorGUILayout.Popup(selectedIndex, popups.ToArray());
        //  tgType = (TimelingGroupType)EditorGUILayout.EnumPopup(tgType, GUILayout.MinWidth(100));
        GUILayout.EndHorizontal();
        int id_int = 0;

        if (!string.IsNullOrEmpty(id) && int.TryParse(id, out id_int) && !string.IsNullOrEmpty(skillname) && !string.IsNullOrEmpty(skillpath) && (GUILayout.Button("创建")))
        {
            string                 path     = "";
            TimeLineGroup          tg       = null;
            JsonSerializerSettings settings = new JsonSerializerSettings {
                TypeNameHandling = TypeNameHandling.All
            };
            Type t = null;
            if (selectedIndex < SkillEditorUtility.skillTypes.Count)
            {
                tgType = TimelingGroupType.SKILL;
                t      = SkillEditorUtility.skillTypes[selectedIndex];
            }
            else if (selectedIndex < (SkillEditorUtility.skillTypes.Count + SkillEditorUtility.buffTypes.Count))
            {
                tgType = TimelingGroupType.BUFF;
                t      = SkillEditorUtility.buffTypes[selectedIndex - SkillEditorUtility.skillTypes.Count];
            }
            else
            {
                tgType = TimelingGroupType.EVENT;
                t      = SkillEditorUtility.eventTypes[selectedIndex - SkillEditorUtility.skillTypes.Count - SkillEditorUtility.buffTypes.Count];
            }
            tg = Create(t);
            if (tgType == TimelingGroupType.SKILL)
            {
                path += "Skills/";
                path += "skill_" + skillpath + ".bytes";
            }
            else if (tgType == TimelingGroupType.BUFF)
            {
                path += "Buffs/";
                path += "buff_" + skillpath + ".bytes";
            }
            else if (tgType == TimelingGroupType.EVENT)
            {
                path += "Events/";
                path += "event_" + skillpath + ".bytes";
            }
            string finalPath = SkillUtility.GetRequiredConfigsPath() + path;
            SkillUtility.SaveTimelineGroup(tg, finalPath);
            SkillUtility.SaveToSkillIndexFile(tg, path);
            skillWindow.OnCreate();
            Close();
        }
        GUILayout.EndVertical();
    }
예제 #5
0
        public override ChartData LoadChartData(ITabularDataView data)
        {
            var fmt = new BedValueFormatter(new DataFormatSettings());
            var res = new ChartData();

            res.ValueDefs = new ChartData.ValueDef[Items.Count];
            for (int i = 0; i < Items.Count; i++)
            {
                res.ValueDefs[i]        = new ChartData.ValueDef();
                res.ValueDefs[i].Column = Items[i].Column;
                res.ValueDefs[i].Label  = Items[i].Expression + (Items[i].Expression != TimeLineExpression.Count ? " " + Items[i].Column : "");
            }

            var tbl      = data.GetStructure(null);
            var colnames = tbl.Columns.GetNames();

            int[] valindexes = new int[Items.Count];
            for (int i = 0; i < Items.Count; i++)
            {
                valindexes[i] = colnames.IndexOfEx(Items[i].Column);
            }
            int dtcolindex = colnames.IndexOfEx(DateColumn);

            if (dtcolindex < 0)
            {
                return(res);
            }

            var dct = new Dictionary <string, TimeLineGroup>();

            var smallstep = SmallStep;

            if (!UseStructuredTime)
            {
                smallstep = Step;
            }

            // go through all rows
            data.LoadAllRows(new TableDataSetProperties(), (row) =>
            {
                row.ReadValue(dtcolindex);
                fmt.ReadFrom(row);
                string curdt = fmt.GetText();
                string key   = ExtractKey(curdt, Step);
                if (key != null)
                {
                    TimeLineGroup item;
                    if (!dct.ContainsKey(key))
                    {
                        item = new TimeLineGroup {
                            Key = key
                        };
                        dct[key] = item;
                    }
                    else
                    {
                        item = dct[key];
                    }

                    var inkey = ExtractKey(curdt, smallstep);
                    if (inkey != null)
                    {
                        double[] vals;

                        if (!item.Items.ContainsKey(inkey))
                        {
                            vals = new double[Items.Count + 1];
                            for (int i = 0; i < Items.Count; i++)
                            {
                                vals[i] = Double.NaN;
                            }
                            item.Items[inkey] = new ChartData.DataItem {
                                Label = inkey, Values = vals
                            };
                        }
                        else
                        {
                            vals = item.Items[inkey].Values;
                        }
                        vals[Items.Count] += 1; // count
                        for (int i = 0; i < Items.Count; i++)
                        {
                            if (valindexes[i] < 0)
                            {
                                if (Double.IsNaN(vals[i]))
                                {
                                    vals[i] = 0;
                                }
                                vals[i] += 1; // count
                            }
                            else
                            {
                                row.ReadValue(valindexes[i]);
                                fmt.ReadFrom(row);
                                double myval;
                                if (Double.TryParse(fmt.GetText(), NumberStyles.Number, CultureInfo.InvariantCulture, out myval))
                                {
                                    AdaptValue(ref vals[i], myval, Items[i].Expression);
                                }
                            }
                        }
                    }
                }
            });

            // summarize results
            var pairs = new List <KeyValuePair <string, TimeLineGroup> >(dct);

            pairs.SortByKey(p => p.Key);
            foreach (var pair in pairs)
            {
                var item = pair.Value;

                foreach (var itm in item.Items.Values)
                {
                    for (int i = 0; i < Items.Count; i++)
                    {
                        if (Double.IsNaN(itm.Values[i]))
                        {
                            itm.Values[i] = 0;
                        }
                        if (Items[i].Expression == TimeLineExpression.Avg && itm.Values[Items.Count] > 0)
                        {
                            itm.Values[i] /= itm.Values[Items.Count];
                        }
                    }
                }

                if (UseStructuredTime)
                {
                    double[] vals = new double[Items.Count];
                    for (int i = 0; i < Items.Count; i++)
                    {
                        switch (Items[i].TimeSelector)
                        {
                        case TimeGroupSelector.Sum:
                            vals[i] = 0;
                            foreach (var val in item.Items.Values)
                            {
                                vals[i] += val.Values[i];
                            }
                            break;

                        case TimeGroupSelector.Avg:
                            vals[i] = 0;
                            foreach (var val in item.Items.Values)
                            {
                                vals[i] += val.Values[i];
                            }
                            if (item.Items.Count > 0)
                            {
                                vals[i] /= item.Items.Count;
                            }
                            break;

                        case TimeGroupSelector.Min:
                            vals[i] = Double.NaN;
                            foreach (var val in item.Items.Values)
                            {
                                if (Double.IsNaN(vals[i]) || val.Values[i] < vals[i])
                                {
                                    vals[i] = val.Values[i];
                                }
                            }
                            if (Double.IsNaN(vals[i]))
                            {
                                vals[i] = 0;
                            }
                            break;

                        case TimeGroupSelector.Max:
                            vals[i] = Double.NaN;
                            foreach (var val in item.Items.Values)
                            {
                                if (Double.IsNaN(vals[i]) || val.Values[i] > vals[i])
                                {
                                    vals[i] = val.Values[i];
                                }
                            }
                            if (Double.IsNaN(vals[i]))
                            {
                                vals[i] = 0;
                            }
                            break;

                        case TimeGroupSelector.First:
                        {
                            string key = item.Items.Keys.Min();
                            if (key != null)
                            {
                                vals[i] = item.Items[key].Values[i];
                            }
                        }
                        break;

                        case TimeGroupSelector.Last:
                        {
                            string key = item.Items.Keys.Min();
                            if (key != null)
                            {
                                vals[i] = item.Items[key].Values[i];
                            }
                        }
                        break;

                        case TimeGroupSelector.Middle:
                        {
                            var keys = new List <string>(item.Items.Keys);
                            keys.Sort();
                            if (keys.Count > 0)
                            {
                                if (keys.Count % 2 == 1)
                                {
                                    vals[i] = item.Items[keys[keys.Count / 2]].Values[i];
                                }
                                else
                                {
                                    vals[i] = (
                                        item.Items[keys[keys.Count / 2 - 1]].Values[i]
                                        + item.Items[keys[keys.Count / 2]].Values[i]
                                        ) / 2;
                                }
                            }
                        }
                        break;
                        }
                    }
                    res.Items.Add(new ChartData.DataItem {
                        Label = pair.Key, Values = vals
                    });
                }
                else
                {
                    var itm = item.Items.First().Value;
                    res.Items.Add(itm);
                }
            }
            return(res);
        }