internal static bool LoadSettings() => IsDamageOverlayEnabled = ConfigUtil.IfSet("IsDamageOverlayEnabled");
Exemple #2
0
        public FightTable()
        {
            InitializeComponent();

            // fight search box
            fightSearchBox.FontStyle = FontStyles.Italic;
            fightSearchBox.Text      = Properties.Resources.NPC_SEARCH_TEXT;

            fightMenuItemClear.IsEnabled           = fightMenuItemSelectAll.IsEnabled = fightMenuItemUnselectAll.IsEnabled =
                fightMenuItemSelectFight.IsEnabled = fightMenuItemUnselectFight.IsEnabled = fightMenuItemSetPet.IsEnabled = fightMenuItemSetPlayer.IsEnabled = false;

            View           = CollectionViewSource.GetDefaultView(Fights);
            NonTankingView = CollectionViewSource.GetDefaultView(NonTankingFights);

            var filter = new Predicate <object>(item => !(CurrentShowBreaks == false && ((Fight)item).IsInactivity));

            View.Filter           = filter;
            NonTankingView.Filter = filter;

            SelectionTimer = new DispatcherTimer {
                Interval = new TimeSpan(0, 0, 0, 0, 800)
            };
            SelectionTimer.Tick += (sender, e) =>
            {
                if (!rightClickMenu.IsOpen)
                {
                    EventsSelectionChange(this, fightDataGrid.SelectedItems);
                }
                else
                {
                    NeedSelectionChange = true;
                }

                SelectionTimer.Stop();
            };

            SearchTextTimer = new DispatcherTimer {
                Interval = new TimeSpan(0, 0, 0, 0, 500)
            };
            SearchTextTimer.Tick += (sender, e) =>
            {
                HandleSearchTextChanged();
                SearchTextTimer.Stop();
            };

            UpdateTimer = new DispatcherTimer {
                Interval = new TimeSpan(0, 0, 0, 0, 1500)
            };
            UpdateTimer.Tick += (sender, e) => ProcessFights();
            UpdateTimer.Start();

            // read show hp setting
            fightShowHitPoints.IsChecked        = ConfigUtil.IfSet("NpcShowHitPoints");
            fightDataGrid.Columns[1].Visibility = fightShowHitPoints.IsChecked.Value ? Visibility.Visible : Visibility.Hidden;

            // read show breaks and spells setting
            fightShowBreaks.IsChecked  = CurrentShowBreaks = ConfigUtil.IfSet("NpcShowInactivityBreaks", null, true);
            fightShowTanking.IsChecked = ConfigUtil.IfSet("NpcShowTanking", null, true);

            fightDataGrid.ItemsSource = fightShowTanking.IsChecked.Value ? View : NonTankingView;

            DataManager.Instance.EventsClearedActiveData  += Instance_EventsCleardActiveData;
            DataManager.Instance.EventsRemovedFight       += Instance_EventsRemovedFight;
            DataManager.Instance.EventsNewFight           += Instance_EventsNewFight;
            DataManager.Instance.EventsUpdateFight        += Instance_EventsUpdateFight;
            DataManager.Instance.EventsNewNonTankingFight += Instance_EventsNewNonTankingFight;
        }
Exemple #3
0
 internal static bool LoadSettings()
 {
     IsDamageOverlayEnabled = ConfigUtil.IfSet("IsDamageOverlayEnabled");
     return(IsDamageOverlayEnabled);
 }
Exemple #4
0
        public OverlayWindow(bool configure = false)
        {
            InitializeComponent();
            LoadColorSettings();

            string width  = ConfigUtil.GetSetting("OverlayWidth");
            string height = ConfigUtil.GetSetting("OverlayHeight");
            string top    = ConfigUtil.GetSetting("OverlayTop");
            string left   = ConfigUtil.GetSetting("OverlayLeft");

            // Hide other player names on overlay
            IsHideOverlayOtherPlayersEnabled = ConfigUtil.IfSet("HideOverlayOtherPlayers");
            showNameSelection.SelectedIndex  = IsHideOverlayOtherPlayersEnabled ? 1 : 0;

            // Hide/Show crit rate
            IsShowOverlayCritRateEnabled        = ConfigUtil.IfSet("ShowOverlayCritRate");
            showCritRateSelection.SelectedIndex = IsShowOverlayCritRateEnabled ? 1 : 0;

            var  margin     = SystemParameters.WindowNonClientFrameThickness;
            bool offsetSize = configure || width == null || height == null || top == null || left == null;

            if (!offsetSize)
            {
                CreateRows();
                Title       = "Overlay";
                MinHeight   = 0;
                UpdateTimer = new DispatcherTimer {
                    Interval = new TimeSpan(0, 0, 0, 0, 1000)
                };
                UpdateTimer.Tick  += UpdateTimerTick;
                AllowsTransparency = true;
                Style       = null;
                WindowStyle = WindowStyle.None;
                SetVisible(false);
                ShowActivated = false;
            }
            else
            {
                overlayCanvas.Background = new SolidColorBrush(Color.FromRgb(45, 45, 48));
                CreateRows(true);
                MinHeight          = 130;
                AllowsTransparency = false;
                WindowStyle        = WindowStyle.SingleBorderWindow;
                SetVisible(true);
                LoadTestData();
            }

            if (width != null && double.TryParse(width, out double dvalue) && !double.IsNaN(dvalue))
            {
                Width = offsetSize ? dvalue + margin.Left + margin.Right : dvalue;
            }

            if (height != null && double.TryParse(height, out dvalue) && !double.IsNaN(dvalue))
            {
                Height = offsetSize ? dvalue + margin.Top + margin.Bottom : 0;
                if (!offsetSize)
                {
                    CalculatedRowHeight = dvalue / (MAX_ROWS + 1);
                }
            }

            if (top != null && double.TryParse(top, out dvalue) && !double.IsNaN(dvalue))
            {
                var test = offsetSize ? dvalue - margin.Top : dvalue;
                if (test >= SystemParameters.VirtualScreenTop && test < SystemParameters.VirtualScreenHeight)
                {
                    Top = test;
                }
            }

            if (left != null && double.TryParse(left, out dvalue) && !double.IsNaN(dvalue))
            {
                var test = offsetSize ? dvalue - margin.Left : dvalue;
                if (test >= SystemParameters.VirtualScreenLeft && test < SystemParameters.VirtualScreenWidth)
                {
                    Left = test;
                }
            }

            int damageMode = ConfigUtil.GetSettingAsInteger("OverlayDamageMode");

            foreach (var item in damageModeSelection.Items.Cast <ComboBoxItem>())
            {
                if ((string)item.Tag == damageMode.ToString(CultureInfo.CurrentCulture))
                {
                    damageModeSelection.SelectedItem = item;
                    CurrentDamageSelectionMode       = damageMode;
                }
            }

            string fontSize        = ConfigUtil.GetSetting("OverlayFontSize");
            bool   fontHasBeenSet  = false;
            int    currentFontSize = DEFAULT_TEXT_FONT_SIZE;

            if (fontSize != null && int.TryParse(fontSize, out currentFontSize) && currentFontSize >= 0 && currentFontSize <= 64)
            {
                foreach (var item in fontSizeSelection.Items)
                {
                    if ((item as ComboBoxItem).Tag as string == fontSize)
                    {
                        fontSizeSelection.SelectedItem = item;
                        SetFont(currentFontSize);
                        fontHasBeenSet = true;
                    }
                }
            }

            if (!fontHasBeenSet)
            {
                SetFont(currentFontSize);
            }

            if (!offsetSize)
            {
                NpcDamageManager.EventsPlayerAttackProcessed += NpcDamageManager_EventsPlayerAttackProcessed;
                DataManager.Instance.EventsNewInactiveFight  += Instance_EventsNewInactiveFight;
                Active = true;
            }
            else
            {
                // remove when configuring
                NpcDamageManager.EventsPlayerAttackProcessed -= NpcDamageManager_EventsPlayerAttackProcessed;
                DataManager.Instance.EventsNewInactiveFight  -= Instance_EventsNewInactiveFight;
            }

            if (!configure)
            {
                var settingsButton = CreateButton("Change Settings", "\xE713", currentFontSize - 1);
                settingsButton.Click += (object sender, RoutedEventArgs e) => OverlayUtil.OpenOverlay(Dispatcher, true, false);
                settingsButton.Margin = new Thickness(4, 0, 0, 0);

                var copyButton = CreateButton("Copy Parse", "\xE8C8", currentFontSize - 1);
                copyButton.Click += (object sender, RoutedEventArgs e) =>
                {
                    lock (Stats)
                    {
                        (Application.Current.MainWindow as MainWindow)?.AddAndCopyDamageParse(Stats, Stats.StatsList);
                    }
                };

                var refreshButton = CreateButton("Cancel Current Parse", "\xE8BB", currentFontSize - 1);
                refreshButton.Click += (object sender, RoutedEventArgs e) => OverlayUtil.ResetOverlay(Dispatcher);

                ButtonPopup  = new Popup();
                ButtonsPanel = CreateNameStackPanel();
                ButtonsPanel.Children.Add(settingsButton);
                ButtonsPanel.Children.Add(copyButton);
                ButtonsPanel.Children.Add(refreshButton);
                ButtonPopup.Child = ButtonsPanel;
                ButtonPopup.AllowsTransparency = true;
                ButtonPopup.Opacity            = 0.3;
                ButtonPopup.Placement          = PlacementMode.Relative;
                ButtonPopup.PlacementTarget    = this;
                ButtonPopup.VerticalOffset     = -1;

                ButtonsPanel.SizeChanged += (object sender, SizeChangedEventArgs e) =>
                {
                    if (TitlePanel.Margin.Left != e.NewSize.Width + 2)
                    {
                        TitlePanel.Margin = new Thickness(e.NewSize.Width + 2, TitlePanel.Margin.Top, 0, TitlePanel.Margin.Bottom);
                    }

                    if (ButtonsPanel != null && ButtonsPanel.ActualHeight != TitlePanel.ActualHeight)
                    {
                        ButtonsPanel.Height = TitlePanel.ActualHeight;
                    }
                };
            }
        }
Exemple #5
0
        public MainWindow()
        {
            try
            {
                InitializeComponent();

                // update titles
#pragma warning disable CA1303 // Do not pass literals as localized parameters
                versionText.Text = VERSION;
#pragma warning restore CA1303 // Do not pass literals as localized parameters

                // used for setting menu icons based on open windows
                IconToWindow = new Dictionary <string, DockingWindow>()
                {
                    { npcIcon.Name, npcWindow }, { verifiedPlayersIcon.Name, verifiedPlayersWindow },
                    { verifiedPetsIcon.Name, verifiedPetsWindow }, { petMappingIcon.Name, petMappingWindow },
                    { playerParseIcon.Name, playerParseTextWindow }
                };

                // Clear/Reset
                DataManager.Instance.EventsClearedActiveData += Instance_EventsClearedActiveData;

                // verified pets table
                verifiedPetsGrid.ItemsSource = VerifiedPetsView;
                PlayerManager.Instance.EventsNewVerifiedPet += (sender, name) => Dispatcher.InvokeAsync(() =>
                {
                    Helpers.InsertNameIntoSortedList(name, VerifiedPetsView);
                    verifiedPetsWindow.Title = string.Format(CultureInfo.CurrentCulture, PETS_LIST_TITLE, VerifiedPetsView.Count);
                });

                // pet -> players
                petMappingGrid.ItemsSource = PetPlayersView;
                PlayerManager.Instance.EventsNewPetMapping += (sender, mapping) =>
                {
                    Dispatcher.InvokeAsync(() =>
                    {
                        var existing = PetPlayersView.FirstOrDefault(item => item.Pet.Equals(mapping.Pet, StringComparison.OrdinalIgnoreCase));
                        if (existing != null && existing.Owner != mapping.Owner)
                        {
                            existing.Owner = mapping.Owner;
                        }
                        else
                        {
                            PetPlayersView.Add(mapping);
                        }

                        petMappingWindow.Title = "Pet Owners (" + PetPlayersView.Count + ")";
                    });
                    CheckComputeStats();
                };

                PlayerManager.Instance.EventsRemoveVerifiedPet += (sender, name) => Dispatcher.InvokeAsync(() =>
                {
                    var found = VerifiedPetsView.FirstOrDefault(item => item.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
                    if (found != null)
                    {
                        VerifiedPetsView.Remove(found);
                        verifiedPetsWindow.Title = string.Format(CultureInfo.CurrentCulture, PETS_LIST_TITLE, VerifiedPetsView.Count);

                        var existing = PetPlayersView.FirstOrDefault(item => item.Pet.Equals(name, StringComparison.OrdinalIgnoreCase));
                        if (existing != null)
                        {
                            PetPlayersView.Remove(existing);
                            petMappingWindow.Title = "Pet Owners (" + PetPlayersView.Count + ")";
                        }
                        CheckComputeStats();
                    }
                });

                // verified player table
                verifiedPlayersGrid.ItemsSource = VerifiedPlayersProperty;
                PlayerManager.Instance.EventsNewVerifiedPlayer += (sender, name) => Dispatcher.InvokeAsync(() =>
                {
                    Helpers.InsertNameIntoSortedList(name, VerifiedPlayersProperty);
                    verifiedPlayersWindow.Title = string.Format(CultureInfo.CurrentCulture, PLAYER_LIST_TITLE, VerifiedPlayersProperty.Count);
                });

                PlayerManager.Instance.EventsRemoveVerifiedPlayer += (sender, name) => Dispatcher.InvokeAsync(() =>
                {
                    var found = VerifiedPlayersProperty.FirstOrDefault(item => item.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
                    if (found != null)
                    {
                        VerifiedPlayersProperty.Remove(found);
                        verifiedPlayersWindow.Title = string.Format(CultureInfo.CurrentCulture, PLAYER_LIST_TITLE, VerifiedPlayersProperty.Count);

                        var existing = PetPlayersView.FirstOrDefault(item => item.Owner.Equals(name, StringComparison.OrdinalIgnoreCase));
                        if (existing != null)
                        {
                            PetPlayersView.Remove(existing);
                            petMappingWindow.Title = "Pet Owners (" + PetPlayersView.Count + ")";
                        }
                        CheckComputeStats();
                    }
                });

                (npcWindow.Content as FightTable).EventsSelectionChange += (sender, data) => ComputeStats();
                DamageStatsManager.Instance.EventsUpdateDataPoint       += (sender, data) => HandleChartUpdateEvent(DamageChartWindow, sender, data);
                HealingStatsManager.Instance.EventsUpdateDataPoint      += (sender, data) => HandleChartUpdateEvent(HealingChartWindow, sender, data);
                TankingStatsManager.Instance.EventsUpdateDataPoint      += (sender, data) => HandleChartUpdateEvent(TankingChartWindow, sender, data);

                // Setup themes
                ThemeManager.BeginUpdate();
                ThemeManager.AreNativeThemesEnabled = true;
                SystemThemeCatalogRegistrar.Register();
                ThemeManager.CurrentTheme = ThemeNames.Dark;

                UpdateDeleteChatMenu();

                // Bane Damage
                IsBaneDamageEnabled             = ConfigUtil.IfSet("IncludeBaneDamage");
                enableBaneDamageIcon.Visibility = IsBaneDamageEnabled ? Visibility.Visible : Visibility.Hidden;

                // Damage Overlay
                enableDamageOverlayIcon.Visibility = OverlayUtil.LoadSettings() ? Visibility.Visible : Visibility.Hidden;

                // AoE healing
                IsAoEHealingEnabled             = ConfigUtil.IfSet("IncludeAoEHealing");
                enableAoEHealingIcon.Visibility = IsAoEHealingEnabled ? Visibility.Visible : Visibility.Hidden;

                // Hide window when minimized
                IsHideOnMinimizeEnabled             = ConfigUtil.IfSet("HideWindowOnMinimize");
                enableHideOnMinimizeIcon.Visibility = IsHideOnMinimizeEnabled ? Visibility.Visible : Visibility.Hidden;

                // Show Tanking Summary at startup
                ConfigUtil.IfSet("ShowTankingSummaryAtStartup", OpenTankingSummary);
                // Show Healing Summary at startup
                ConfigUtil.IfSet("ShowHealingSummaryAtStartup", OpenHealingSummary);
                // Show Healing Summary at startup
                ConfigUtil.IfSet("ShowDamageSummaryAtStartup", OpenDamageSummary, true);
                // Show Tanking Summary at startup
                ConfigUtil.IfSet("ShowTankingChartAtStartup", OpenTankingChart);
                // Show Healing Summary at startup
                ConfigUtil.IfSet("ShowHealingChartAtStartup", OpenHealingChart);
                // Show Healing Summary at startup
                ConfigUtil.IfSet("ShowDamageChartAtStartup", OpenDamageChart);
                LOG.Info("Initialized Components");

                if (ConfigUtil.IfSet("AutoMonitor"))
                {
                    enableAutoMonitorIcon.Visibility = Visibility.Visible;
                    var previousFile = ConfigUtil.GetSetting("LastOpenedFile");
                    if (File.Exists(previousFile))
                    {
                        OpenLogFile(LogOption.MONITOR, previousFile);
                    }
                }
                else
                {
                    enableAutoMonitorIcon.Visibility = Visibility.Hidden;
                }

                if (ConfigUtil.IfSet("Debug"))
                {
                    LOG.Info("Debug Enabled. Saving Unprocessed Lines to " + ConfigUtil.LogsDir);
                    ConfigUtil.Debug = true;
                }
            }
            catch (Exception e)
            {
                LOG.Error(e);
                throw;
            }
            finally
            {
                ThemeManager.EndUpdate();
            }
        }
Exemple #6
0
        public FightTable()
        {
            InitializeComponent();

            // fight search box
            fightSearchBox.FontStyle = FontStyles.Italic;
            fightSearchBox.Text      = Properties.Resources.NPC_SEARCH_TEXT;

            fightMenuItemClear.IsEnabled  = fightMenuItemSelectAll.IsEnabled = fightMenuItemUnselectAll.IsEnabled = fightMenuItemSelectFight.IsEnabled = false;
            fightMenuItemSetPet.IsEnabled = fightMenuItemSetPlayer.IsEnabled = false;

            var view = CollectionViewSource.GetDefaultView(Fights);

            view.Filter = new Predicate <object>(item =>
            {
                var fightItem = (Fight)item;
                return(CurrentShowBreaks ? fightItem.GroupId >= -1 : fightItem.GroupId > -1);
            });

            fightDataGrid.ItemsSource = view;

            SelectionTimer = new DispatcherTimer {
                Interval = new TimeSpan(0, 0, 0, 0, 800)
            };
            SelectionTimer.Tick += (sender, e) =>
            {
                if (!rightClickMenu.IsOpen)
                {
                    EventsSelectionChange(this, fightDataGrid.SelectedItems);
                }
                else
                {
                    NeedSelectionChange = true;
                }

                SelectionTimer.Stop();
            };

            SearchTextTimer = new DispatcherTimer {
                Interval = new TimeSpan(0, 0, 0, 0, 400)
            };
            SearchTextTimer.Tick += (sender, e) =>
            {
                HandleSearchTextChanged();
                SearchTextTimer.Stop();
            };

            RefreshTimer = new DispatcherTimer {
                Interval = new TimeSpan(0, 0, 0, 0, 5000)
            };
            RefreshTimer.Tick += (sender, e) =>
            {
                (fightDataGrid.ItemsSource as ICollectionView).Refresh();
                NeedRefresh = false;
                RefreshTimer.Stop();
            };

            UpdateTimer = new DispatcherTimer {
                Interval = new TimeSpan(0, 0, 0, 0, 500)
            };
            UpdateTimer.Tick += (sender, e) =>
            {
                // get state so it can't be modified outside this thread
                var currentNeedRefresh = NeedRefresh;

                if (NeedScroll)
                {
                    (fightDataGrid.ItemsSource as ICollectionView).Refresh();
                    currentNeedRefresh = false;
                    NeedRefresh        = false;

                    var last = Fights.LastOrDefault(fight => fight.GroupId > -1);

                    if (last != null)
                    {
                        fightDataGrid.ScrollIntoView(last);
                    }

                    NeedScroll = false;
                }

                if (currentNeedRefresh && !Keyboard.IsKeyDown(Key.LeftShift) && !RefreshTimer.IsEnabled)
                {
                    RefreshTimer.Start();
                }
            };

            UpdateTimer.Start();

            // read show hp setting
            fightShowHitPoints.IsChecked        = ConfigUtil.IfSet("NpcShowHitPoints");
            fightDataGrid.Columns[1].Visibility = fightShowHitPoints.IsChecked.Value ? Visibility.Visible : Visibility.Hidden;
            // read show breaks setting
            fightShowBreaks.IsChecked = CurrentShowBreaks = ConfigUtil.IfSet("NpcShowInactivityBreaks", null, true);
        }