override public void SaveConfig()
 {
     try
     {
         string      filename = GetStateConfigFileName(DlgMode);
         OLVStateAdv state    = new OLVStateAdv();
         SaveUserSettings(state.UserSettings);
         if (listView != null)
         {
             OLVHelper.SaveStateAdvanced(listView, state);
         }
         state.HotItemStyle = HotItemStyle;
         //use save with defaults (sort column = 0);
         string newConfigStr = JsonSerializeHelper.SaveToStringWithNullAndDefaultValues(state);
         if (newConfigStr.Equals(configFileStr) == false)
         {
             File.WriteAllText(filename, newConfigStr, Encoding.UTF8);
             configFileStr = newConfigStr;
             //Log.ProcessDebug("@@@@@ Saved config for OLV list  " + SourceObjectType);
         }
     }
     catch (Exception ex)
     {
         Log.LogError("Can not write config for " + GetType().ToString(), ex);
     }
 }
 private void LoadConfig()
 {
     try
     {
         string filename = null;
         if (DlgMode)
         {
             filename = GetStateConfigFileName(true);
             if (!File.Exists(filename))
             {
                 filename = GetStateConfigFileName(false);
             }
         }
         else
         {
             filename = GetStateConfigFileName(false);
         }
         if (File.Exists(filename))
         {
             configFileStr  = File.ReadAllText(filename, Encoding.UTF8);
             savedTreeState = JsonSerializeHelper.LoadFromString <TreeListState>(configFileStr);
         }
         else
         {
             savedTreeState = new TreeListState();
         }
         LoadUserSettings(savedTreeState.UserSettings);
     }
     catch (Exception ex)
     {
         Log.LogError("Can not read config for " + GetType().ToString(), ex);
     }
 }
 private void LoadConfig()
 {
     try
     {
         string filename = null;
         if (DlgMode)
         {
             filename = GetStateConfigFileName(true);
             if (!File.Exists(filename))
             {
                 filename = GetStateConfigFileName(false);
             }
         }
         else
         {
             filename = GetStateConfigFileName(false);
         }
         if (File.Exists(filename))
         {
             configFileStr = File.ReadAllText(filename, Encoding.UTF8);
             OLVStateAdv state = JsonSerializeHelper.LoadFromString <OLVStateAdv>(configFileStr);
             if (listView != null)
             {
                 OLVHelper.RestoreStateAdvanced(listView, state);
             }
             HotItemStyle = state.HotItemStyle;
             OLVHelper.SetHotItemStyle(listView, HotItemStyle);
             LoadUserSettings(state.UserSettings);
         }
     }
     catch (Exception ex)
     {
         Log.LogError("Can not read config for " + GetType().ToString(), ex);
     }
 }
示例#4
0
        private SData LoadEntityFromDisk(Type t)
        {
            JEntity entityAttr = AttrHelper.GetClassAttribute <JEntity>(t);

            if (entityAttr.DsType != typeof(JsonDs))
            {
                throw new InvalidOperationException("Not a json file stored entity");
            }

            //long tstart = DateTime.Now.Ticks;
            SData sdata = new SData()
            {
                DataType = t
            };
            Type   lt       = typeof(List <>);
            Type   listType = lt.MakeGenericType(t);
            object list     = null;

            string   filename = GetDataFilePathForType(t);
            FileInfo fileInfo = new FileInfo(filename);

            if (fileInfo.Exists)
            {
                list = JsonSerializeHelper.LoadForType(filename, listType);
            }
            else
            {
                list = Activator.CreateInstance(listType);
            }
            foreach (var x in (IList)list)
            {
                INotifyPropertyChanged notifier = x as INotifyPropertyChanged;
                if (notifier != null)
                {
                    notifier.PropertyChanged += Notifier_PropertyChanged;
                }
            }
            PropertyInfo pkProp = AttrHelper.GetProperty <JPrimaryKey>(t);

            if (pkProp != null)
            {
                foreach (var o in (IList)list)
                {
                    object pk = pkProp.GetValue(o);
                    try
                    {
                        sdata.PkCache.Add(pk, o);
                    }
                    catch (ArgumentException ex)
                    {
                        Log.ProcessDebug("Dublicate pk entity: " + t + " pk value:  " + pk + " Error text: " + ex);
                    }
                }
            }
            sdata.DataList = list;
            sdatas.Add(sdata);

            return(sdata);
        }
示例#5
0
        protected JoinEntityData FindAllJoinData(Type t1, Type t2, string joinTableName)
        {
            JoinEntityData joinData = GetJoinData(t1, t2, joinTableName);

            if (joinData == null)
            {
                long tstart = DateTime.Now.Ticks;

                //sort before add
                TypeComparer typeComparer = new TypeComparer();
                Type[]       ts           = new Type[] { t1, t2 };
                Array.Sort(ts, typeComparer);

                joinData = new JoinEntityData()
                {
                    DataType1 = ts[0], DataType2 = ts[1], JoinTableName = joinTableName
                };

                var listType = typeof(List <JoinEntityDataItem>);
                List <JoinEntityDataItem> list = null;
                string filename = Path.Combine(Path.Combine(FrwConfig.Instance.ProfileDir, DATA_STORAGE), joinData.DataType1.FullName + "_" + joinData.DataType2.FullName +
                                               (joinTableName != null ? ("_" + joinTableName) : "") + ".json");
                FileInfo fileInfo = new FileInfo(filename);
                if (fileInfo.Exists)
                {
                    list = JsonSerializeHelper.LoadForType(filename, listType);
                }
                else
                {
                    list = (List <JoinEntityDataItem>)Activator.CreateInstance(listType);
                }
                joinData.DataList = list;

                long tstartConvert = DateTime.Now.Ticks;

                PropertyInfo pkProp1 = AttrHelper.GetProperty <JPrimaryKey>(joinData.DataType1);

                if (pkProp1.PropertyType != typeof(string))
                {
                    foreach (var l in joinData.DataList)
                    {
                        l.Pk1 = JsonSerializeHelper.DeserializeString(l.Pk1.ToString(), pkProp1.PropertyType);
                    }
                }
                PropertyInfo pkProp2 = AttrHelper.GetProperty <JPrimaryKey>(joinData.DataType1);
                if (pkProp2.PropertyType != typeof(string))
                {
                    foreach (var l in joinData.DataList)
                    {
                        l.Pk2 = JsonSerializeHelper.DeserializeString(l.Pk2.ToString(), pkProp2.PropertyType);
                    }
                }
                joinDatas.Add(joinData);
                long tend = DateTime.Now.Ticks;
                //Log.ProcessDebug("======= Loaded join data : " + sdata.DataType1 + " " + sdata.DataType2  + " Count: " + ((IList)list).Count + " Time: " + (tend - tstart) / 10000 + " mils" + " include time converting: " + (tend - tstartConvert) / 10000 + " mils");
            }
            return(joinData);
        }
示例#6
0
        private void SaveJoinEntityDataLocal(JoinEntityData s)
        {
            string        dirPath = Path.Combine(FrwConfig.Instance.ProfileDir, DATA_STORAGE);
            DirectoryInfo dir     = new DirectoryInfo(dirPath);

            if (dir.Exists == false)
            {
                Directory.CreateDirectory(dir.FullName);
            }
            string filename = Path.Combine(dirPath, s.DataType1.FullName + "_" + s.DataType2.FullName + ".json");
            object list     = s.DataList;

            JsonSerializeHelper.SaveToFile(list, filename);
            s.Modified = false;
        }
 override public void SaveConfig()
 {
     try
     {
         string filename = GetStateConfigFileName(DlgMode);
         SaveUserSettings(savedTreeState.UserSettings);
         savedTreeState.NodeStates = treeControl.Nodes.GetExpansionState();
         string newConfigStr = JsonSerializeHelper.SaveToString(savedTreeState);
         if (newConfigStr.Equals(configFileStr) == false)
         {
             File.WriteAllText(filename, newConfigStr, Encoding.UTF8);
             configFileStr = newConfigStr;
         }
     }
     catch (Exception ex)
     {
         Log.LogError("Can not write config for " + GetType().ToString(), ex);
     }
 }
示例#8
0
        private void SaveEntityDataLocal(IList list, Type type, string customDirPath)
        {
            string filename = GetDataFilePathForType(type, customDirPath);
            var    lt       = typeof(List <>);
            var    listType = lt.MakeGenericType(type);
            IList  alist    = (IList)Activator.CreateInstance(listType);

            foreach (object v in list)
            {
                object av = Dm.CloneObject(v, CloneObjectType.ForSave);
                alist.Add(av);
            }
            //
            if (alist.Count > 5000)//todo better check size
            {
                JsonSerializeHelper.SaveToFileLageData(alist, filename);
            }
            else
            {
                JsonSerializeHelper.SaveToFile(alist, filename);
            }
        }
示例#9
0
        protected void SaveConfig()
        {
            //todo - do not save if not modified
            CloseAllHiddenContents();
            FrwConfig.Instance.SetPropertyValue(FrwSimpleWinCRUDConfig.APPLICATION_FONT, Font);
            string configFile = GetContentConfigFileName();

            MemoryStream xmlStream = new MemoryStream();

            dockPanel.SaveAsXml(xmlStream, Encoding.UTF8);
            string newConfigLayoutStr = Encoding.UTF8.GetString(xmlStream.ToArray());

            if (newConfigLayoutStr.Equals(configLayoutStr) == false)
            {
                File.WriteAllText(configFile, newConfigLayoutStr);
                configLayoutStr = newConfigLayoutStr;
                //Log.ProcessDebug("@@@@@ Saved config for main window " + DocPanelIndex);
            }

            ////////////////////////////////////////////////
            try
            {
                string        filename = GetStateConfigFileName();
                DocPanelState state    = new DocPanelState();
                SaveUserSettings(state.UserSettings);

                string newConfigStr = JsonSerializeHelper.SaveToString(state);
                if (newConfigStr.Equals(configFileStr) == false)
                {
                    File.WriteAllText(filename, newConfigStr, Encoding.UTF8);
                    configFileStr = newConfigStr;
                    //Log.ProcessDebug("@@@@@ Saved json config for main window " + DocPanelIndex);
                }
            }
            catch (Exception ex)
            {
                Log.LogError("Can not write config for " + GetType().ToString(), ex);
            }
        }
示例#10
0
        protected void LoadConfig()
        {
            /////////////////////////////////////////////////
            try
            {
                string filename = GetStateConfigFileName();
                if (File.Exists(filename))
                {
                    configFileStr = File.ReadAllText(filename, Encoding.UTF8);
                    DocPanelState state = JsonSerializeHelper.LoadFromString <DocPanelState>(configFileStr);
                    LoadUserSettings(state.UserSettings);
                }
            }
            catch (Exception ex)
            {
                Log.LogError("Can not read config for " + GetType().ToString(), ex);
            }


            string configFile = GetContentConfigFileName();

            if (File.Exists(configFile))
            {
                configLayoutStr = File.ReadAllText(configFile);
                Stream xmlStream = new MemoryStream(Encoding.UTF8.GetBytes(configLayoutStr));
                dockPanel.LoadFromXml(xmlStream, m_deserializeDockContent);
                //xmlStream.Close();
            }
            try
            {
                // Font installation for all forms
                WinFormsUtils.SetNewControlFont(this, (Font)FrwConfig.Instance.GetPropertyValue(FrwSimpleWinCRUDConfig.APPLICATION_FONT));//if this.AutoScaleMode = Font - Setting the font will change the size of the window
            }
            catch (Exception ex)
            {
                Log.LogError("Can not set font ", ex);
            }
        }
示例#11
0
        /// <summary>
        /// Saves all user settings
        /// </summary>
        public void SaveConfig()
        {
            foreach (var s in settings.Values)
            {
                if (s.Value != null && s.ValueType == null)
                {
                    s.ValueType = s.Value.GetType();
                }
                if (s.Value != null)
                {
                    if (s.ValueType != typeof(string))
                    {
                        JEntity entityAttr = AttrHelper.GetClassAttribute <JEntity>(s.ValueType);
                        if (entityAttr != null)
                        {
                            if (s.AllowMultiValues)
                            {
                                IList list   = (IList)s.Value;
                                IList values = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(s.ValueType));
                                foreach (var realObject in list)
                                {
                                    values.Add(AttrHelper.ReplaceObjectByPkOnlyObject(realObject));
                                }
                                s.Value = values;
                            }
                            else
                            {
                                s.Value = AttrHelper.ReplaceObjectByPkOnlyObject(s.Value);
                            }
                        }
                        else
                        {
                            TypeConverter converter = TypeDescriptor.GetConverter(s.ValueType);
                            if (converter != null)
                            {
                                s.Value = converter.ConvertToString(s.Value);
                            }
                        }
                    }
                }
            }

            string        filename = Path.Combine(ProfileConfigDir, settingsFileName);
            FileInfo      fileInfo = new FileInfo(filename);
            DirectoryInfo dir      = fileInfo.Directory;

            if (dir.Exists == false)
            {
                Directory.CreateDirectory(dir.FullName);
            }
            List <JSetting> settingsList = new List <JSetting>();

            foreach (var s in settings.Values)
            {
                if (!s.IsAttachedToComputer)
                {
                    settingsList.Add(s);
                }
            }
            JsonSerializeHelper.SaveToFile(settingsList, filename);
            //stage 2
            filename = Path.Combine(ComputerUserDir, settingsFileName);
            fileInfo = new FileInfo(filename);
            dir      = fileInfo.Directory;
            if (dir.Exists == false)
            {
                Directory.CreateDirectory(dir.FullName);
            }
            settingsList = new List <JSetting>();
            foreach (var s in settings.Values)
            {
                if (s.IsAttachedToComputer)
                {
                    settingsList.Add(s);
                }
            }
            File.WriteAllText(filename, JsonSerializeHelper.SaveToString(settingsList), Encoding.UTF8);//short
        }
示例#12
0
        /// <summary>
        /// Loads all user settings.
        /// </summary>
        public void LoadConfig()
        {
            string        filename = Path.Combine(ProfileConfigDir, settingsFileName);
            FileInfo      fileInfo = new FileInfo(filename);
            DirectoryInfo dir      = fileInfo.Directory;

            if (dir.Exists == false)
            {
                Directory.CreateDirectory(dir.FullName);
            }
            if (fileInfo.Exists)
            {
                List <JSetting> settingsList = null;
                settingsList = JsonSerializeHelper.LoadFromFile <List <JSetting> >(filename);
                foreach (var s in settingsList)
                {
                    s.IsAttachedToComputer = false;
                    settings.Add(s.Name, s);
                }
            }

            //Properties.Settings.Default path
            //https://msdn.microsoft.com/en-us/library/system.environment.specialfolder.aspx

            //stage 2
            if (ComputerUserDir != null)
            {
                filename = Path.Combine(ComputerUserDir, settingsFileName);
                fileInfo = new FileInfo(filename);
                dir      = fileInfo.Directory;
                if (dir.Exists == false)
                {
                    Directory.CreateDirectory(dir.FullName);
                }
                if (fileInfo.Exists)
                {
                    List <JSetting> settingsList = null;
                    settingsList = JsonSerializeHelper.LoadFromFile <List <JSetting> >(filename);
                    foreach (var s in settingsList)
                    {
                        s.IsAttachedToComputer = true;
                        settings[s.Name]       = s;
                    }
                }
            }

            foreach (JSetting setting in settings.Values)
            {
                if (setting.Value != null)
                {
                    Type type = setting.ValueType;
                    if (type != null)
                    {
                        if (type != typeof(string))
                        {
                            JEntity entityAttr = AttrHelper.GetClassAttribute <JEntity>(type);
                            if (entityAttr != null)
                            {
                                if (setting.AllowMultiValues)
                                {
                                    IList list   = (IList)setting.Value;
                                    IList values = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(type));
                                    foreach (var pkOnlyObject in list)
                                    {
                                        string str        = JsonSerializeHelper.SaveToString(pkOnlyObject);
                                        object realObject = JsonSerializeHelper.LoadFromString(str, type);
                                        values.Add(realObject);
                                    }
                                    setting.Value = values;
                                }
                                else
                                {
                                    setting.Value = JsonSerializeHelper.LoadFromString(JsonSerializeHelper.SaveToString(setting.Value), type);
                                }
                            }
                            else
                            {
                                TypeConverter converter = TypeDescriptor.GetConverter(type);
                                if (converter != null)//for system types (Font, etc.)
                                {
                                    setting.Value = converter.ConvertFromString((string)setting.Value);
                                }
                            }
                        }
                    }
                }
            }

            CreateProperties();
        }