Exemplo n.º 1
0
        // update favorites toggle
        public static void FavoriteToggle(int Id)
        {
            using (var romaContext = new MyDbContext())
            {
                Game rom = (from r in romaContext.Game
                            where r.gameId == Id
                            select r).SingleOrDefault();

                if (rom != null)
                {
                    if (GetFavoriteStatus(Id) == 1)
                    {
                        // Rom is marked as a favorite - make isFavorite as false
                        rom.isFavorite = false;
                    }
                    else
                    {
                        // rom is not marked as favorite - make isFavorite true
                        rom.isFavorite = true;
                    }
                }

                // update ROM
                UpdateRom(rom);
                GameListBuilder.UpdateFlag();
                romaContext.Dispose();
            }
        }
Exemplo n.º 2
0
        // mark single game as hidden
        public void MarkRomAsHidden(int gameId)
        {
            Game game = (from g in Games
                         where g.gameId == gameId
                         select g).ToList().SingleOrDefault();

            if (game == null)
            {
                // no game found
            }
            else
            {
                Game newGame = game;
                if (newGame.hidden == false)
                {
                    newGame.hidden = true;
                    // add to GamesToUpdate to be processed later
                    RomsToUpdate.Add(newGame);
                    HiddenStats++;
                    GameListBuilder.UpdateFlag();
                }
                else
                {
                    // game is already hidden
                    UntouchedStats++;
                }
            }
        }
Exemplo n.º 3
0
        // mark all ROMS from a system as hidden (as long as it is not a disk based game)
        public void MarkAllRomsAsHidden(int systemId)
        {
            List <Game> gamesAll = (from g in Games
                                    where g.systemId == systemId
                                    select g).ToList();
            List <Game> games = (from g in gamesAll
                                 where g.isDiskBased == false
                                 select g).ToList();

            if (games == null)
            {
                // no games found
            }
            else
            {
                // iterate through each game
                foreach (Game game in games)
                {
                    Game newGame = game;
                    if (newGame.hidden == false)
                    {
                        newGame.hidden = true;
                        // add to GamesToUpdate to be processed later
                        RomsToUpdate.Add(newGame);
                        HiddenStats++;
                        GameListBuilder.UpdateFlag();
                    }
                    else
                    {
                        // game is already marked as hidden
                        UntouchedStats++;
                    }
                }
            }
        }
Exemplo n.º 4
0
        // update game data for games datagrid including search
        public static void GetGames(DataGrid datagrid, int systemId, string search)
        {
            // get the full dataset from application
            App _App = ((App)Application.Current);
            //List<DataGridGamesView> allGames = _App.GamesList.AllGames;

            var result = GameListBuilder.Filter(systemId, search);
        }
Exemplo n.º 5
0
        public LayoutBuilder(GameListBuilder gameListBuilder, TitleFactory titleFactory, LayoutFactory layoutFactory)
        {
            _gameListBuilder = gameListBuilder;
            _titleFactory    = titleFactory;
            _layoutFactory   = layoutFactory;

            var tempPath = Path.GetTempPath();

            _tempDirectory = Directory.CreateDirectory(Path.Combine(tempPath, "Mamesaver", "Layouts"));
            _artPaths      = new Lazy <List <string> >(() => _gameListBuilder.GetArtPaths());
        }
Exemplo n.º 6
0
        public GameListViewModel(
            GameList gameList,
            GameListBuilder gameListBuilder,
            GameListStore gameListStore)
        {
            _gameList        = gameList;
            _gameListBuilder = gameListBuilder;
            _gameListStore   = gameListStore;

            _games         = new List <GameViewModel>();
            _filteredGames = new List <GameViewModel>();
        }
Exemplo n.º 7
0
        // remove ALL GAMES from db for all systems
        public static void RemoveAllGames()
        {
            MessageBoxResult result = MessageBox.Show("This operation will wipe out ALL the games in your games library database (but they will not be deleted from disk)\n\nAre you sure you wish to continue?", "WARNING", MessageBoxButton.OKCancel, MessageBoxImage.Warning);

            if (result == MessageBoxResult.OK)
            {
                // get all roms for specific system
                using (var context = new MyDbContext())
                {
                    List <Game> roms = (from a in context.Game
                                        select a).ToList();
                    Game.DeleteGames(roms);
                    GameListBuilder.UpdateFlag();
                }
            }
        }
Exemplo n.º 8
0
        // attempt to add game to Game database
        public static int AddGame(Rom systemRom, string fullPath, string relPath, string fileName, string extension, string romName)
        {
            // check whether ROM already exists in database
            using (var romContext = new MyDbContext())
            {
                var rom = (from r in romContext.Game
                           where (r.gameName == romName) && (r.systemId == systemRom.gameSystem.systemId)
                           select r).SingleOrDefault();

                if (rom != null)
                {
                    // Rom already exists in database. Check whether it needs updating
                    if (rom.gamePath == relPath)
                    {
                        // path is correct in database - skip updating
                        return(0);
                    }
                    else
                    {
                        // path is incorrect in database - update record
                        Game g = rom;
                        g.gamePath = relPath;

                        UpdateRom(g);
                        GameListBuilder.UpdateFlag();
                        return(2);
                    }
                }
                else
                {
                    // Rom does not exist. Add to database.
                    Game g = new Game();
                    g.gameName = romName;
                    g.gamePath = relPath;
                    g.systemId = systemRom.gameSystem.systemId;
                    //g.GameSystem.systemId = systemRom.gameSystem.systemId;
                    g.isFavorite = false;
                    g.configId   = 1;
                    g.hidden     = false;

                    InsertRom(g);
                    GameListBuilder.UpdateFlag();
                    return(1);
                }
            }
        }
Exemplo n.º 9
0
        // remove all disk-based games from db for a certain system
        public static void RemoveDisks(int sysId)
        {
            MessageBoxResult result = MessageBox.Show("This operation will wipe out ALL the " + GSystem.GetSystemName(sysId) + " games in your library database (but they will not be deleted from disk)\n\nAre you sure you wish to continue?", "WARNING", MessageBoxButton.OKCancel, MessageBoxImage.Warning);

            if (result == MessageBoxResult.OK)
            {
                // get all disks for specific system
                using (var context = new MyDbContext())
                {
                    List <Game> disks = (from a in context.Game
                                         where a.systemId == sysId
                                         select a).ToList();
                    Game.DeleteGames(disks);
                    GameListBuilder.UpdateFlag();
                }
            }
        }
Exemplo n.º 10
0
        public static void UnlinkGameData(DataGrid dgGameList)
        {
            // get selected row
            var row = (DataGridGamesView)dgGameList.SelectedItem;

            if (dgGameList.SelectedItem == null)
            {
                // game is not selected
                return;
            }
            int GameId = row.ID;

            Game.SetGdbId(GameId, 0);

            GameListBuilder.UpdateFlag();
            GamesLibraryVisualHandler.UpdateSidebar(GameId);
        }
Exemplo n.º 11
0
        public void BeginManualImport(int sysId)
        {
            // Start manual import process for a game based on sysId
            DiskGameFile gameFile = SelectGameFile(sysId);

            if (gameFile == null)
            {
                MessageBox.Show("No valid file was selected", "MedLaunch: Error");
                return;
            }
            else
            {
                // Add or update the returned GameFile to the database
                InsertOrUpdateDisk(gameFile, sysId);
                SaveToDatabase();
                MessageBox.Show("Game: " + gameFile.FileName + " has added to (or updated in) the library", "MedLaunch: Import or Update Completed");
                GameListBuilder.UpdateFlag();
            }
        }
Exemplo n.º 12
0
        // Start ROM scan and import process for specific system
        public void BeginRomImport(int systemId, ProgressDialogController dialog)
        {
            // get path to ROM folder
            string romFolderPath = GetPath(systemId);
            //MessageBoxResult result2 = MessageBox.Show(romFolderPath);
            // get allowed file types for this particular system
            HashSet <string> exts = GetAllowedFileExtensions(systemId);

            // get a list of games for this system currently already in the database
            List <Game> presentGames = (from g in Games
                                        where g.systemId == systemId
                                        select g).ToList();


            // get all files from romfolderpath and sub directories that have an allowed extension
            IEnumerable <string> romFiles = GetFiles(romFolderPath, true);

            // if romfiles is null break
            if (romFiles == null)
            {
                return;
            }

            List <string> allowedFiles = new List <string>();

            foreach (string s in exts)
            {
                foreach (string p in romFiles)
                {
                    if (p.EndsWith(s))
                    {
                        //MessageBoxResult result5 = MessageBox.Show(p);
                        allowedFiles.Add(p);
                    }
                }

                /*
                 * List<string> fi = (from a in romFiles
                 *       where a.EndsWith(s)
                 *       select a).ToList();
                 * if (fi == null || fi.Count < 1) { continue; }
                 * allowedFiles.AddRange(fi);
                 */
            }

            // calculate the number of files to be processed
            int numFiles = allowedFiles.Count;
            // set the progress bar limits
            //dialog.Minimum = 0;
            //dialog.Maximum = numFiles;
            int progress = 0;
            // set base dialog message
            string strBase = "Scanning: ";


            // create new final list to be populated with approved files
            List <Game> finalGames = new List <Game>();



            // now we have a list of allowed files, loop through them
            foreach (string file in allowedFiles)
            {
                // get the relative path
                string relPath = PathUtil.GetRelativePath(romFolderPath, file);
                // get just the filename
                string fileName = System.IO.Path.GetFileName(file);
                // get just the extension
                string extension = System.IO.Path.GetExtension(file).ToLower();
                // get rom name wihout extension
                string romName = fileName.Replace(extension, "");

                // update UI
                progress++;
                string uiUpdate = strBase + fileName + "\n(" + progress + " of " + numFiles + ")";
                dialog.SetMessage(uiUpdate);
                //dialog.SetProgress(progress);

                Game   newGame = new Game();
                string hash    = String.Empty;

                // inspect archive files
                if (extension == ".zip" || extension == ".7z")
                {
                    bool isAllowed = false;
                    try
                    {
                        Archiving arch = new Archiving(file, systemId);
                        arch.ProcessArchive();
                        hash      = arch.MD5Hash;
                        isAllowed = arch.IsAllowed;
                        if (hash == null)
                        {
                            continue;
                        }
                    }
                    catch (System.IO.InvalidDataException ex)
                    {
                        // problem with the archive file
                    }
                    finally { }

                    if (isAllowed == false)
                    {
                        continue;
                    }
                }
                else
                {
                    // file is not an archive - calculate md5
                    //hash = Crypto.Crc32.ComputeFileHash(file);
                    hash = Crypto.checkMD5(file);
                }


                // check whether game already exists (by gameName and systemId)
                Game chkGame = (from g in Games
                                where g.systemId == systemId && g.gameName == romName
                                select g).FirstOrDefault();

                // lookup game in master dat
                //var sysFilter = DAT.Where(p => p.SystemId == systemId);
                // var lookup = DAT.Where(p => p.Roms.Any(x => x.MD5.ToUpper().Trim() == hash.ToUpper().Trim())).ToList();

                //var lookup = DAT.Where(p => p.Roms.Any(x => x.MD5.ToUpper() == hash)).ToList();
                string          nHash  = hash.ToUpper().Trim().ToString();
                List <DATMerge> lookup = (from i in DAT
                                          where i.SystemId == systemId && i.Roms.Any(l => l.MD5.ToUpper().Trim() == hash)
                                          select i).ToList();

                if (chkGame == null)
                {
                    // does not already exist - create new game
                    newGame.configId = 1;

                    if (lookup != null && lookup.Count > 0)
                    {
                        newGame.gameNameFromDAT = lookup.First().GameName;
                        newGame.Publisher       = lookup.First().Publisher;
                        newGame.Year            = lookup.First().Year;

                        // get rom we are interested in
                        var rom = (from ro in lookup.First().Roms
                                   where ro.MD5.ToUpper().Trim() == hash.ToUpper().Trim()
                                   select ro).First();
                        newGame.romNameFromDAT    = rom.RomName;
                        newGame.Copyright         = rom.Copyright;
                        newGame.Country           = rom.Country;
                        newGame.DevelopmentStatus = rom.DevelopmentStatus;
                        newGame.Language          = rom.Language;
                        newGame.OtherFlags        = rom.OtherFlags;

                        if (rom.Year != null && rom.Year != "")
                        {
                            newGame.Year = rom.Year;
                        }
                        if (rom.Publisher != null && rom.Publisher != "")
                        {
                            newGame.Publisher = rom.Publisher;
                        }
                    }

                    newGame.gameName    = romName;
                    newGame.gamePath    = relPath;
                    newGame.hidden      = false;
                    newGame.isDiskBased = false;
                    newGame.isFavorite  = false;
                    newGame.systemId    = systemId;
                    newGame.CRC32       = hash;

                    // add to finaGames list
                    RomsToAdd.Add(newGame);
                    // increment the added counter
                    AddedStats++;
                }
                else
                {
                    // matching game found - update it
                    if (chkGame.gamePath == relPath && chkGame.hidden == false && chkGame.CRC32 == hash)
                    {
                        //nothing to update - increment untouched counter
                        UntouchedStats++;
                    }
                    else
                    {
                        newGame = chkGame;
                        // update path in case it has changed location
                        newGame.gamePath = relPath;
                        // mark as not hidden
                        newGame.hidden = false;

                        newGame.CRC32 = hash;
                        if (lookup != null && lookup.Count > 0)
                        {
                            newGame.gameNameFromDAT = lookup.First().GameName;
                            newGame.Publisher       = lookup.First().Publisher;
                            newGame.Year            = lookup.First().Year;

                            // get rom we are interested in
                            var rom = (from ro in lookup.First().Roms
                                       where ro.MD5.ToUpper().Trim() == hash.ToUpper().Trim()
                                       select ro).First();
                            newGame.romNameFromDAT    = rom.RomName;
                            newGame.Copyright         = rom.Copyright;
                            newGame.Country           = rom.Country;
                            newGame.DevelopmentStatus = rom.DevelopmentStatus;
                            newGame.Language          = rom.Language;
                            newGame.OtherFlags        = rom.OtherFlags;

                            if (rom.Year != null && rom.Year != "")
                            {
                                newGame.Year = rom.Year;
                            }
                            if (rom.Publisher != null && rom.Publisher != "")
                            {
                                newGame.Publisher = rom.Publisher;
                            }
                        }

                        // add to finalGames list
                        RomsToUpdate.Add(newGame);
                        // increment updated counter
                        UpdatedStats++;
                    }

                    // remove game from presentGames list - remaining games in this list will be marked as hidden at the end
                    presentGames.Remove(chkGame);
                }
            }

            // whatever games are left in the presentGames list should be marked as hidden as they have not been found
            if (presentGames.Count > 0)
            {
                foreach (Game g in presentGames)
                {
                    g.hidden = true;
                    RomsToUpdate.Add(g);
                }
            }

            GameListBuilder.UpdateFlag();
        }
Exemplo n.º 13
0
        public void InsertOrUpdateDisk(DiskGameFile f, int sysId)
        {
            // check whether game already exists (by gameName and systemId)
            Game chkGame = (from g in Games
                            where g.systemId == sysId && g.gameName == f.GameName
                            select g).SingleOrDefault();

            // create new Game object for import
            Game newGame = new Game();

            string hash = string.Empty;

            // calculate MD5 checksum hashes
            if (f.Extension.Contains("m3u"))
            {
                // this is an m3u playlist - inspect and get relevant cue files
                string[] lines = File.ReadAllLines(f.FullPath);

                if (lines.Length > 0)
                {
                    // get hash for first cue/toc/ccd
                    hash = Crypto.checkMD5(f.FolderPath + "\\" + lines[0]);
                }
            }
            else
            {
                hash = Crypto.checkMD5(f.FullPath);
            }



            // lookup md5 in master DAT
            List <DATMerge> lookup = (from i in DAT
                                      where i.SystemId == sysId && i.Roms.Any(l => l.MD5.ToUpper().Trim() == hash)
                                      select i).ToList();

            if (chkGame == null)
            {
                // does not already exist - create new game
                newGame.configId    = 1;
                newGame.gameName    = f.GameName;
                newGame.gamePath    = f.FullPath;
                newGame.hidden      = false;
                newGame.isDiskBased = true;
                newGame.isFavorite  = false;
                newGame.systemId    = sysId;

                if (lookup != null && lookup.Count > 0)
                {
                    newGame.gameNameFromDAT = lookup.First().GameName;
                    newGame.Publisher       = lookup.First().Publisher;
                    newGame.Year            = lookup.First().Year;

                    // get rom we are interested in
                    var rom = (from ro in lookup.First().Roms
                               where ro.MD5.ToUpper().Trim() == hash.ToUpper().Trim()
                               select ro).First();
                    newGame.romNameFromDAT    = rom.RomName;
                    newGame.Copyright         = rom.Copyright;
                    newGame.Country           = rom.Country;
                    newGame.DevelopmentStatus = rom.DevelopmentStatus;
                    newGame.Language          = rom.Language;
                    newGame.OtherFlags        = rom.OtherFlags;

                    if (rom.Year != null && rom.Year != "")
                    {
                        newGame.Year = rom.Year;
                    }
                    if (rom.Publisher != null && rom.Publisher != "")
                    {
                        newGame.Publisher = rom.Publisher;
                    }
                }

                // add to finaGames list
                DisksToAdd.Add(newGame);
                // increment the added counter
                AddedStats++;
                GameListBuilder.UpdateFlag();
            }
            else
            {
                // matching game found - update it
                if ((chkGame.gamePath == f.FullPath || chkGame.gamePath == f.FullPath) && chkGame.hidden == false)
                {
                    //nothing to update - Path is either identical either absoultely or relatively (against the systemPath set in the database)
                    UntouchedStats++;
                }
                else
                {
                    newGame = chkGame;
                    // update path in case it has changed location
                    newGame.gamePath = f.FullPath;
                    // mark as not hidden
                    newGame.hidden      = false;
                    newGame.isDiskBased = true;

                    if (lookup != null && lookup.Count > 0)
                    {
                        newGame.gameNameFromDAT = lookup.First().GameName;
                        newGame.Publisher       = lookup.First().Publisher;
                        newGame.Year            = lookup.First().Year;

                        // get rom we are interested in
                        var rom = (from ro in lookup.First().Roms
                                   where ro.MD5.ToUpper().Trim() == hash.ToUpper().Trim()
                                   select ro).First();
                        newGame.romNameFromDAT    = rom.RomName;
                        newGame.Copyright         = rom.Copyright;
                        newGame.Country           = rom.Country;
                        newGame.DevelopmentStatus = rom.DevelopmentStatus;
                        newGame.Language          = rom.Language;
                        newGame.OtherFlags        = rom.OtherFlags;

                        if (rom.Year != null && rom.Year != "")
                        {
                            newGame.Year = rom.Year;
                        }
                        if (rom.Publisher != null && rom.Publisher != "")
                        {
                            newGame.Publisher = rom.Publisher;
                        }
                    }

                    // add to finalGames list
                    DisksToUpdate.Add(newGame);
                    // increment updated counter
                    UpdatedStats++;
                    GameListBuilder.UpdateFlag();
                }
            }
        }
Exemplo n.º 14
0
        private void ApplicationStart(object sender, StartupEventArgs e)
        {
            // unhandled exception events
            AppDomain.CurrentDomain.UnhandledException +=
                (s, exception) =>
                LogUnhandledException((Exception)exception.ExceptionObject, "AppDomain.CurrentDomain.UnhandledException");

            DispatcherUnhandledException +=
                (s, exception) =>
                LogUnhandledException(exception.Exception, "Application.Current.DispatcherUnhandledException");

            TaskScheduler.UnobservedTaskException +=
                (s, exception) =>
                LogUnhandledException(exception.Exception, "TaskScheduler.UnobservedException");



            var splashScreen = new SplashScreen(@"Data\Graphics\mediconsplash-new.png");

            splashScreen.Show(false);
            Current.ShutdownMode = ShutdownMode.OnExplicitShutdown;
            // show the initialisation window and begin checks
            ShowInitWindow();
            Thread.Sleep(1000);
            // init should have completed - run MainWindow

            // instantiate GamesList object
            GamesList = new GameListBuilder();

            MainWindow mw = new MedLaunch.MainWindow();

            Current.ShutdownMode           = ShutdownMode.OnMainWindowClose;
            Application.Current.MainWindow = mw;



            mw.Show();

            // instantiate GamesList object
            //GamesList = new GameListBuilder();



            splashScreen.Close(TimeSpan.FromSeconds(1));

            // instantiate ScrapedContent Object
            ScrapedData = new GamesLibraryScrapedContent();



            // set color scheme from database
            Tuple <AppTheme, Accent> appStyle = ThemeManager.DetectAppStyle(Application.Current);

            if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + @"Data\Settings\MedLaunch.db"))
            {
                // database already exists
                var gs = GlobalSettings.GetGlobals();
                ThemeManager.ChangeAppStyle(Application.Current,
                                            ThemeManager.GetAccent(gs.colorAccent),
                                            ThemeManager.GetAppTheme(gs.colorBackground));
            }
            else
            {
                // database hasnt been generated yet - set default
                ThemeManager.ChangeAppStyle(Application.Current,
                                            ThemeManager.GetAccent("Emerald"),
                                            ThemeManager.GetAppTheme("BaseDark"));
            }
        }
Exemplo n.º 15
0
        /* Methods */

        public async static void ScrapeGamesMultiple(List <DataGridGamesView> list, ScrapeType scrapeType)
        {
            // instantiate instance of this class
            ScraperMainSearch gs = new ScraperMainSearch();

            // get mainwindow
            MainWindow MWindow = Application.Current.Windows.OfType <MainWindow>().FirstOrDefault();

            // popup progress dialog
            var mySettings = new MetroDialogSettings()
            {
                NegativeButtonText = "Cancel Scraping",
                AnimateShow        = false,
                AnimateHide        = false
            };
            var controller = await MWindow.ShowProgressAsync("Scraping Data", "Initialising...", true, settings : mySettings);

            controller.SetCancelable(true);
            await Task.Delay(100);

            await Task.Run(() =>
            {
                gs.LocalGames = new List <Game>();

                // iterate through each game, look it up and pass it to gs.LocalGames
                foreach (var game in list)
                {
                    Game g = Game.GetGame(game.ID);

                    if (scrapeType == ScrapeType.Selected)
                    {
                        if (g.gdbId == null || g.gdbId == 0 || Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + @"Data\Games\" + g.gdbId.ToString()) == false)
                        {
                            // scraping can happen
                            gs.LocalGames.Add(g);
                        }
                    }

                    if (scrapeType == ScrapeType.SelectedRescrape)
                    {
                        gs.LocalGames.Add(g);
                    }
                }

                // count number of games to scan for
                int numGames       = gs.LocalGames.Count;
                controller.Minimum = 0;
                controller.Maximum = numGames;
                int i = 0;
                // iterate through each local game and attempt to match it with the master list
                foreach (var g in gs.LocalGames)
                {
                    if (controller.IsCanceled)
                    {
                        controller.CloseAsync();
                        return;
                    }
                    i++;
                    controller.SetProgress(i);
                    controller.SetMessage("Attempting local search match for:\n" + g.gameName + " (" + GSystem.GetSystemCode(g.systemId) + ")" + "\n(" + i + " of " + numGames + ")");
                    List <ScraperMaster> results = gs.SearchGameLocal(g.gameName, g.systemId, g.gameId).ToList();

                    if (results.Count == 0)
                    {
                        // no results returned
                    }
                    if (results.Count == 1)
                    {
                        // one result returned - add GdbId to the Game table
                        Game.SetGdbId(g.gameId, results.Single().GamesDbId);
                    }
                }

                /* Begin actual scraping */

                // Get all games that have a GdbId set and determine if they need scraping (is json file present for them)
                var gamesTmp  = gs.LocalGames;
                gs.LocalGames = new List <Game>();
                foreach (var g in gamesTmp)
                {
                    if (g.gdbId == null || g.gdbId == 0)
                    {
                        continue;
                    }

                    if (scrapeType == ScrapeType.SelectedRescrape)
                    {
                        gs.LocalGames.Add(g);
                        continue;
                    }

                    // check each game directory
                    if (!Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + @"Data\Games\" + g.gdbId.ToString()))
                    {
                        // directory does not exist - scraping needed
                        gs.LocalGames.Add(g);
                    }
                    else
                    {
                        // directory does exist - check whether json file is present
                        if (!File.Exists(AppDomain.CurrentDomain.BaseDirectory + @"Data\Games\" + g.gdbId.ToString() + @"\" + g.gdbId.ToString() + ".json"))
                        {
                            // json file is not present - scraping needed
                            gs.LocalGames.Add(g);
                        }
                    }
                }

                int gamesCount = gs.LocalGames.Count;
                i = 0;
                controller.Minimum = 0;
                controller.Maximum = gamesCount;
                foreach (var g in gs.LocalGames)
                {
                    if (controller.IsCanceled)
                    {
                        controller.CloseAsync();
                        return;
                    }

                    // iterate through each game that requires scraping and attempt to download the data and import to database
                    i++;
                    controller.SetProgress(i);
                    string message = "Scraping Started....\nGetting data for: " + g.gameName + " (" + GSystem.GetSystemCode(g.systemId) + ")" + "\n(" + i + " of " + gamesCount + ")\n\n";
                    controller.SetMessage(message);

                    // do actual scraping
                    ScraperHandler sh = new ScraperHandler(g.gdbId.Value, g.gameId, false);
                    sh.ScrapeGame(controller);
                    GameListBuilder.UpdateFlag();
                }
            });

            await controller.CloseAsync();

            if (controller.IsCanceled)
            {
                await MWindow.ShowMessageAsync("MedLaunch Scraper", "Scraping Cancelled");

                GamesLibraryVisualHandler.RefreshGamesLibrary();
            }
            else
            {
                await MWindow.ShowMessageAsync("MedLaunch Scraper", "Scraping Completed");

                GamesLibraryVisualHandler.RefreshGamesLibrary();
            }
        }