public OverlayWindow(Config config, Game game)
        {
            InitializeComponent();
            _config = config;
            _game = game;

            ListViewPlayer.ItemsSource = _game.IsUsingPremade
                                             ? _game.PlayerDeck
                                             : _game.PlayerDrawn;
            ListViewOpponent.ItemsSource = _game.OpponentCards;
            Scaling = 1.0;
            OpponentScaling = 1.0;
            ShowInTaskbar = _config.ShowInTaskbar;
            if (_config.VisibleOverlay)
            {
                Background = (SolidColorBrush) new BrushConverter().ConvertFrom("#4C0000FF");
            }
            _offsetX = _config.OffsetX;
            _offsetY = _config.OffsetY;
            _customWidth = _config.CustomWidth;
            _customHeight = _config.CustomHeight;

            _cardLabels = new List<HearthstoneTextBlock>
                {
                    LblCard0,
                    LblCard1,
                    LblCard2,
                    LblCard3,
                    LblCard4,
                    LblCard5,
                    LblCard6,
                    LblCard7,
                    LblCard8,
                    LblCard9,
                };
            _cardMarkLabels = new List<HearthstoneTextBlock>
                {
                    LblCardMark0,
                    LblCardMark1,
                    LblCardMark2,
                    LblCardMark3,
                    LblCardMark4,
                    LblCardMark5,
                    LblCardMark6,
                    LblCardMark7,
                    LblCardMark8,
                    LblCardMark9,
                };
            _stackPanelsMarks = new List<StackPanel>
                {
                    Marks0,
                    Marks1,
                    Marks2,
                    Marks3,
                    Marks4,
                    Marks5,
                    Marks6,
                    Marks7,
                    Marks8,
                    Marks9,
                };

            UpdateScaling();
        }
		public MainWindow()
		{
			InitializeComponent();

			var version = Helper.CheckForUpdates(out _newVersion);
			if (version != null)
			{
				TxtblockVersion.Text = string.Format("Version: {0}.{1}.{2}", version.Major, version.Minor,
													 version.Build);
			}

			#region load config
			_config = new Config();
			_xmlManagerConfig = new XmlManager<Config> { Type = typeof(Config) };

			bool foundConfig = false;
			try
			{
				if (File.Exists("config.xml"))
				{
					_config = _xmlManagerConfig.Load("config.xml");
					foundConfig = true;
				}
				else if (File.Exists(_config.AppDataPath + @"\config.xml"))
				{
					_config = _xmlManagerConfig.Load(_config.AppDataPath + @"\config.xml");
					foundConfig = true;
				}
				else if (!Directory.Exists(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)))

				//save locally if appdata doesn't exist (when e.g. not on C)
				{
					_config.SaveInAppData = false;
				}

			}
			catch (Exception e)
			{
				MessageBox.Show(
					e.Message + "\n\n" + e.InnerException +
					"\n\n If you don't know how to fix this, please delete " + _config.ConfigPath,
					"Error loading config.xml");
				Application.Current.Shutdown();
			}
			_configPath = _config.ConfigPath;
			if (!foundConfig)
			{
				if (_config.HomeDir != string.Empty)
					Directory.CreateDirectory(_config.HomeDir);
				using (var sr = new StreamWriter(_config.ConfigPath, false))
				{
					sr.WriteLine("<Config></Config>");
				}
			}
			else
			{
				//check if config needs to be moved
				if (_config.SaveInAppData)
				{
					if (File.Exists("config.xml"))
					{
						Directory.CreateDirectory(_config.HomeDir);
						if (File.Exists(_config.ConfigPath))
						{
							//backup in case the file already exists
							File.Move(_configPath, _configPath + DateTime.Now.ToFileTime());
						}
						File.Move("config.xml", _config.ConfigPath);
						Logger.WriteLine("Moved config to appdata");
					}
				}
				else
				{
					if (File.Exists(_config.AppDataPath + @"\config.xml"))
					{
						if (File.Exists(_config.ConfigPath))
						{
							//backup in case the file already exists
							File.Move(_configPath, _configPath + DateTime.Now.ToFileTime());
						}
						File.Move(_config.AppDataPath + @"\config.xml", _config.ConfigPath);
						Logger.WriteLine("Moved config to local");
					}
				}
			}
			#endregion

			if (_config.SelectedTags.Count == 0)
				_config.SelectedTags.Add("All");

			_config.Debug = IS_DEBUG;

			if (_config.GenerateLog)
			{
				Directory.CreateDirectory("Logs");
				var listener = new TextWriterTraceListener(_config.LogFilePath);
				Trace.Listeners.Add(listener);
				Trace.AutoFlush = true;
			}

			#region find hearthstone dir
			if (string.IsNullOrEmpty(_config.HearthstoneDirectory) || !File.Exists(_config.HearthstoneDirectory + @"\Hearthstone.exe"))
			{
				using (var hsDirKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Hearthstone"))
				{
					if (hsDirKey != null)
					{
						var hsDir = (string)hsDirKey.GetValue("InstallLocation");

						//verify the installlocation actually is correct (possibly moved?)
						if (File.Exists(hsDir + @"\Hearthstone.exe"))
						{
							_config.HearthstoneDirectory = hsDir;
							WriteConfig();
							_foundHsDirectory = true;
						}
					}
				}
			}
			else
			{
				_foundHsDirectory = true;
			}

			if (_foundHsDirectory)
			{

				//check for log config and create if not existing
				try
				{
					//always overwrite is true by default. 
					if (!File.Exists(_logConfigPath))
					{
						_updatedLogConfig = true;
						File.Copy("Files/log.config", _logConfigPath, true);
						Logger.WriteLine(string.Format("Copied log.config to {0} (did not exist)", _configPath));
					}
					else
					{
						//update log.config if newer
						var localFile = new FileInfo(_logConfigPath);
						var file = new FileInfo("Files/log.config");
						if (file.LastWriteTime > localFile.LastWriteTime)
						{
							_updatedLogConfig = true;
							File.Copy("Files/log.config", _logConfigPath, true);
							Logger.WriteLine(string.Format("Copied log.config to {0} (file newer)", _configPath));
						}
						else if (_config.AlwaysOverwriteLogConfig)
						{
							File.Copy("Files/log.config", _logConfigPath, true);
							Logger.WriteLine(string.Format("Copied log.config to {0} (AlwaysOverwriteLogConfig)", _configPath));
						}
					}
				}
				catch (Exception e)
				{
					if (_updatedLogConfig)
					{
						MessageBox.Show(
							e.Message + "\n\n" + e.InnerException +
							"\n\n Please manually copy the log.config from the Files directory to \"%LocalAppData%/Blizzard/Hearthstone\".",
							"Error writing log.config");
						Application.Current.Shutdown();
					}
				}
			}
			#endregion

			string languageTag = _config.SelectedLanguage;
			//hearthstone, loads db etc - needs to be loaded before playerdecks, since cards are only saved as ids now
			_game = Helper.LanguageDict.ContainsValue(languageTag) ? new Game(languageTag) : new Game("enUS");
			_game.Reset();

			#region playerdecks
			_decksPath = _config.HomeDir + "PlayerDecks.xml";

			if (_config.SaveInAppData)
			{
				if (File.Exists("PlayerDecks.xml"))
				{
					if (File.Exists(_decksPath))
					{
						//backup in case the file already exists
						File.Move(_decksPath, _decksPath + DateTime.Now.ToFileTime());
					}
					File.Move("PlayerDecks.xml", _decksPath);
					Logger.WriteLine("Moved decks to appdata");
				}
			}
			else
			{
				var appDataPath = _config.AppDataPath + @"\PlayerDecks.xml";
				if (File.Exists(appDataPath))
				{
					if (File.Exists(_decksPath))
					{
						//backup in case the file already exists
						File.Move(_decksPath, _decksPath + DateTime.Now.ToFileTime());
					}
					File.Move(appDataPath, _decksPath);
					Logger.WriteLine("Moved decks to local");
				}
			}

			//load saved decks
			if (!File.Exists(_decksPath))
			{
				//avoid overwriting decks file with new releases.
				using (var sr = new StreamWriter(_decksPath, false))
				{
					sr.WriteLine("<Decks></Decks>");
				}
			}
			else
			{
				//the new playerdecks.xml wont work with versions below 0.2.19, make copy
				if (!File.Exists(_decksPath + ".old"))
				{
					File.Copy(_decksPath, _decksPath + ".old");
				}
			}

			_xmlManager = new XmlManager<Decks> { Type = typeof(Decks) };
			try
			{
				_deckList = _xmlManager.Load(_decksPath);
			}
			catch (Exception e)
			{
				MessageBox.Show(
					e.Message + "\n\n" + e.InnerException +
					"\n\n If you don't know how to fix this, please delete " + _decksPath + " (this will cause you to lose your decks).",
					"Error loading PlayerDecks.xml");
				Application.Current.Shutdown();
			}
			#endregion

			foreach (var deck in _deckList.DecksList)
			{
				DeckPickerList.AddDeck(deck);
			}
			DeckPickerList.SelectedDeckChanged += DeckPickerListOnSelectedDeckChanged;

			_notifyIcon = new System.Windows.Forms.NotifyIcon();
			_notifyIcon.Icon = new Icon(@"Images/HearthstoneDeckTracker.ico");
			_notifyIcon.MouseDoubleClick += NotifyIconOnMouseDoubleClick;
			_notifyIcon.Visible = false;

			_xmlManagerDeck = new XmlManager<Deck>();
			_xmlManagerDeck.Type = typeof(Deck);

			_newDeck = new Deck();
			ListViewNewDeck.ItemsSource = _newDeck.Cards;


			//create overlay
			_overlay = new OverlayWindow(_config, _game) { Topmost = true };
			if (_foundHsDirectory)
			{
				_overlay.Show();
			}
			_playerWindow = new PlayerWindow(_config, _game.IsUsingPremade ? _game.PlayerDeck : _game.PlayerDrawn);
			_opponentWindow = new OpponentWindow(_config, _game.OpponentCards);
			_timerWindow = new TimerWindow(_config);

			if (_config.WindowsOnStartup)
			{
				_playerWindow.Show();
				_opponentWindow.Show();
			}
			if (_config.TimerWindowOnStartup)
			{
				_timerWindow.Show();
			}
			if (!_deckList.AllTags.Contains("All"))
			{
				_deckList.AllTags.Add("All");
				WriteDecks();
			}
			if (!_deckList.AllTags.Contains("Arena"))
			{
				_deckList.AllTags.Add("Arena");
				WriteDecks();
			}
			if (!_deckList.AllTags.Contains("Constructed"))
			{
				_deckList.AllTags.Add("Constructed");
				WriteDecks();
			}

			ComboboxAccent.ItemsSource = ThemeManager.Accents;
			ComboboxTheme.ItemsSource = ThemeManager.AppThemes;
			ComboboxLanguages.ItemsSource = Helper.LanguageDict.Keys;

			ComboboxKeyPressGameStart.ItemsSource = EventKeys.Split(',');
			ComboboxKeyPressGameEnd.ItemsSource = EventKeys.Split(',');

			LoadConfig();

			_deckImporter = new DeckImporter(_game);
			_deckExporter = new DeckExporter(_config);

			//this has to happen before reader starts
			var lastDeck = _deckList.DecksList.FirstOrDefault(d => d.Name == _config.LastDeck);
			DeckPickerList.SelectDeck(lastDeck);

			//deck options flyout button events
			DeckOptionsFlyout.BtnDeleteDeck.Click += DeckOptionsFlyoutBtnDeleteDeck_Click;
			DeckOptionsFlyout.BtnExportHs.Click += DeckOptionsFlyoutBtnExportHs_Click;
			DeckOptionsFlyout.BtnNotes.Click += DeckOptionsFlyoutBtnNotes_Click;
			DeckOptionsFlyout.BtnScreenshot.Click += DeckOptionsFlyoutBtnScreenhot_Click;
			DeckOptionsFlyout.BtnCloneDeck.Click += DeckOptionsFlyoutCloneDeck_Click;
			DeckOptionsFlyout.BtnTags.Click += DeckOptionsFlyoutBtnTags_Click;
			DeckOptionsFlyout.BtnSaveToFile.Click += DeckOptionsFlyoutBtnSaveToFile_Click;
			DeckOptionsFlyout.BtnClipboard.Click += DeckOptionsFlyoutBtnClipboard_Click;

			DeckOptionsFlyout.DeckOptionsButtonClicked += CloseDeckOptionsFlyout;

			//deck import flyout button events
			DeckImportFlyout.BtnWeb.Click += DeckImportFlyoutBtnWebClick;
			DeckImportFlyout.BtnArenavalue.Click += DeckImportFlyoutBtnArenavalue_Click;
			DeckImportFlyout.BtnFile.Click += DeckImportFlyoutBtnFile_Click;
			DeckImportFlyout.BtnIdString.Click += DeckImportFlyoutBtnIdString_Click;

			DeckImportFlyout.DeckOptionsButtonClicked += CloseDeckImportFlyout;

			//log reader
			_logReader = new HsLogReader(_config.HearthstoneDirectory, _config.UpdateDelay);
			_logReader.CardMovement += LogReaderOnCardMovement;
			_logReader.GameStateChange += LogReaderOnGameStateChange;
			_logReader.Analyzing += LogReaderOnAnalyzing;
			_logReader.TurnStart += LogReaderOnTurnStart;
			_logReader.CardPosChange += LogReaderOnCardPosChange;
			_logReader.SecretPlayed += LogReaderOnSecretPlayed;

			_turnTimer = new TurnTimer(90);
			_turnTimer.TimerTick += TurnTimerOnTimerTick;

			TagControlFilter.HideStuffToCreateNewTag();
			TagControlNewDeck.OperationSwitch.Visibility = Visibility.Collapsed;
			TagControlMyDecks.OperationSwitch.Visibility = Visibility.Collapsed;

			TagControlNewDeck.NewTag += TagControlOnNewTag;
			TagControlNewDeck.SelectedTagsChanged += TagControlOnSelectedTagsChanged;
			TagControlNewDeck.DeleteTag += TagControlOnDeleteTag;
			TagControlMyDecks.NewTag += TagControlOnNewTag;
			TagControlMyDecks.SelectedTagsChanged += TagControlOnSelectedTagsChanged;
			TagControlMyDecks.DeleteTag += TagControlOnDeleteTag;
			TagControlFilter.SelectedTagsChanged += TagControlFilterOnSelectedTagsChanged;
			TagControlFilter.OperationChanged += TagControlFilterOnOperationChanged;


			UpdateDbListView();

			_doUpdate = _foundHsDirectory;
			UpdateOverlayAsync();

			_initialized = true;

			DeckPickerList.UpdateList();
			if (lastDeck != null)
			{
				DeckPickerList.SelectDeck(lastDeck);
				UpdateDeckList(lastDeck);
				UseDeck(lastDeck);
			}

			if (_foundHsDirectory)
			{
				_logReader.Start();
			}

			Helper.SortCardCollection(ListViewDeck.Items, _config.CardSortingClassFirst);

		}
 public DeckImporter(Game game)
 {
     _game = game;
 }