Beispiel #1
0
 private void FirstTimeRunForm_Load(object sender, EventArgs e)
 {
     if (DesignMode)
     {
         return;
     }
     Icon = UserSettingsManager.UserSettings.GetIcon();
     foreach (var setting in Settings.FactoriesOrder)
     {
         FactorySettings factory = Settings.GetFactorySetting(setting);
         if (factory == null)
         {
             continue;
         }
         var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
         string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Disabled";
         var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
         FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
         chkLstDataProviderStatus.Items.Add(itm, factory.Status == DataProviderFactoryStatus.Enabled);
     }
     //add missing:
     foreach (var factory in Settings.FactoriesSettings.Where(itm => !Settings.FactoriesOrder.Contains(itm.FactoryId)))
     {
         var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
         string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Disabled";
         var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
         FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
         chkLstDataProviderStatus.Items.Add(itm, factory.Status != DataProviderFactoryStatus.Disabled);
     }
 }
        private void LoadSettings()
        {
            tsRememberLastOpenedDataProvider.IsOn = Settings.RememberLastOpenedDataProvider;
            foreach (var setting in Settings.FactoriesOrder)
            {
                FactorySettings factory = Settings.GetFactorySetting(setting);
                if (factory == null)
                {
                    continue;
                }

                var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
                string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Not found";
                var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
                FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
                chkLstDataProviderStatus.Items.Add(itm, factory.Status == DataProviderFactoryStatus.Enabled);
            }
            //add missing:
            foreach (var factory in Settings.FactoriesSettings.Where(itm => !Settings.FactoriesOrder.Contains(itm.FactoryId)))
            {
                var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
                string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Disabled";
                var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
                FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
                chkLstDataProviderStatus.Items.Add(itm, factory.Status != DataProviderFactoryStatus.Disabled);
            }
        }
        private void LoadSettings()
        {
            var loaded = FactoriesManager.Instance.GetRealTimeDataSourcesNamesAndIds();

            foreach (var realTime in loaded)
            {
                FactoryCheckItem itm = new FactoryCheckItem(realTime.Name, realTime.ID, realTime.Description, realTime.Image);
                chkLstItemRealTimeDataSources.Items.Add(itm, Settings.AutoStartDataProviders.Contains(itm.ID));
            }
        }
        private void LoadSettings()
        {
            var extensions = FactoriesManager.Instance.GetAllExtensions();

            foreach (var ex in extensions)
            {
                FactoryCheckItem itm = new FactoryCheckItem(ex.Title, ex.Id, ex.Description, null);
                chkLstItemExtensions.Items.Add(itm, Settings.StartupExtensions.Contains(itm.ID));
            }
        }
 private void SetupEventsHandlers()
 {
     chkLstDataProviderStatus.ItemCheck           += (s, e) => SaveSettings();
     tsRememberLastOpenedDataProvider.IsOnChanged += (s, e) =>
                                                     Settings.RememberLastOpenedDataProvider = tsRememberLastOpenedDataProvider.IsOn;
     chkLstDataProviderStatus.CustomizeItem += (s, e) =>
     {
         FactoryCheckItem bind = (FactoryCheckItem)e.Value;
         e.TemplatedItem.Elements[0].ImageOptions.Image = bind.Image;
         e.TemplatedItem.Elements[1].Text = $"{bind.Name} (id:{bind.ID})";
         e.TemplatedItem.Elements[2].Text = bind.Description;
     };
 }
 private void SetupEventsHandlers()
 {
     chkLstItemRealTimeDataSources.ItemCheck += (s, e) =>
     {
         Settings.AutoStartDataProviders = new List <Guid>();
         foreach (CheckedListBoxItem item in chkLstItemRealTimeDataSources.Items)
         {
             if (item.CheckState == CheckState.Checked)
             {
                 FactoryCheckItem f = (FactoryCheckItem)item.Value;
                 Settings.AutoStartDataProviders.Add(f.ID);
             }
         }
     };
 }
 private void SetupEventsHandlers()
 {
     chkLstItemExtensions.ItemCheck += (s, e) =>
     {
         Settings.StartupExtensions = new List <Guid>();
         foreach (CheckedListBoxItem item in chkLstItemExtensions.Items)
         {
             if (item.CheckState == CheckState.Checked)
             {
                 FactoryCheckItem f = (FactoryCheckItem)item.Value;
                 Settings.StartupExtensions.Add(f.ID);
             }
         }
     };
 }
        private async void FirstTimeRunForm_Load(object sender, EventArgs e)
        {
            if (DesignMode)
            {
                return;
            }

            xtraTabControl1.ShowTabHeader = DefaultBoolean.False;
            Icon = UserSettingsManager.UserSettings.GetIcon();
            await FactoriesManager.Instance.InitializeBuiltInFactories();

            await FactoriesManager.Instance.AddExternalDataSources();

            chkLstDataProviderStatus.CustomizeItem += (s, e) =>
            {
                FactoryCheckItem bind = (FactoryCheckItem)e.Value;
                e.TemplatedItem.Elements[0].ImageOptions.Image = bind.Image;
                e.TemplatedItem.Elements[1].Text = $"{bind.Name} (id:{bind.ID})";
                e.TemplatedItem.Elements[2].Text = bind.Description;
            };
            chkLstDataProviderStatus.ItemCheck += (s, e) => SaveSettings();

            foreach (var setting in Settings.FactoriesOrder)
            {
                FactorySettings factory = Settings.GetFactorySetting(setting);
                if (factory == null)
                {
                    continue;
                }

                var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
                string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Disabled";
                var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
                FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
                chkLstDataProviderStatus.Items.Add(itm, factory.Status == DataProviderFactoryStatus.Enabled);
            }
            //add missing:
            foreach (var factory in Settings.FactoriesSettings.Where(itm => !Settings.FactoriesOrder.Contains(itm.FactoryId)))
            {
                var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
                string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Disabled";
                var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
                FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
                chkLstDataProviderStatus.Items.Add(itm, factory.Status != DataProviderFactoryStatus.Disabled);
            }
        }
        private void SaveSettings()
        {
            List <Guid> order = new List <Guid>(chkLstDataProviderStatus.Items.Count);

            foreach (CheckedListBoxItem item in chkLstDataProviderStatus.Items)
            {
                FactoryCheckItem fci = (FactoryCheckItem)item.Value;
                order.Add(fci.ID);
                var guid    = fci.ID;
                var factory = Settings.FactoriesSettings.SingleOrDefault(f => f.FactoryId == guid);
                if (factory != null)
                {
                    factory.Status = item.CheckState == CheckState.Checked
                        ? DataProviderFactoryStatus.Enabled
                        : DataProviderFactoryStatus.Disabled;
                }
            }
        }
Beispiel #10
0
        private void SaveSetting()
        {
            SaveColorsSettings();
            Settings.SettingsMode = tsSettingModeApplictionFolder.IsOn
                ? SettingsMode.ApplicationFolder
                : SettingsMode.PerUser;
            Settings.RealTimeRefreshInterval = (float)nudRealTimeRefreshInterval.Value;
            Settings.TrackActiveMessage      = tsTrackActiveMessage.IsOn;
            Settings.SimpleMode         = tsSimpleMode.IsOn;
            Settings.LogLevelSelection  = tsLogLevels.IsOn ? LogLevelSelectionType.Multiple : LogLevelSelectionType.Single;
            Settings.RecentFilesCount   = (int)nudRecentFiles.Value;
            Settings.RecentFoldersCount = (int)nudRecentFolders.Value;
            List <Guid> order = new List <Guid>(chkLstDataProviderStatus.Items.Count);

            foreach (CheckedListBoxItem item in chkLstDataProviderStatus.Items)
            {
                FactoryCheckItem fci = (FactoryCheckItem)item.Value;
                order.Add(fci.ID);
                var guid    = fci.ID;
                var factory = Settings.FactoriesSettings.SingleOrDefault(f => f.FactoryId == guid);
                if (factory != null)
                {
                    factory.Status = item.CheckState == CheckState.Checked
                        ? DataProviderFactoryStatus.Enabled
                        : DataProviderFactoryStatus.Disabled;
                }
            }

            Settings.AutoStartDataProviders = new List <Guid>();
            foreach (CheckedListBoxItem item in chkLstItemRealTimeDataSources.Items)
            {
                if (item.CheckState == CheckState.Checked)
                {
                    FactoryCheckItem f = (FactoryCheckItem)item.Value;
                    Settings.AutoStartDataProviders.Add(f.ID);
                }
            }

            Settings.StartupExtensions = new List <Guid>();
            foreach (CheckedListBoxItem item in chkLstItemExtensions.Items)
            {
                if (item.CheckState == CheckState.Checked)
                {
                    FactoryCheckItem f = (FactoryCheckItem)item.Value;
                    Settings.StartupExtensions.Add(f.ID);
                }
            }

            Settings.RememberLastOpenedDataProvider = tsRememberLastOpenedDataProvider.IsOn;
            Settings.RememberLastSearches           = tsAutoComplete.IsOn;
            Settings.UpdateOrder(order);
            Settings.AdditionalProbingLocations = listBoxFoldersProbing.Items.Cast <string>().ToList();
            Settings.SingleInstance             = tsSingleInstance.IsOn;
            Settings.AnalogyIcon = rbtnLightIconColor.Checked ? "Light" : "Dark";
            var options = typeof(UpdateMode).GetDisplayValues();

            UpdateManager.Instance.UpdateMode = (UpdateMode)Enum.Parse(typeof(UpdateMode),
                                                                       options.Single(k => k.Value == cbUpdates.SelectedItem.ToString()).Key, true);
            Settings.MinimizedToTrayBar                   = tsTraybar.IsOn;
            Settings.CheckAdditionalInformation           = tsCheckAdditionalInformation.IsOn;
            Settings.AnalogyPosition.RememberLastPosition = tsRememberLastPositionAndState.IsOn;
            Settings.EnableCompressedArchives             = tsEnableCompressedArchive.IsOn;
            if (rbFontSizeDefault.Checked)
            {
                Settings.FontSettings.SetFontSelectionType(FontSelectionType.Default);
            }
            else if (rbFontSizeNormal.Checked)
            {
                Settings.FontSettings.SetFontSelectionType(FontSelectionType.Normal);
            }

            else if (rbFontSizeLarge.Checked)
            {
                Settings.FontSettings.SetFontSelectionType(FontSelectionType.Large);
            }

            else if (rbFontSizeVeryLarge.Checked)
            {
                Settings.FontSettings.SetFontSelectionType(FontSelectionType.VeryLarge);
            }

            if (rbMenuFontSizeDefault.Checked)
            {
                Settings.FontSettings.SetMenuFontSelectionType(FontSelectionType.Default);
            }
            else if (rbMenuFontSizeNormal.Checked)
            {
                Settings.FontSettings.SetMenuFontSelectionType(FontSelectionType.Normal);
            }

            else if (rbMenuFontSizeLarge.Checked)
            {
                Settings.FontSettings.SetMenuFontSelectionType(FontSelectionType.Large);
            }

            else if (rbMenuFontSizeVeryLarge.Checked)
            {
                Settings.FontSettings.SetMenuFontSelectionType(FontSelectionType.VeryLarge);
            }

            Settings.EnableFirstChanceException = tsEnableFirstChanceException.IsOn;

            Settings.Save();
        }
Beispiel #11
0
        private void LoadSettings()
        {
            tsSettingModeApplictionFolder.IsOn = Settings.SettingsMode == SettingsMode.ApplicationFolder;
            tsSimpleMode.IsOn = Settings.SimpleMode;
            nudRealTimeRefreshInterval.Value    = (decimal)Settings.RealTimeRefreshInterval;
            tsTrackActiveMessage.IsOn           = Settings.TrackActiveMessage;
            tsEnableCompressedArchive.IsOn      = Settings.EnableCompressedArchives;
            tsRememberLastPositionAndState.IsOn = Settings.AnalogyPosition.RememberLastPosition;
            logGrid.Columns["Date"].DisplayFormat.FormatType   = FormatType.DateTime;
            logGrid.Columns["Date"].DisplayFormat.FormatString = Settings.DateTimePattern;
            tsHistory.IsOn          = Settings.ShowHistoryOfClearedMessages;
            teDateTimeFormat.Text   = Settings.DateTimePattern;
            tsFilteringExclude.IsOn = Settings.SaveSearchFilters;
            listBoxFoldersProbing.Items.AddRange(Settings.AdditionalProbingLocations.ToArray());
            tsAutoComplete.IsOn    = Settings.RememberLastSearches;
            nudRecentFiles.Value   = Settings.RecentFilesCount;
            nudRecentFolders.Value = Settings.RecentFoldersCount;
            //tsSimpleMode.IsOn = Settings.SimpleMode;
            tsFileCaching.IsOn            = Settings.EnableFileCaching;
            tsStartupRibbonMinimized.IsOn = Settings.StartupRibbonMinimized;
            tsErrorLevelAsDefault.IsOn    = Settings.StartupErrorLogLevel;
            chkEditPaging.Checked         = Settings.PagingEnabled;
            if (Settings.PagingEnabled)
            {
                nudPageLength.Value = Settings.PagingSize;
            }
            else
            {
                nudPageLength.Enabled = false;
            }

            checkEditSearchAlsoInSourceAndModule.Checked = Settings.SearchAlsoInSourceAndModule;
            toggleSwitchIdleMode.IsOn    = Settings.IdleMode;
            nudIdleTime.Value            = Settings.IdleTimeMinutes;
            tsDataTimeAscendDescend.IsOn = Settings.DefaultDescendOrder;

            var startup = Settings.AutoStartDataProviders;
            var loaded  = FactoriesManager.Instance.GetRealTimeDataSourcesNamesAndIds();

            foreach (var realTime in loaded)
            {
                FactoryCheckItem itm = new FactoryCheckItem(realTime.Name, realTime.ID, realTime.Description, realTime.Image);
                chkLstItemRealTimeDataSources.Items.Add(itm, startup.Contains(itm.ID));
            }

            foreach (var setting in Settings.FactoriesOrder)
            {
                FactorySettings factory = Settings.GetFactorySetting(setting);
                if (factory == null)
                {
                    continue;
                }

                var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
                string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Disabled";
                var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
                FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
                chkLstDataProviderStatus.Items.Add(itm, factory.Status == DataProviderFactoryStatus.Enabled);
            }
            //add missing:
            foreach (var factory in Settings.FactoriesSettings.Where(itm => !Settings.FactoriesOrder.Contains(itm.FactoryId)))
            {
                var              factoryContainer = FactoriesManager.Instance.FactoryContainer(factory.FactoryId);
                string           about            = (factoryContainer?.Factory != null) ? factoryContainer.Factory.About : "Disabled";
                var              image            = FactoriesManager.Instance.GetLargeImage(factory.FactoryId);
                FactoryCheckItem itm = new FactoryCheckItem(factory.FactoryName, factory.FactoryId, about, image);
                chkLstDataProviderStatus.Items.Add(itm, factory.Status != DataProviderFactoryStatus.Disabled);
            }

            //file associations:

            cbDataProviderAssociation.Properties.DataSource    = Settings.FactoriesSettings;
            cbDataProviderAssociation.Properties.DisplayMember = "FactoryName";
            cbDataProviderAssociation.EditValue = Settings.FactoriesSettings.First();
            //cbDataProviderAssociation.Properties.ValueMember = "ID";
            tsRememberLastOpenedDataProvider.IsOn = Settings.RememberLastOpenedDataProvider;
            lboxHighlightItems.DataSource         = Settings.PreDefinedQueries.Highlights;
            lboxAlerts.DataSource      = Settings.PreDefinedQueries.Alerts;
            lboxFilters.DataSource     = Settings.PreDefinedQueries.Filters;
            nudAutoCompleteCount.Value = Settings.NumberOfLastSearches;
            tsSingleInstance.IsOn      = Settings.SingleInstance;
            if (Settings.AnalogyIcon == "Light")
            {
                rbtnLightIconColor.Checked = true;
            }
            else
            {
                rbtnDarkIconColor.Checked = true;
            }
            LoadColorsSettings();
            cbUpdates.Properties.Items.AddRange(typeof(UpdateMode).GetDisplayValues().Values);
            cbUpdates.SelectedItem = UpdateManager.Instance.UpdateMode.GetDisplay();
            if (AnalogyNonPersistSettings.Instance.DisableUpdatesByDataProvidersOverrides)
            {
                lblDisableUpdates.Visible = true;
                cbUpdates.Enabled         = false;
            }
            tsTraybar.IsOn = Settings.MinimizedToTrayBar;
            tsCheckAdditionalInformation.IsOn = Settings.CheckAdditionalInformation;
            tsLogLevels.IsOn = Settings.LogLevelSelection == LogLevelSelectionType.Multiple;
            Utils.SetLogLevel(chkLstLogLevel);
            Utils.FillLogLevels(chklExclusionLogLevel);
            switch (Settings.FontSettings.FontSelectionType)
            {
            case FontSelectionType.Default:
                rbFontSizeDefault.Checked = true;
                break;

            case FontSelectionType.Normal:
                rbFontSizeNormal.Checked = true;
                break;

            case FontSelectionType.Large:
                rbFontSizeLarge.Checked = true;
                break;

            case FontSelectionType.VeryLarge:
                rbFontSizeVeryLarge.Checked = true;
                break;

            case FontSelectionType.Manual:
            default:
                rbFontSizeNormal.Checked = true;
                break;
            }
            switch (Settings.FontSettings.MenuFontSelectionType)
            {
            case FontSelectionType.Default:
                rbMenuFontSizeDefault.Checked = true;
                break;

            case FontSelectionType.Normal:
                rbMenuFontSizeNormal.Checked = true;
                break;

            case FontSelectionType.Large:
                rbMenuFontSizeLarge.Checked = true;
                break;

            case FontSelectionType.VeryLarge:
                rbMenuFontSizeVeryLarge.Checked = true;
                break;

            case FontSelectionType.Manual:
            default:
                rbMenuFontSizeNormal.Checked = true;
                break;
            }

            tsRibbonCompactStyle.IsOn         = Settings.RibbonStyle == CommandLayout.Simplified;
            tsEnableFirstChanceException.IsOn = Settings.EnableFirstChanceException;

            var extensions = FactoriesManager.Instance.GetAllExtensions();

            foreach (var ex in extensions)
            {
                FactoryCheckItem itm = new FactoryCheckItem(ex.Title, ex.Id, ex.Description, null);
                chkLstItemExtensions.Items.Add(itm, Settings.StartupExtensions.Contains(itm.ID));
            }
        }