Esempio n. 1
0
        public void InspectorGUI_ViewModel()
        {
            EditorGUI.indentLevel++;
            EditorGUILayout.BeginVertical();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Name & ID");
            EditorGUILayout.TextField(string.Format("{0} ({1})", "FirstViewModel", VM.VMID.ToString().Substring(0, 8)));
            EditorGUILayout.EndHorizontal();


            EditorGUILayout.BeginVertical("box");
            FBElementEditor baseElementEditor = new FBElementEditor();

            baseElementEditor.VM = VM as FBViewModel;
            baseElementEditor.InspectorGUI_ViewModel();
            EditorGUILayout.EndVertical();

            string vmk;

            vmk = "LabelTextNum";
            int tempLabelTextNum = EditorGUILayout.DelayedIntField(vmk, VM.LabelTextNum);

            if (tempLabelTextNum != VM.LabelTextNum)
            {
                VM.LabelTextNum = tempLabelTextNum;
            }

            vmk = "Numbers";
            EditorGUILayout.BeginHorizontal();
            string NumbersJson     = JsonConvert.SerializeObject(VM.Numbers);
            string tempNumbersJson = EditorGUILayout.DelayedTextField(vmk, NumbersJson);

            if (tempNumbersJson != NumbersJson)
            {
                if (string.IsNullOrEmpty(tempNumbersJson))
                {
                    VM.Numbers = null;
                }
                else
                {
                    VM.Numbers = JsonConvert.DeserializeObject <ReactiveCollection <int> > (tempNumbersJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <int> (this, VM.Numbers)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "MyDictionary";
            EditorGUILayout.BeginHorizontal();
            string MyDictionary     = JsonConvert.SerializeObject(VM.MyDictionary);
            string tempMyDictionary = EditorGUILayout.DelayedTextField(vmk, MyDictionary);

            if (tempMyDictionary != MyDictionary)
            {
                if (string.IsNullOrEmpty(tempMyDictionary))
                {
                    VM.MyDictionary = null;
                }
                else
                {
                    VM.MyDictionary = JsonConvert.DeserializeObject <ReactiveDictionary <string, string> > (tempMyDictionary);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveDictionaryEditorPopupWindow <string, string> (this, VM.MyDictionary)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "MyNewProperty";
            EditorGUILayout.DelayedTextField(vmk, VM.MyNewProperty != null ? VM.MyNewProperty.ToString() : "null (object)");

            vmk = "DefaultCollection";
            EditorGUILayout.BeginHorizontal();
            string DefaultCollectionJson     = JsonConvert.SerializeObject(VM.DefaultCollection);
            string tempDefaultCollectionJson = EditorGUILayout.DelayedTextField(vmk, DefaultCollectionJson);

            if (tempDefaultCollectionJson != DefaultCollectionJson)
            {
                if (string.IsNullOrEmpty(tempDefaultCollectionJson))
                {
                    VM.DefaultCollection = null;
                }
                else
                {
                    VM.DefaultCollection = JsonConvert.DeserializeObject <ReactiveCollection <object> > (tempDefaultCollectionJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <object> (this, VM.DefaultCollection)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultProperty";
            EditorGUILayout.DelayedTextField(vmk, VM.DefaultProperty != null ? VM.DefaultProperty.ToString() : "null (object)");

            vmk = "AddNum";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Params"))
            {
                if (CommandParams.ContainsKey(vmk))
                {
                    CommandParams.Remove(vmk);
                }
                else
                {
                    CommandParams [vmk] = JsonConvert.SerializeObject(new AddNumCommand(), Formatting.Indented);
                }
            }
            if (GUILayout.Button("Invoke"))
            {
                if (CommandParams.ContainsKey(vmk) == false)
                {
                    VM.RC_AddNum.Execute(new AddNumCommand()
                    {
                        Sender = VM
                    });
                }
                else
                {
                    AddNumCommand command = JsonConvert.DeserializeObject <AddNumCommand> (CommandParams [vmk]);
                    command.Sender = VM;
                    VM.RC_AddNum.Execute(command);
                }
            }
            EditorGUILayout.EndHorizontal();
            if (CommandParams.ContainsKey(vmk))
            {
                CommandParams [vmk] = EditorGUILayout.TextArea(CommandParams [vmk]);
                EditorGUILayout.Space();
            }

            vmk = "CurrentVector2";
            VM.CurrentVector2 = EditorGUILayout.Vector2Field(vmk, VM.CurrentVector2);

            vmk = "CurrentVector3";
            VM.CurrentVector3 = EditorGUILayout.Vector3Field(vmk, VM.CurrentVector3);

            vmk = "CurrentVector4";
            VM.CurrentVector4 = EditorGUILayout.Vector4Field(vmk, VM.CurrentVector4);

            vmk = "CurrentQuaternion";
            Vector3 tempCurrentQuaternionVector3 = VM.CurrentQuaternion.eulerAngles;

            tempCurrentQuaternionVector3 = EditorGUILayout.Vector3Field(vmk, tempCurrentQuaternionVector3);
            VM.CurrentQuaternion         = Quaternion.Euler(tempCurrentQuaternionVector3);

            vmk            = "CurrentRect";
            VM.CurrentRect = EditorGUILayout.RectField(vmk, VM.CurrentRect);

            vmk = "CurrentBounds";
            VM.CurrentBounds = EditorGUILayout.BoundsField(vmk, VM.CurrentBounds);

            vmk             = "CurrentColor";
            VM.CurrentColor = EditorGUILayout.ColorField(vmk, VM.CurrentColor);

            vmk = "CurrentAC";
            EditorGUILayout.BeginHorizontal();
            if (VM.CurrentAC == null)
            {
                EditorGUILayout.PrefixLabel(vmk);
                if (GUILayout.Button("Create"))
                {
                    VM.CurrentAC = AnimationCurve.Linear(0f, 0f, 1f, 1f);
                }
            }
            else
            {
                VM.CurrentAC = EditorGUILayout.CurveField(vmk, VM.CurrentAC);
                if (GUILayout.Button("-", GUILayout.MaxWidth(20f)))
                {
                    VM.CurrentAC = null;
                }
            }
            EditorGUILayout.EndHorizontal();

            vmk = "CurrentDateTime";
            DateTime tempCurrentDateTime;

            if (DateTime.TryParse(EditorGUILayout.DelayedTextField(vmk, VM.CurrentDateTime.ToString()), out tempCurrentDateTime))
            {
                if (VM.CurrentDateTime != tempCurrentDateTime)
                {
                    VM.CurrentDateTime = tempCurrentDateTime;
                }
            }

            vmk = "CurrentTimeSpan";
            TimeSpan tempCurrentTimeSpan;

            if (TimeSpan.TryParse(EditorGUILayout.DelayedTextField(vmk, VM.CurrentTimeSpan.ToString()), out tempCurrentTimeSpan))
            {
                if (VM.CurrentTimeSpan != tempCurrentTimeSpan)
                {
                    VM.CurrentTimeSpan = tempCurrentTimeSpan;
                }
            }

            vmk = "CurrentJObject";
            string tempCurrentJObjectString  = JsonConvert.SerializeObject(VM.CurrentJObject);
            string temp2CurrentJObjectString = EditorGUILayout.DelayedTextField(vmk, tempCurrentJObjectString);

            if (tempCurrentJObjectString != temp2CurrentJObjectString)
            {
                try {
                    VM.CurrentJObject = JsonConvert.DeserializeObject <JObject> (temp2CurrentJObjectString);
                } catch {
                    VM.CurrentJObject = JsonConvert.DeserializeObject <JObject> (tempCurrentJObjectString);
                }
            }

            vmk = "CurrentJArray";
            string tempCurrentJArrayString  = JsonConvert.SerializeObject(VM.CurrentJArray);
            string temp2CurrentJArrayString = EditorGUILayout.DelayedTextField(vmk, tempCurrentJArrayString);

            if (tempCurrentJArrayString != temp2CurrentJArrayString)
            {
                try {
                    VM.CurrentJArray = JsonConvert.DeserializeObject <JArray> (temp2CurrentJArrayString);
                } catch {
                    VM.CurrentJArray = JsonConvert.DeserializeObject <JArray> (tempCurrentJArrayString);
                }
            }

            vmk = "V3List";
            EditorGUILayout.BeginHorizontal();
            string V3ListJson     = JsonConvert.SerializeObject(VM.V3List);
            string tempV3ListJson = EditorGUILayout.DelayedTextField(vmk, V3ListJson);

            if (tempV3ListJson != V3ListJson)
            {
                if (string.IsNullOrEmpty(tempV3ListJson))
                {
                    VM.V3List = null;
                }
                else
                {
                    VM.V3List = JsonConvert.DeserializeObject <ReactiveCollection <UnityEngine.Vector3> > (tempV3ListJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <UnityEngine.Vector3> (this, VM.V3List)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "RectList";
            EditorGUILayout.BeginHorizontal();
            string RectListJson     = JsonConvert.SerializeObject(VM.RectList);
            string tempRectListJson = EditorGUILayout.DelayedTextField(vmk, RectListJson);

            if (tempRectListJson != RectListJson)
            {
                if (string.IsNullOrEmpty(tempRectListJson))
                {
                    VM.RectList = null;
                }
                else
                {
                    VM.RectList = JsonConvert.DeserializeObject <ReactiveCollection <UnityEngine.Rect> > (tempRectListJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <UnityEngine.Rect> (this, VM.RectList)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk     = "MyEA";
            VM.MyEA = (EA)EditorGUILayout.EnumPopup(vmk, VM.MyEA);

            vmk = "SCA_a";
            EditorGUILayout.BeginHorizontal();
            if (VM.SCA_a == null)
            {
                EditorGUILayout.PrefixLabel(vmk);
                if (GUILayout.Button("Create"))
                {
                    VM.SCA_a = new SCA();
                }
            }
            else
            {
                string SCA_a     = JsonConvert.SerializeObject(VM.SCA_a);
                string tempSCA_a = EditorGUILayout.DelayedTextField(vmk, SCA_a);
                if (tempSCA_a != SCA_a)
                {
                    if (string.IsNullOrEmpty(tempSCA_a))
                    {
                        VM.SCA_a = null;
                    }
                    else
                    {
                        VM.SCA_a = JsonConvert.DeserializeObject <SCA> (SCA_a);
                    }
                }
                if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
                {
                    PopupWindow.Show(
                        new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                        new SimpleClassReactivePropertyEditorPopupWindow <SCA> (this, VM.RP_SCA_a)
                        );
                }
            }
            EditorGUILayout.EndHorizontal();

            vmk = "MyBooleanValue";
            VM.MyBooleanValue = EditorGUILayout.Toggle(vmk, VM.MyBooleanValue);

            EditorGUILayout.EndVertical();
            EditorGUI.indentLevel--;

            if (EditorApplication.isPlaying == false)
            {
                if (GUI.changed)
                {
                    VMCopyToJson();
                }
            }
        }
Esempio n. 2
0
        public void InspectorGUI_ViewModel()
        {
            EditorGUI.indentLevel++;
            EditorGUILayout.BeginVertical();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Name & ID");
            EditorGUILayout.TextField(string.Format("{0} ({1})", "SecondViewModel", VM.VMID.ToString().Substring(0, 8)));
            EditorGUILayout.EndHorizontal();



            string vmk;

            vmk = "IntValue";
            int tempIntValue = EditorGUILayout.DelayedIntField(vmk, VM.IntValue);

            if (tempIntValue != VM.IntValue)
            {
                VM.IntValue = tempIntValue;
            }

            vmk = "LongValue";
            int tempLongValue = EditorGUILayout.DelayedIntField(vmk, (int)VM.LongValue);

            if ((long)tempLongValue != VM.LongValue)
            {
                VM.LongValue = (long)tempLongValue;
            }

            vmk = "FloatValue";
            float tempFloatValue = EditorGUILayout.DelayedFloatField(vmk, VM.FloatValue);

            if (tempFloatValue != VM.FloatValue)
            {
                VM.FloatValue = tempFloatValue;
            }

            vmk = "DoubleValue";
            double tempDoubleValue = EditorGUILayout.DelayedDoubleField(vmk, VM.DoubleValue);

            if (tempDoubleValue != VM.DoubleValue)
            {
                VM.DoubleValue = tempDoubleValue;
            }

            vmk = "IntList";
            EditorGUILayout.BeginHorizontal();
            string IntListJson     = JsonConvert.SerializeObject(VM.IntList);
            string tempIntListJson = EditorGUILayout.DelayedTextField(vmk, IntListJson);

            if (tempIntListJson != IntListJson)
            {
                if (string.IsNullOrEmpty(tempIntListJson))
                {
                    VM.IntList = null;
                }
                else
                {
                    VM.IntList = JsonConvert.DeserializeObject <ReactiveCollection <int> > (tempIntListJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <int> (this, VM.IntList)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "LongList";
            EditorGUILayout.BeginHorizontal();
            string LongListJson     = JsonConvert.SerializeObject(VM.LongList);
            string tempLongListJson = EditorGUILayout.DelayedTextField(vmk, LongListJson);

            if (tempLongListJson != LongListJson)
            {
                if (string.IsNullOrEmpty(tempLongListJson))
                {
                    VM.LongList = null;
                }
                else
                {
                    VM.LongList = JsonConvert.DeserializeObject <ReactiveCollection <long> > (tempLongListJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <long> (this, VM.LongList)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "FloatList";
            EditorGUILayout.BeginHorizontal();
            string FloatListJson     = JsonConvert.SerializeObject(VM.FloatList);
            string tempFloatListJson = EditorGUILayout.DelayedTextField(vmk, FloatListJson);

            if (tempFloatListJson != FloatListJson)
            {
                if (string.IsNullOrEmpty(tempFloatListJson))
                {
                    VM.FloatList = null;
                }
                else
                {
                    VM.FloatList = JsonConvert.DeserializeObject <ReactiveCollection <float> > (tempFloatListJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <float> (this, VM.FloatList)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DoubleList";
            EditorGUILayout.BeginHorizontal();
            string DoubleListJson     = JsonConvert.SerializeObject(VM.DoubleList);
            string tempDoubleListJson = EditorGUILayout.DelayedTextField(vmk, DoubleListJson);

            if (tempDoubleListJson != DoubleListJson)
            {
                if (string.IsNullOrEmpty(tempDoubleListJson))
                {
                    VM.DoubleList = null;
                }
                else
                {
                    VM.DoubleList = JsonConvert.DeserializeObject <ReactiveCollection <double> > (tempDoubleListJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <double> (this, VM.DoubleList)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "StringList";
            EditorGUILayout.BeginHorizontal();
            string StringListJson     = JsonConvert.SerializeObject(VM.StringList);
            string tempStringListJson = EditorGUILayout.DelayedTextField(vmk, StringListJson);

            if (tempStringListJson != StringListJson)
            {
                if (string.IsNullOrEmpty(tempStringListJson))
                {
                    VM.StringList = null;
                }
                else
                {
                    VM.StringList = JsonConvert.DeserializeObject <ReactiveCollection <string> > (tempStringListJson);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <string> (this, VM.StringList)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "IntDictionary";
            EditorGUILayout.BeginHorizontal();
            string IntDictionary     = JsonConvert.SerializeObject(VM.IntDictionary);
            string tempIntDictionary = EditorGUILayout.DelayedTextField(vmk, IntDictionary);

            if (tempIntDictionary != IntDictionary)
            {
                if (string.IsNullOrEmpty(tempIntDictionary))
                {
                    VM.IntDictionary = null;
                }
                else
                {
                    VM.IntDictionary = JsonConvert.DeserializeObject <ReactiveDictionary <string, int> > (tempIntDictionary);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveDictionaryEditorPopupWindow <string, int> (this, VM.IntDictionary)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "StringDictionary";
            EditorGUILayout.BeginHorizontal();
            string StringDictionary     = JsonConvert.SerializeObject(VM.StringDictionary);
            string tempStringDictionary = EditorGUILayout.DelayedTextField(vmk, StringDictionary);

            if (tempStringDictionary != StringDictionary)
            {
                if (string.IsNullOrEmpty(tempStringDictionary))
                {
                    VM.StringDictionary = null;
                }
                else
                {
                    VM.StringDictionary = JsonConvert.DeserializeObject <ReactiveDictionary <int, string> > (tempStringDictionary);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveDictionaryEditorPopupWindow <int, string> (this, VM.StringDictionary)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "StringCommand";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Params"))
            {
                if (CommandParams.ContainsKey(vmk))
                {
                    CommandParams.Remove(vmk);
                }
                else
                {
                    CommandParams [vmk] = JsonConvert.SerializeObject(new StringCommandCommand(), Formatting.Indented);
                }
            }
            if (GUILayout.Button("Invoke"))
            {
                if (CommandParams.ContainsKey(vmk) == false)
                {
                    VM.RC_StringCommand.Execute(new StringCommandCommand()
                    {
                        Sender = VM
                    });
                }
                else
                {
                    StringCommandCommand command = JsonConvert.DeserializeObject <StringCommandCommand> (CommandParams [vmk]);
                    command.Sender = VM;
                    VM.RC_StringCommand.Execute(command);
                }
            }
            EditorGUILayout.EndHorizontal();
            if (CommandParams.ContainsKey(vmk))
            {
                CommandParams [vmk] = EditorGUILayout.TextArea(CommandParams [vmk]);
                EditorGUILayout.Space();
            }

            vmk = "IntCommand";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Params"))
            {
                if (CommandParams.ContainsKey(vmk))
                {
                    CommandParams.Remove(vmk);
                }
                else
                {
                    CommandParams [vmk] = JsonConvert.SerializeObject(new IntCommandCommand(), Formatting.Indented);
                }
            }
            if (GUILayout.Button("Invoke"))
            {
                if (CommandParams.ContainsKey(vmk) == false)
                {
                    VM.RC_IntCommand.Execute(new IntCommandCommand()
                    {
                        Sender = VM
                    });
                }
                else
                {
                    IntCommandCommand command = JsonConvert.DeserializeObject <IntCommandCommand> (CommandParams [vmk]);
                    command.Sender = VM;
                    VM.RC_IntCommand.Execute(command);
                }
            }
            EditorGUILayout.EndHorizontal();
            if (CommandParams.ContainsKey(vmk))
            {
                CommandParams [vmk] = EditorGUILayout.TextArea(CommandParams [vmk]);
                EditorGUILayout.Space();
            }

            vmk = "SimpleCommand";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_SimpleCommand.Execute();
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.EndVertical();
            EditorGUI.indentLevel--;

            if (EditorApplication.isPlaying == false)
            {
                if (GUI.changed)
                {
                    VMCopyToJson();
                }
            }
        }
Esempio n. 3
0
        public void InspectorGUI_ViewModel()
        {
            EditorGUI.indentLevel++;
            EditorGUILayout.BeginVertical();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Name & ID");
            EditorGUILayout.TextField(string.Format("{0} ({1})", "PTestViewModel", VM.VMID.ToString().Substring(0, 8)));
            EditorGUILayout.EndHorizontal();



            string vmk;

            vmk = "DefaultProperty1";
            string tempDefaultProperty1 = EditorGUILayout.DelayedTextField(vmk, VM.DefaultProperty1);

            if (tempDefaultProperty1 != VM.DefaultProperty1)
            {
                VM.DefaultProperty1 = tempDefaultProperty1;
            }

            vmk = "DefaultProperty2";
            string tempDefaultProperty2 = EditorGUILayout.DelayedTextField(vmk, VM.DefaultProperty2);

            if (tempDefaultProperty2 != VM.DefaultProperty2)
            {
                VM.DefaultProperty2 = tempDefaultProperty2;
            }

            vmk = "DefaultProperty3";
            int tempDefaultProperty3 = EditorGUILayout.DelayedIntField(vmk, VM.DefaultProperty3);

            if (tempDefaultProperty3 != VM.DefaultProperty3)
            {
                VM.DefaultProperty3 = tempDefaultProperty3;
            }

            vmk = "DefaultProperty4";
            float tempDefaultProperty4 = EditorGUILayout.DelayedFloatField(vmk, VM.DefaultProperty4);

            if (tempDefaultProperty4 != VM.DefaultProperty4)
            {
                VM.DefaultProperty4 = tempDefaultProperty4;
            }

            vmk = "DefaultCollection1";
            EditorGUILayout.BeginHorizontal();
            string DefaultCollection1Json     = JsonConvert.SerializeObject(VM.DefaultCollection1);
            string tempDefaultCollection1Json = EditorGUILayout.DelayedTextField(vmk, DefaultCollection1Json);

            if (tempDefaultCollection1Json != DefaultCollection1Json)
            {
                if (string.IsNullOrEmpty(tempDefaultCollection1Json))
                {
                    VM.DefaultCollection1 = null;
                }
                else
                {
                    VM.DefaultCollection1 = JsonConvert.DeserializeObject <ReactiveCollection <string> > (tempDefaultCollection1Json);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <string> (this, VM.DefaultCollection1)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCollection2";
            EditorGUILayout.BeginHorizontal();
            string DefaultCollection2Json     = JsonConvert.SerializeObject(VM.DefaultCollection2);
            string tempDefaultCollection2Json = EditorGUILayout.DelayedTextField(vmk, DefaultCollection2Json);

            if (tempDefaultCollection2Json != DefaultCollection2Json)
            {
                if (string.IsNullOrEmpty(tempDefaultCollection2Json))
                {
                    VM.DefaultCollection2 = null;
                }
                else
                {
                    VM.DefaultCollection2 = JsonConvert.DeserializeObject <ReactiveCollection <int> > (tempDefaultCollection2Json);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveCollectionEditorPopupWindow <int> (this, VM.DefaultCollection2)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultDictionary1";
            EditorGUILayout.BeginHorizontal();
            string DefaultDictionary1     = JsonConvert.SerializeObject(VM.DefaultDictionary1);
            string tempDefaultDictionary1 = EditorGUILayout.DelayedTextField(vmk, DefaultDictionary1);

            if (tempDefaultDictionary1 != DefaultDictionary1)
            {
                if (string.IsNullOrEmpty(tempDefaultDictionary1))
                {
                    VM.DefaultDictionary1 = null;
                }
                else
                {
                    VM.DefaultDictionary1 = JsonConvert.DeserializeObject <ReactiveDictionary <string, string> > (tempDefaultDictionary1);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveDictionaryEditorPopupWindow <string, string> (this, VM.DefaultDictionary1)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultDictionary2";
            EditorGUILayout.BeginHorizontal();
            string DefaultDictionary2     = JsonConvert.SerializeObject(VM.DefaultDictionary2);
            string tempDefaultDictionary2 = EditorGUILayout.DelayedTextField(vmk, DefaultDictionary2);

            if (tempDefaultDictionary2 != DefaultDictionary2)
            {
                if (string.IsNullOrEmpty(tempDefaultDictionary2))
                {
                    VM.DefaultDictionary2 = null;
                }
                else
                {
                    VM.DefaultDictionary2 = JsonConvert.DeserializeObject <ReactiveDictionary <int, string> > (tempDefaultDictionary2);
                }
            }
            if (GUILayout.Button("...", GUILayout.MaxWidth(20)))
            {
                PopupWindow.Show(
                    new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 0f, 0f),
                    new ReactiveDictionaryEditorPopupWindow <int, string> (this, VM.DefaultDictionary2)
                    );
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand1";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Params"))
            {
                if (CommandParams.ContainsKey(vmk))
                {
                    CommandParams.Remove(vmk);
                }
                else
                {
                    CommandParams [vmk] = JsonConvert.SerializeObject(new DefaultCommand1Command(), Formatting.Indented);
                }
            }
            if (GUILayout.Button("Invoke"))
            {
                if (CommandParams.ContainsKey(vmk) == false)
                {
                    VM.RC_DefaultCommand1.Execute(new DefaultCommand1Command()
                    {
                        Sender = VM
                    });
                }
                else
                {
                    DefaultCommand1Command command = JsonConvert.DeserializeObject <DefaultCommand1Command> (CommandParams [vmk]);
                    command.Sender = VM;
                    VM.RC_DefaultCommand1.Execute(command);
                }
            }
            EditorGUILayout.EndHorizontal();
            if (CommandParams.ContainsKey(vmk))
            {
                CommandParams [vmk] = EditorGUILayout.TextArea(CommandParams [vmk]);
                EditorGUILayout.Space();
            }

            vmk = "DefaultCommand2";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand2.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand3";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand3.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand4";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand4.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand5";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand5.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand6";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand6.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand7";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand7.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand8";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Params"))
            {
                if (CommandParams.ContainsKey(vmk))
                {
                    CommandParams.Remove(vmk);
                }
                else
                {
                    CommandParams [vmk] = JsonConvert.SerializeObject(new DefaultCommand8Command(), Formatting.Indented);
                }
            }
            if (GUILayout.Button("Invoke"))
            {
                if (CommandParams.ContainsKey(vmk) == false)
                {
                    VM.RC_DefaultCommand8.Execute(new DefaultCommand8Command()
                    {
                        Sender = VM
                    });
                }
                else
                {
                    DefaultCommand8Command command = JsonConvert.DeserializeObject <DefaultCommand8Command> (CommandParams [vmk]);
                    command.Sender = VM;
                    VM.RC_DefaultCommand8.Execute(command);
                }
            }
            EditorGUILayout.EndHorizontal();
            if (CommandParams.ContainsKey(vmk))
            {
                CommandParams [vmk] = EditorGUILayout.TextArea(CommandParams [vmk]);
                EditorGUILayout.Space();
            }

            vmk = "DefaultCommand9";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand9.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand10";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand10.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand11";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand11.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand12";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand12.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand13";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand13.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand14";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand14.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand15";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand15.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand16";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand16.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand17";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand17.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand18";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand18.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand19";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand19.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "DefaultCommand20";
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(vmk);
            if (GUILayout.Button("Invoke"))
            {
                VM.RC_DefaultCommand20.Execute();
            }
            EditorGUILayout.EndHorizontal();

            vmk = "CurrentFB";
            ViewBase CurrentFBView = (target as IPTestView).CurrentFBView as ViewBase;

            if (EditorApplication.isPlaying && VM.CurrentFB == null)
            {
                CurrentFBView = null;
            }
            ViewBase tempCurrentFBView = (ViewBase)EditorGUILayout.ObjectField(vmk, CurrentFBView, typeof(ViewBase), true);

            if (tempCurrentFBView == null)
            {
                (target as IPTestView).CurrentFBView = null;
                VM.CurrentFB = null;
            }
            else if (CurrentFBView != tempCurrentFBView)
            {
                var view = tempCurrentFBView as WS1.IFBView;
                if (view != null)
                {
                    (target as IPTestView).CurrentFBView = tempCurrentFBView as WS1.IFBView;
                    VM.CurrentFB = (WS1.FBViewModel)tempCurrentFBView.GetViewModel();
                }
                else
                {
                    Debug.Log("类型不匹配, 需要一个: FB");
                }
            }

            EditorGUILayout.EndVertical();
            EditorGUI.indentLevel--;

            if (EditorApplication.isPlaying == false)
            {
                if (GUI.changed)
                {
                    VMCopyToJson();
                }
            }
        }