private void ItemSearchResultList_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (!_loaded || ActiveItem == null)
            {
                return;
            }

            PriceCheckResults pcr = null;
            if (ActiveItem != null)
            {
                pcr = CmdPriceCheck.GetPriceCheckResults(ActiveItem.Item);

                _changingQuality = true;
                Quality oldQuality = ClassifiedsQualities.SelectedQuality;
                ClassifiedsQualities.ClearAllQualities();
                foreach (CheckedPrice cp in pcr.All)
                {
                    ClassifiedsQualities.EnableQuality(cp.Quality);
                }
                if (ClassifiedsQualities.AvailableQualities.Contains(oldQuality))
                {
                    ClassifiedsQualities.SelectedQuality = oldQuality;
                }
                else
                {
                    ClassifiedsQualities.SelectFirstAvailable();
                }
                _changingQuality = false;

                if (pcr.All.Exists((cp) => cp.Quality == ClassifiedsQualities.SelectedQuality))
                {
                    bool hasCraftable = pcr.All.Exists((cp) => cp.Craftable);
                    bool hasUncraftable = pcr.All.Exists((cp) => !cp.Craftable);

                    ClassifiedsCraftableCheck.IsEnabled = hasCraftable && hasUncraftable;
                    if (!ClassifiedsCraftableCheck.IsEnabled)
                    {
                        ClassifiedsCraftableCheck.IsChecked = hasCraftable;
                    }

                    bool hasTradable = pcr.All.Exists((cp) => cp.Tradable);
                    bool hasNontradable = pcr.All.Exists((cp) => !cp.Tradable);

                    ClassifiedsTradableCheck.IsEnabled = hasTradable && hasNontradable;
                    if (!ClassifiedsTradableCheck.IsEnabled)
                    {
                        ClassifiedsTradableCheck.IsChecked = hasTradable;
                    }
                }
                else
                {
                    ClassifiedsCraftableCheck.IsEnabled = false;
                    ClassifiedsCraftableCheck.IsChecked = true;

                    ClassifiedsTradableCheck.IsEnabled = false;
                    ClassifiedsTradableCheck.IsChecked = true;
                }

                Info = new ItemPriceInfo(ActiveItem.Item, ClassifiedsQualities.SelectedQuality);
                Info.Craftable = ClassifiedsCraftableCheck.IsChecked ?? false;
                Info.Tradable = ClassifiedsCraftableCheck.IsChecked ?? false;

                ClassifiedsAustraliumCheck.IsEnabled = ActiveItem.Item.CanBeAustralium();
                if (!ClassifiedsAustraliumCheck.IsEnabled)
                {
                    ClassifiedsAustraliumCheck.IsChecked = false;
                }
            }

            RefreshPriceLabel();
        }
 public PricedViewModel(ItemPriceInfo info, PriceRange range)
 {
     Info = info;
     Price = range;
 }
 public void ShowClassifieds(ClassifiedsListing listing)
 {
     ItemPriceInfo buf = new ItemPriceInfo(listing.ItemInstance);
     ShowClassifieds(buf);
 }
        public void ShowClassifieds(ItemPriceInfo info)
        {
            ItemSearchBox.Text = info.Item.ImproperName; // triggers TextChanged event
            ClassifiedsQualities.SelectedQuality = info.Quality; // triggers QualityChanged event
            ClassifiedsCraftableCheck.IsChecked = info.Craftable;
            ClassifiedsCraftableCheck_Click(ClassifiedsCraftableCheck, null); // must be manually triggered
            ClassifiedsTradableCheck.IsChecked = info.Tradable;
            ClassifiedsTradableCheck_Click(ClassifiedsTradableCheck, null); // must be manually triggered
            ClassifiedsAustraliumCheck.IsChecked = info.Australium;
            ClassifiedsAustraliumCheck_Click(ClassifiedsAustraliumCheck, null); // must be manually triggered

            // And...SEARCH!
            ClassifiedsSearchBtn_Click(ClassifiedsSearchBtn, null);
        }
		private void ItemSearchResultList_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (!_loaded || ActiveItem == null)
			{
				return;
			}

			ItemSlotPlain plain = (ItemSlotPlain)ActiveItem?.Item.PlainSlot;
			Killstreaks.IsEnabled = plain == ItemSlotPlain.Weapon;
			if (!Killstreaks.IsEnabled)
			{
				Killstreaks.SelectedKillstreak = CustomSteamTools.Market.KillstreakType.None;
			}

			PriceCheckResults pcr = null;
			if (ActiveItem != null)
			{
				pcr = CmdPriceCheck.GetPriceCheckResults(ActiveItem.Item);

				_changingQuality = true;
				Quality oldQuality = Qualities.SelectedQuality;
				Qualities.ClearAllQualities();
				foreach (CheckedPrice cp in pcr.All)
				{
					Qualities.EnableQuality(cp.Quality);
				}
				if (Qualities.AvailableQualities.Contains(oldQuality))
				{
					Qualities.SelectedQuality = oldQuality;
				}
				else
				{
					Qualities.SelectFirstAvailable();
				}
				_changingQuality = false;

				if (pcr.All.Exists((cp) => cp.Quality == Qualities.SelectedQuality))
				{
					bool hasCraftable = pcr.All.Exists((cp) => cp.Craftable);
					bool hasUncraftable = pcr.All.Exists((cp) => !cp.Craftable);

					CraftableCheckbox.IsEnabled = hasCraftable && hasUncraftable;
					if (!CraftableCheckbox.IsEnabled)
					{
						CraftableCheckbox.IsChecked = hasCraftable;
					}

					bool hasTradable = pcr.All.Exists((cp) => cp.Tradable);
					bool hasNontradable = pcr.All.Exists((cp) => !cp.Tradable);

					TradableCheckbox.IsEnabled = hasTradable && hasNontradable;
					if (!TradableCheckbox.IsEnabled)
					{
						TradableCheckbox.IsChecked = hasTradable;
					}
				}
				else
				{
					CraftableCheckbox.IsEnabled = false;
					CraftableCheckbox.IsChecked = true;

					TradableCheckbox.IsEnabled = false;
					TradableCheckbox.IsChecked = true;
				}

				Info = new ItemPriceInfo(ActiveItem.Item, Qualities.SelectedQuality);
				Info.Killstreak = Killstreaks.SelectedKillstreak;
				Info.Craftable = CraftableCheckbox.IsChecked ?? false;
				Info.Tradable = CraftableCheckbox.IsChecked ?? false;

				AustraliumCheckbox.IsEnabled = ActiveItem.Item.CanBeAustralium();
				if (!AustraliumCheckbox.IsEnabled)
				{
					AustraliumCheckbox.IsChecked = false;
				}
			}

			UnusualEffectsDropdown.IsEnabled = Qualities.SelectedQuality == Quality.Unusual;
			if (!UnusualEffectsDropdown.IsEnabled)
			{
				UnusualEffectsDropdown.SelectedIndex = 0;
			}

			Unusuals.Clear();
			Unusuals.Add(UnusualViewModel.None);
			if (ActiveItem != null)
			{
				List<UnusualViewModel> ues = pcr.Unusuals.ConvertAll((cp) => new UnusualViewModel(cp.Unusual));
				Unusuals.AddRange(ues);
				UnusualEffectsDropdown.SelectedIndex = 0;
				Info.Unusual = ActiveUnusual?.Effect;
			}

			RefreshPriceLabels();
		}
        public void RunFilter()
        {
            if (!_loaded)
            {
                return;
            }

            if (!ValidMin || !ValidMax)
            {
                return;
            }

            const int MAX_SHOWN = 500;

            List<ItemPricing> cmdRes = CmdRange.GetInRange(Range, Filters);

            List<ItemPricing> buf = new List<ItemPricing>();
            for (int i = 0; i < MAX_SHOWN && i < cmdRes.Count; i++)
            {
                buf.Add(cmdRes[i]);
            }
            buf.Sort((a, b) => a.Pricing.Low.TotalRefined.CompareTo(b.Pricing.Low.TotalRefined));

            Pricings.Clear();
            foreach (ItemPricing p in buf)
            {
                ItemPriceInfo info = new ItemPriceInfo(p.Item, p.Quality);

                if (info.Quality == Quality.Unusual && p.PriceIndex > 0)
                {
                    info.Unusual = DataManager.Schema.GetUnusual(p.PriceIndex);
                }

                PricedViewModel vm = new PricedViewModel(info, p.Pricing);

                Pricings.Add(vm);
            }

            if (cmdRes.Count > MAX_SHOWN)
            {
                PricingsCountTxt.Text = Pricings.Count + " pricings shown (" +
                    cmdRes.Count + " results found)";
            }
            else
            {
                PricingsCountTxt.Text = Pricings.Count + " pricings found matching filters";
            }
        }
        /// <summary>
        /// Gets the resulting price from complex algorithm, with the flag "market" if the price
        /// was obtained from the Steam Community Market.
        /// </summary>
        /// <param name="item">Item to check</param>
        /// <returns>The resulting price with flags</returns>
        public static FlaggedResult<PriceRange?, string> GetPriceFlagged(ItemPriceInfo item)
        {
            List<string> flags = new List<string>();

            PriceRange? res = null;
            if (item.Skin != null)
            {
                res = GetSkinPrice(item.Item, item.SkinWear.GetValueOrDefault());
                flags.AddIfMissing("market");
            }

            if (res == null && item.Killstreak != KillstreakType.None)
            {
                res = GetKillstreakPrice(item.Item, item.Quality, item.Killstreak, item.Australium);
                flags.AddIfMissing("market");
            }

            if (res == null)
            {
                res = GetNormalPrice(item.Item, item.Quality, item.Craftable, item.Australium, item.Unusual);
            }

            if (res == null) // still
            {
                string hash = MarketPricing.GetMarketHash(item.Item, item.Killstreak, item.Quality);
                res = GetMarketPriceRange(hash);
                flags.AddIfMissing("market");
            }

            return new FlaggedResult<PriceRange?, string>(res, flags);
        }
 /// <summary>
 /// Gets the resulting price from complex algorithm.
 /// </summary>
 /// <param name="item">Item to check</param>
 /// <returns>The resulting price</returns>
 public static PriceRange? GetPrice(ItemPriceInfo item)
 {
     return GetPriceFlagged(item).Result;
 }
        public Grid GetPriceStamp(CheckedPrice cp)
        {
            Grid res = new Grid();
            ItemPriceInfo info = new ItemPriceInfo(cp.Pricing?.Item, cp.Quality);
            PricedViewModel pvm = new PricedViewModel(info, cp.Price);
            res.ToolTip = pvm.Tooltip;
            res.Margin = new Thickness(2);

            string priceText = cp.Price.ToString();
            bool craftable = cp.Craftable;
            Quality actualQuality = cp.Quality;

            TextBlock textBlock = new TextBlock();
            textBlock.Text = priceText;
            textBlock.FontWeight = FontWeights.SemiBold;
            textBlock.Foreground = new SolidColorBrush(Colors.White);
            textBlock.HorizontalAlignment = HorizontalAlignment.Center;
            textBlock.VerticalAlignment = VerticalAlignment.Center;
            textBlock.Margin = new Thickness(3);
            textBlock.FontSize = 10;

            Rectangle rect = new Rectangle();
            rect.StrokeThickness = 2;
            rect.Fill = new SolidColorBrush(actualQuality.ToWPFColor());
            rect.Stroke = new SolidColorBrush(actualQuality.ToWPFBorderColor());
            if (!craftable)
            {
                rect.StrokeDashArray = new DoubleCollection(new double[] { 0, 2, 0 });
            }

            res.Children.Add(rect);
            res.Children.Add(textBlock);

            return res;
        }