Example #1
5
        public void CanCheckForPathExistenceUsingNormalSlashInsteadOfBackslash()
        {
            var pathStr = @"c:\whatever;d:\omg";

            var path = new Paths(pathStr);

            path.Contains(@"c:/whatever/").Should().Be.True();
        }
Example #2
2
        public void CanCheckForPathExistenceUsingDifferentCasing()
        {
            var pathStr = @"c:\whatever;d:\omg";

            var path = new Paths(pathStr);

            path.Contains(@"C:/Whatever/").Should().Be.True();
        }
Example #3
0
 private static async Task ConvertAsync(TopicData topic, IDictionary<string, TopicData> name2topic, Paths paths, IFile destFile, CancellationToken cancellationToken)
 {
     using (var destStream = await destFile.OpenAsync(FileAccess.ReadAndWrite, cancellationToken))
     {
         await ConvertAsync(topic, destStream, name2topic, paths, cancellationToken);
     }
 }
Example #4
0
 private static async Task ConvertAsync(TopicData topic, Stream destStream, IDictionary<string, TopicData> name2topic, Paths paths, CancellationToken cancellationToken)
 {
     using (var writer = new StreamWriter(destStream))
     {
         await Writers.TopicWriter.WriteAsync(topic, name2topic, writer, paths, cancellationToken);
     }
 }
Example #5
0
        public void CanCheckForPathExistenceUsingSameTrailingSlashNormalization()
        {
            var pathStr = @"c:\whatever;d:\omg";

            var path = new Paths(pathStr);

            path.Contains(@"c:\whatever").Should().Be.True();
        }
Example #6
0
 public void AddPaths(Paths poly)
 {
     if (poly.Count == 0) return;
     PolyInfo pi = new PolyInfo();
     pi.polygons = poly;
     pi.si = style.Clone();
     PolyInfoList.Add(pi);
 }
Example #7
0
 /// <summary>
 /// Converts the topic to MAML.
 /// </summary>
 /// <param name="paths">Paths.</param>
 /// <param name="name2topic">Mapping from topic name to data.</param>
 /// <param name="cancellationToken">Cancellation token.</param>
 /// <param name="progress">Progress indicator.</param>
 /// <returns>Asynchronous task.</returns>
 public static async Task ConvertAsync(Paths paths, IDictionary<string, TopicData> name2topic,
     CancellationToken cancellationToken = default(CancellationToken), IProgress<Indicator> progress = null)
 {
     var topicsArray = name2topic.Values.ToArray();
     var count = topicsArray.Length;
     Indicator.Report(progress, count);
     for (var index = 0; index < count; index++)
         await ConvertAsync(topicsArray[index], paths, name2topic, cancellationToken, progress, index, count);
 }
Example #8
0
        public void CanFindIndividualPathItems()
        {
            var pathStr = @"c:\whatever;d:\omg";

            var path = new Paths(pathStr);

            path.Should().Have.SameSequenceAs(
                @"c:\whatever", @"d:\omg");
        }
Example #9
0
        public void CanGetPathStringFromPathList()
        {
            var path = new Paths("");
            path.Add(@"c:\a");
            path.Add(@"d:\b");
            path.Add(@"e:/C");

            path.ToString().Should().Be(@"c:\a\;d:\b\;e:\c\");
        }
Example #10
0
 /// <summary>
 /// Matches the topics to their IDs from content layout and creates a mapping from topic name to topic.
 /// </summary>
 /// <param name="topics">The topics.</param>
 /// <param name="paths">Paths.</param>
 /// <param name="title2id">Gets the topic ID from the topic title.</param>
 /// <param name="cancellationToken">Cancellation token.</param>
 /// <param name="progress">Progress indicator.</param>
 /// <returns>Matched topic mapping.</returns>
 public static async Task<Dictionary<string, TopicData>> MatchAsync(IEnumerable<TopicData> topics, Paths paths, IDictionary<string, Guid> title2id,
     CancellationToken cancellationToken = default(CancellationToken), IProgress<Indicator> progress = null)
 {
     var topicsArray = topics.ToArray();
     var count = topicsArray.Length;
     Indicator.Report(progress, count);
     var tasks = Enumerable.Range(0, count).Select(index =>
         MatchAsync(topicsArray[index], paths, title2id, cancellationToken, progress, count, index));
     topics = await Task.WhenAll(tasks);
     return topics.ToDictionary(topic => topic.Name, topic => topic);
 }
Example #11
0
        public void AddingNonNormalizedPathWillNormalizeAndAddItToList()
        {
            var pathStr = @"c:\whatever;d:\omg";

            var path = new Paths(pathStr);

            path.Add("E:/Wtf").Should().Be(@"e:\wtf\");

            path.Should().Have.SameSequenceAs(
                @"c:\whatever", @"d:\omg", @"e:\wtf\");
        }
Example #12
0
 /// <summary>
 /// Parses the topics.
 /// </summary>
 /// <param name="topics">The topics.</param>
 /// <param name="paths">Paths.</param>
 /// <param name="cancellationToken">Cancellation token.</param>
 /// <param name="progress">Progress indicator.</param>
 /// <returns>Parsed topics.</returns>
 public static async Task<IEnumerable<TopicData>> ParseAsync(IEnumerable<TopicData> topics, Paths paths,
     CancellationToken cancellationToken = default(CancellationToken), IProgress<Indicator> progress = null)
 {
     var topicsArray = topics.ToArray();
     var count = topicsArray.Length;
     Indicator.Report(progress, count);
     var tasks = Enumerable.Range(0, count).Select(index =>
         ParseAsync(topicsArray[index], paths, cancellationToken, progress, index, count));
     await Task.WhenAll(tasks);
     return topics;
 }
Example #13
0
 /// <summary>
 /// Parses the topic.
 /// </summary>
 /// <param name="topic">The topic.</param>
 /// <param name="paths">Paths.</param>
 /// <param name="cancellationToken">Cancellation token.</param>
 /// <param name="progress">Progress indicator.</param>
 /// <param name="index">Index.</param>
 /// <param name="count">Count.</param>
 /// <returns>Parsed topic.</returns>
 public static async Task<TopicParserResult> ParseAsync(TopicData topic, Paths paths, CancellationToken cancellationToken,
     IProgress<Indicator> progress = null, int index = 0, int count = 0)
 {
     var srcFilePath = Path.Combine(paths.Source, topic.RelativePath, topic.FileName);
     var file = await FileSystem.Current.GetFileFromPathAsync(srcFilePath, cancellationToken)
         .ConfigureAwait(false);
     using (var stream = await file.OpenAsync(FileAccess.Read, cancellationToken))
     using (var reader = new StreamReader(stream))
     {
         var parserResult = topic.ParserResult = TopicParser.Parse(reader);
         Indicator.Report(progress, count, index + 1, () => Path.Combine(topic.RelativePath, topic.Name));
         return parserResult;
     }
 }
Example #14
0
        /// <summary>
        /// Converts the topic to MAML.
        /// </summary>
        /// <param name="topic">Topic data.</param>
        /// <param name="paths">Paths.</param>
        /// <param name="name2topic">Mapping from topic name to data.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        /// <param name="progress">Progress indicator.</param>
        /// <param name="index">Index.</param>
        /// <param name="count">Count.</param>
        /// <returns>Asynchronous task.</returns>
        public static async Task ConvertAsync(TopicData topic, Paths paths, IDictionary<string, TopicData> name2topic,
            CancellationToken cancellationToken, IProgress<Indicator> progress = null, int index = 0, int count = 0)
        {
            var destDir = Path.Combine(paths.Destination, topic.RelativePath);
            var fileName = Path.GetFileName(topic.FileName);
            var destName = Path.ChangeExtension(fileName, ".aml");

            var destFolder = await FileSystem.Current.LocalStorage.CreateFolderAsync(destDir, CreationCollisionOption.OpenIfExists, cancellationToken);
            var destFile = await destFolder.CreateFileAsync(destName, CreationCollisionOption.ReplaceExisting, cancellationToken);

            await ConvertAsync(topic, name2topic, paths, destFile, cancellationToken);

            Indicator.Report(progress, count, index + 1, () => Path.Combine(topic.RelativePath, topic.Name));
        }
Example #15
0
        /// <summary>
        /// Initializes a new instance of maze cell with locations
        /// </summary>
        /// <param name="location">The location on the graphics surface</param>
        /// <param name="position">The location on the 2d array</param>
        public unsafe Cell(Point location, Point position)
        {
            this.location = location;
            this.position = position;

            // initially, all walls are intact
            this.LeftWall = true;
            this.RightWall = true;
            this.UpWall = true;
            this.DownWall = true;
            this.Path = Paths.None;

            // must be initialized, since it is a member of a struct
            this.Visited = false;
            this.Previous = null;
        }
Example #16
0
 /// <summary>
 /// Indexes the content layout.
 /// </summary>
 /// <param name="paths">Paths.</param>
 /// <param name="cancellationToken">Cancellation token.</param>
 /// <returns>Mapping from topic title to its ID.</returns>
 public static async Task<IDictionary<string, Guid>> IndexAsync(Paths paths, CancellationToken cancellationToken)
 {
     var title2id = new Dictionary<string, Guid>();
     var layoutPath = paths.ContentLayout;
     if (layoutPath == null)
         return title2id;
     ContentLayout layout;
     var file = await FileSystem.Current.GetFileFromPathAsync(layoutPath, cancellationToken)
         .ConfigureAwait(false);
     using (var stream = await file.OpenAsync(FileAccess.Read, cancellationToken))
     using (var reader = new StreamReader(stream))
     {
         var serializer = new XmlSerializer(typeof(ContentLayout));
         layout = (ContentLayout)serializer.Deserialize(reader);
     }
     return Index(title2id, layout.Topics);
 }
Example #17
0
 public static Paths ParsePathsFile(string[] fileLines)
 {
     Paths p = new Paths();
     foreach (string l in fileLines)
     {
         //Ignore whitspace lines
         if (l.Trim().Length == 0) continue;
         //Ignore comment lines
         if (l.Trim().StartsWith("#")) continue;
         string[] parts = l.Trim().Split('=');
         if (parts.Length < 2)
         {
             Logger.LogWarning("Ignoring " + l + " in " + PATHS_FILE);
             continue;
         }
         if (!parts[1].EndsWith("\\")) parts[1] += '\\';
         switch (parts[0].ToLower())
         {
             case "articlesdir":
                 p.ArticlesRootDir = parts[1].Trim();
                 break;
             case "virtualarticlesdir":
                 p.VirtualArticlesRootDir = parts[1].Trim();
                 break;
             case "templatesdir":
                 p.TemplatesRootDir = parts[1].Trim();
                 break;
             case "macrosdir":
                 p.MacrosRootDir = parts[1].Trim();
                 break;
             case "outputdir":
                 p.OutputRootDir = parts[1].Trim();
                 break;
             default:
                 break;
         }
     }
     return p;
 }
Example #18
0
        public Task Call(IDictionary<string, object> env)
        {
            var paths = new Paths(env);
            var path = paths.Path;
            var pathBase = paths.PathBase;
            
            var match = _map.FirstOrDefault(m => path.StartsWith(m.Item1));
            if (match == null)
            {
                // fall-through to default
                return _defaultApp(env);
            }

            // Map moves the matched portion of Path into PathBase
            paths.PathBase = pathBase + match.Item1;
            paths.Path = path.Substring(match.Item1.Length);
            return match.Item2.Invoke(env).Then(() =>
            {
                // Path and PathBase are restored as the call returns
                paths.Path = path;
                paths.PathBase = pathBase;
            });
        }
Example #19
0
 public void Call(
     IDictionary<string, object> env,
     ResultDelegate result,
     Action<Exception> fault)
 {
     var paths = new Paths(env);
     var path = paths.Path;
     var pathBase = paths.PathBase;
     Action finish = () =>
     {
         paths.Path = path;
         paths.PathBase = pathBase;
     };
     var match = _map.FirstOrDefault(m => path.StartsWith(m.Item1));
     if (match == null)
     {
         // fall-through to default
         _app(env, result, fault);
         return;
     }
     paths.PathBase = pathBase + match.Item1;
     paths.Path = path.Substring(match.Item1.Length);
     match.Item2.Invoke(env, result, fault);
 }
Example #20
0
        public Task<ResultParameters> Call(CallParameters call)
        {
            var paths = new Paths(call.Environment);
            var path = paths.Path;
            var pathBase = paths.PathBase;

            var match = _map.FirstOrDefault(m => path.StartsWith(m.Item1));
            if (match == null)
            {
                // fall-through to default
                return _app(call);
            }

            // Map moves the matched portion of Path into PathBase
            paths.PathBase = pathBase + match.Item1;
            paths.Path = path.Substring(match.Item1.Length);
            return match.Item2.Invoke(call).Then(result =>
            {
                // Path and PathBase are restored as the call returnss
                paths.Path = path;
                paths.PathBase = pathBase;
                return result;
            });
        }
Example #21
0
        public static async Task CheckAndSwapInstalledExternalPlugins()
        {
            try
            {
                if (ConfigManager.IsVersionChanged)
                {
                    string minerPluginsPath          = Paths.MinerPluginsPath();
                    var    zipPackages               = Directory.GetFiles(Paths.RootPath("plugins_packages"), "*.zip", SearchOption.TopDirectoryOnly);
                    var    installedExternalPackages = Directory.GetDirectories(minerPluginsPath);
                    foreach (var installedPath in installedExternalPackages)
                    {
                        try
                        {
                            var uuid = installedPath.Replace(minerPluginsPath, "").Trim('\\');
                            if (!System.Guid.TryParse(uuid, out var _))
                            {
                                continue;
                            }
                            var zipPackage = zipPackages.FirstOrDefault(package => package.Contains(uuid));
                            if (zipPackage == null)
                            {
                                continue;
                            }
                            // uzip to temp dir
                            var tmpPluginDir = installedPath + "_tmp";
                            Directory.CreateDirectory(tmpPluginDir);
                            await ArchiveHelpers.ExtractFileAsync(zipPackage, tmpPluginDir, null, CancellationToken.None);

                            // now copy move over files
                            var tmpPackageFiles       = Directory.GetFiles(tmpPluginDir, "*", SearchOption.AllDirectories);
                            var installedPackagePaths = Directory.GetFiles(installedPath, "*", SearchOption.AllDirectories);
                            foreach (var path in installedPackagePaths)
                            {
                                // skip if not file and skip all bins
                                if (!File.Exists(path) || path.Contains("bins"))
                                {
                                    continue;
                                }
                                var fileName = Path.GetFileName(path);
                                var moveFile = tmpPackageFiles.FirstOrDefault(file => Path.GetFileName(file) == fileName);
                                if (moveFile == null)
                                {
                                    continue;
                                }
                                try
                                {
                                    File.Copy(moveFile, path, true);
                                }
                                catch (Exception e)
                                {
                                    Logger.Error("CheckAndSwapInstalledExternalPlugins", e.Message);
                                }
                            }
                            Directory.Delete(tmpPluginDir, true);
                        }
                        catch (Exception e)
                        {
                            Logger.Error("CheckAndSwapInstalledExternalPlugins", e.Message);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Logger.Error("CheckAndSwapInstalledExternalPlugins", e.Message);
            }
        }
Example #22
0
      //------------------------------------------------------------------------------

      public bool AddPolygons(Paths ppg, PolyType polyType)
      {
        bool result = false;
        for (int i = 0; i < ppg.Count; ++i)
          if (AddPath(ppg[i], polyType, true)) result = true;
        return result;
      }
Example #23
0
        private void App_OnStartup(object sender, StartupEventArgs e)
        {
            // Set working directory to exe
            var pathSet = false;
            var path    = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            if (path != null)
            {
                Paths.SetRoot(path);
                Environment.CurrentDirectory = path;
                pathSet = true;
            }

            // Add common folder to path for launched processes
            const string pathKey = "PATH";
            var          pathVar = Environment.GetEnvironmentVariable(pathKey);

            pathVar += $";{Path.Combine(Environment.CurrentDirectory, "common")}";
            Environment.SetEnvironmentVariable(pathKey, pathVar);

            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            // Set security protocols
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol  = SecurityProtocolType.Tls |
                                                    SecurityProtocolType.Tls11 |
                                                    SecurityProtocolType.Tls12 |
                                                    SecurityProtocolType.Ssl3;

            // Initialize config
            ConfigManager.InitializeConfig();

            // Check multiple instances
            if (!ConfigManager.GeneralConfig.AllowMultipleInstances)
            {
                try
                {
                    var current = Process.GetCurrentProcess();
                    if (Process.GetProcessesByName(current.ProcessName).Any(p => p.Id != current.Id))
                    {
                        // Shutdown to exit
                        Shutdown();
                    }
                }
                catch
                { }
            }

            // Init logger
            Logger.ConfigureWithFile(ConfigManager.GeneralConfig.LogToFile, Level.Info, ConfigManager.GeneralConfig.LogMaxFileSize);

            if (ConfigManager.GeneralConfig.DebugConsole)
            {
                PInvokeHelpers.AllocConsole();
                Logger.ConfigureConsoleLogging(Level.Info);
            }

            if (!pathSet)
            {
                Logger.Warn(Tag, "Path not set to executable");
            }

            // Set to explicit shutdown or else these intro windows will cause shutdown
            ShutdownMode = ShutdownMode.OnExplicitShutdown;

            // Init ExchangeRateApi and TimeUnit
            ExchangeRateApi.ActiveDisplayCurrency = ConfigManager.GeneralConfig.DisplayCurrency;
            TimeFactor.UnitType = ConfigManager.GeneralConfig.TimeUnit;

            Logger.Info(Tag, $"Starting up {ApplicationStateManager.Title}");

            if (ConfigManager.GeneralConfig.agreedWithTOS != ApplicationStateManager.CurrentTosVer)
            {
                Logger.Info(Tag, $"TOS differs! agreed: {ConfigManager.GeneralConfig.agreedWithTOS} != Current {ApplicationStateManager.CurrentTosVer}");

                var eula = new EulaWindow
                {
                    WindowStartupLocation = WindowStartupLocation.CenterScreen
                };

                var accepted = eula.ShowDialog();

                if (accepted.HasValue && eula.AcceptedTos)
                {
                    ConfigManager.GeneralConfig.agreedWithTOS = ApplicationStateManager.CurrentTosVer;
                }
                else
                {
                    Logger.Error(Tag, "TOS differs AFTER TOS confirmation window");
                    Shutdown();
                    return;
                }
            }

            // Chose lang
            if (string.IsNullOrEmpty(ConfigManager.GeneralConfig.Language))
            {
                var langToSet = "en";
                if (Translations.GetAvailableLanguagesNames().Count > 1)
                {
                    var lang = new ChooseLanguageWindow
                    {
                        LangNames             = Translations.GetAvailableLanguagesNames(),
                        WindowStartupLocation = WindowStartupLocation.CenterScreen
                    };

                    lang.ShowDialog();

                    langToSet = Translations.GetLanguageCodeFromIndex(lang.SelectedLangIndex);
                }

                ConfigManager.GeneralConfig.Language = langToSet;
                ConfigManager.GeneralConfigFileCommit();
            }

            Translations.SelectedLanguage = ConfigManager.GeneralConfig.Language;

            // Check sys requirements
            var canRun = ApplicationStateManager.SystemRequirementsEnsured();

            if (!canRun)
            {
                Shutdown();
            }

            // Check 3rd party miners
            if (ConfigManager.GeneralConfig.Use3rdPartyMiners == Use3rdPartyMiners.NOT_SET)
            {
                var thirdPty = new _3rdPartyTosWindow
                {
                    WindowStartupLocation = WindowStartupLocation.CenterScreen
                };

                var result = thirdPty.ShowDialog();

                // Note result is a Nullable<bool>, hence the verbose if-else
                if (result == true)
                {
                    ConfigManager.GeneralConfig.Use3rdPartyMiners = Use3rdPartyMiners.YES;
                }
                else if (result == false)
                {
                    ConfigManager.GeneralConfig.Use3rdPartyMiners = Use3rdPartyMiners.NO;
                }

                ConfigManager.GeneralConfigFileCommit();
            }

            var main = new MainWindow();

            main.Show();

            // Set shutdown mode back to default
            ShutdownMode = ShutdownMode.OnLastWindowClose;
        }
Example #24
0
        public void MergeByTreeNodesAsync(
            IEnumerable <TreeNode> fileNodesToMerge,
            string mergedModName)
        {
            _bgWorker.DoWork += (sender, e) =>
            {
                _checkedFileNodes = fileNodesToMerge.ToArray();
                _mergedModName    = mergedModName;

                var checkedModNodesForFile =
                    _checkedFileNodes.Select(
                        fileNode =>
                        fileNode.GetTreeNodes().Where(
                            modNode =>
                            modNode.Checked
                            ).ToArray()
                        ).ToArray();

                ProgressInfo.TotalMergeCount = checkedModNodesForFile.Sum(modNodes => modNodes.Length - 1);
                ProgressInfo.TotalFileCount  = _checkedFileNodes.Length;

                for (int i = 0; i < _checkedFileNodes.Length; ++i)
                {
                    var fileNode = _checkedFileNodes[i];

                    ProgressInfo.CurrentFileName = Path.GetFileName(fileNode.Text);
                    ProgressInfo.CurrentFileNum  = i + 1;

                    var checkedModNodes = checkedModNodesForFile[i];

                    ProgressInfo.CurrentAction = "Starting merge";

                    if (checkedModNodes.Any(node => (new LoadOrderComparer()).Compare(node.Text, _mergedModName) < 0) &&
                        !ConfirmRemainingConflict(_mergedModName))
                    {
                        continue;
                    }

                    var isNew = false;
                    var merge = _inventory.Merges.FirstOrDefault(m => m.RelativePath.EqualsIgnoreCase(fileNode.Text));
                    if (merge == null)
                    {
                        isNew = true;
                        merge = new Merge
                        {
                            RelativePath  = fileNode.Text,
                            MergedModName = _mergedModName
                        };
                    }

                    if ((ModFileCategory)fileNode.Parent.Tag == Categories.BundleText)
                    {
                        merge.BundleName = Path.GetFileName(Paths.RetrieveMergedBundlePath());
                        MergeBundleFileNode(fileNode, checkedModNodes, merge, isNew);
                    }
                    else
                    {
                        MergeFlatFileNode(fileNode, checkedModNodes, merge, isNew);
                    }
                }
                if (_bundleChanged)
                {
                    var newBundlePath = PackNewBundle(Paths.RetrieveMergedBundlePath());
                    if (newBundlePath != null)
                    {
                        ProgressInfo.CurrentAction = "Adding bundle merge to inventory";
                        foreach (var bundleMerge in _pendingBundleMerges)
                        {
                            _inventory.Merges.Add(bundleMerge);
                        }

                        if (Program.Settings.Get <bool>("PlayCompletionSounds"))
                        {
                            System.Media.SystemSounds.Asterisk.Play();
                        }
                        if (Program.Settings.Get <bool>("ReportAfterPack"))
                        {
                            using (var reportForm = new PackReportForm(newBundlePath))
                            {
                                ProgressInfo.CurrentAction = "Showing pack report";
                                Program.MainForm.ShowModal(reportForm);
                            }
                        }
                    }
                }
                CleanUpTempFiles();
                CleanUpEmptyDirectories();
            };
            _bgWorker.RunWorkerAsync();
        }
Example #25
0
        ////////////////////////////////////////////////

        static void Main(string[] args)
        {
            ////quick test with random polygons ...
            //Paths ss = new Paths(1), cc = new Paths(1), sss = new Paths();
            //Random r = new Random((int)DateTime.Now.Ticks);
            //int scale = 1000000000; //tests 128bit math
            //ss.Add(MakeRandomPolygon(r, 400, 350, 9, scale));
            //cc.Add(MakeRandomPolygon(r, 400, 350, 9, scale));
            //Clipper cpr = new Clipper();
            //cpr.AddPaths(ss, PolyType.ptSubject, true);
            //cpr.AddPaths(cc, PolyType.ptClip, true);
            //cpr.Execute(ClipType.ctUnion, sss, PolyFillType.pftNonZero, PolyFillType.pftNonZero);
            //sss = Clipper.OffsetPolygons(sss, -5.0 * scale, JoinType.jtMiter, 4);
            //SVGBuilder svg1 = new SVGBuilder();
            //svg1.style.brushClr = Color.FromArgb(0x20, 0, 0, 0x9c);
            //svg1.style.penClr = Color.FromArgb(0xd3, 0xd3, 0xda);
            //svg1.AddPaths(ss);
            //svg1.style.brushClr = Color.FromArgb(0x20, 0x9c, 0, 0);
            //svg1.style.penClr = Color.FromArgb(0xff, 0xa0, 0x7a);
            //svg1.AddPaths(cc);
            //svg1.style.brushClr = Color.FromArgb(0xAA, 0x80, 0xff, 0x9c);
            //svg1.style.penClr = Color.FromArgb(0, 0x33, 0);
            //svg1.AddPaths(sss);
            //svg1.SaveToFile("solution.svg", 1.0 / scale);
            //return;

            if (args.Length < 5)
            {
                string appname = System.Environment.GetCommandLineArgs()[0];
                appname = System.IO.Path.GetFileName(appname);
                Console.WriteLine("");
                Console.WriteLine("Usage:");
                Console.WriteLine("  {0} CLIPTYPE s_file c_file INPUT_DEC_PLACES SVG_SCALE [S_FILL, C_FILL]", appname);
                Console.WriteLine("  where ...");
                Console.WriteLine("  CLIPTYPE = INTERSECTION|UNION|DIFFERENCE|XOR");
                Console.WriteLine("  FILLMODE = NONZERO|EVENODD");
                Console.WriteLine("  INPUT_DEC_PLACES = signific. decimal places for subject & clip coords.");
                Console.WriteLine("  SVG_SCALE = scale of SVG image as power of 10. (Fractions are accepted.)");
                Console.WriteLine("  both S_FILL and C_FILL are optional. The default is EVENODD.");
                Console.WriteLine("Example:");
                Console.WriteLine("  Intersect polygons, rnd to 4 dec places, SVG is 1/100 normal size ...");
                Console.WriteLine("  {0} INTERSECTION subj.txt clip.txt 0 0 NONZERO NONZERO", appname);
                return;
            }

            ClipType ct;

            switch (args[0].ToUpper())
            {
            case "INTERSECTION": ct = ClipType.ctIntersection; break;

            case "UNION": ct = ClipType.ctUnion; break;

            case "DIFFERENCE": ct = ClipType.ctDifference; break;

            case "XOR": ct = ClipType.ctXor; break;

            default: Console.WriteLine("Error: invalid operation - {0}", args[0]); return;
            }

            string subjFilename = args[1];
            string clipFilename = args[2];

            if (!File.Exists(subjFilename))
            {
                Console.WriteLine("Error: file - {0} - does not exist.", subjFilename);
                return;
            }
            if (!File.Exists(clipFilename))
            {
                Console.WriteLine("Error: file - {0} - does not exist.", clipFilename);
                return;
            }

            int decimal_places = 0;

            if (!Int32.TryParse(args[3], out decimal_places))
            {
                Console.WriteLine("Error: invalid number of decimal places - {0}", args[3]);
                return;
            }
            if (decimal_places > 8)
            {
                decimal_places = 8;
            }
            else if (decimal_places < 0)
            {
                decimal_places = 0;
            }

            double svg_scale = 0;

            if (!double.TryParse(args[4], out svg_scale))
            {
                Console.WriteLine("Error: invalid value for SVG_SCALE - {0}", args[4]);
                return;
            }
            if (svg_scale < -18)
            {
                svg_scale = -18;
            }
            else if (svg_scale > 18)
            {
                svg_scale = 18;
            }
            svg_scale = Math.Pow(10, svg_scale - decimal_places);//nb: also compensate for decimal places


            PolyFillType pftSubj = PolyFillType.pftEvenOdd;
            PolyFillType pftClip = PolyFillType.pftEvenOdd;

            if (args.Length > 6)
            {
                switch (args[5].ToUpper())
                {
                case "EVENODD": pftSubj = PolyFillType.pftEvenOdd; break;

                case "NONZERO": pftSubj = PolyFillType.pftNonZero; break;

                default: Console.WriteLine("Error: invalid cliptype - {0}", args[5]); return;
                }
                switch (args[6].ToUpper())
                {
                case "EVENODD": pftClip = PolyFillType.pftEvenOdd; break;

                case "NONZERO": pftClip = PolyFillType.pftNonZero; break;

                default: Console.WriteLine("Error: invalid cliptype - {0}", args[6]); return;
                }
            }

            Paths subjs = new Paths();
            Paths clips = new Paths();

            if (!LoadFromFile(subjFilename, subjs, decimal_places))
            {
                Console.WriteLine("Error processing subject polygons file - {0} ", subjFilename);
                OutputFileFormat();
                return;
            }
            if (!LoadFromFile(clipFilename, clips, decimal_places))
            {
                Console.WriteLine("Error processing clip polygons file - {0} ", clipFilename);
                OutputFileFormat();
                return;
            }

            Console.WriteLine("wait ...");
            Clipper cp = new Clipper();

            cp.AddPaths(subjs, PolyType.ptSubject, true);
            cp.AddPaths(clips, PolyType.ptClip, true);

            Paths solution = new Paths();

            //Paths solution = new Paths();
            if (cp.Execute(ct, solution, pftSubj, pftClip))
            {
                SaveToFile("solution.txt", solution, decimal_places);

                //solution = Clipper.OffsetPolygons(solution, -4, JoinType.jtRound);

                SVGBuilder svg = new SVGBuilder();
                svg.style.brushClr = Color.FromArgb(0x20, 0, 0, 0x9c);
                svg.style.penClr   = Color.FromArgb(0xd3, 0xd3, 0xda);
                svg.AddPaths(subjs);
                svg.style.brushClr = Color.FromArgb(0x20, 0x9c, 0, 0);
                svg.style.penClr   = Color.FromArgb(0xff, 0xa0, 0x7a);
                svg.AddPaths(clips);
                svg.style.brushClr = Color.FromArgb(0xAA, 0x80, 0xff, 0x9c);
                svg.style.penClr   = Color.FromArgb(0, 0x33, 0);
                svg.AddPaths(solution);
                svg.SaveToFile("solution.svg", svg_scale);

                Console.WriteLine("finished!");
            }
            else
            {
                Console.WriteLine("failed!");
            }
        }
Example #26
0
        public void InstallGame(IPackage package)
        {
            Log.InfoFormat("Installing game {0} {1}", package.Id, package.Title);
            try
            {
                Log.InfoFormat("Creating path {0} {1}", package.Id, package.Title);
                var dirPath = Path.GetTempPath();
                dirPath = Path.Combine(dirPath, "o8ginstall-" + Guid.NewGuid());
                Log.InfoFormat("Extracting package {0} {1} {2}", dirPath, package.Id, package.Title);
                GameFeedManager.Get().ExtractPackage(dirPath, package);
                Log.InfoFormat("Making def path {0} {1}", package.Id, package.Title);
                var defPath = Path.Combine(dirPath, "def");
                if (!Directory.Exists(defPath))
                {
                    Log.WarnFormat("Def path doesn't exist in the game package {0} {1}", package.Id, package.Title);
                    return;
                }
                var di = new DirectoryInfo(defPath);
                Log.InfoFormat("Copying temp files {0} {1}", package.Id, package.Title);
                foreach (var f in di.GetFiles("*", SearchOption.AllDirectories))
                {
                    Log.InfoFormat("Copying temp file {0} {1} {2}", f.FullName, package.Id, package.Title);
                    var relPath = f.FullName.Replace(di.FullName, "");
                    relPath = relPath.TrimStart('\\', '/');
                    var newPath = Path.Combine(Paths.Get().DatabasePath, package.Id);
                    newPath = Path.Combine(newPath, relPath);
                    var newFileInfo = new FileInfo(newPath);
                    if (newFileInfo.Directory != null)
                    {
                        Log.InfoFormat("Creating directory {0} {1} {2}", newFileInfo.Directory.FullName, package.Id, package.Title);
                        Directory.CreateDirectory(newFileInfo.Directory.FullName);
                    }
                    Log.InfoFormat("Copying file {0} {1} {2} {3}", f.FullName, newPath, package.Id, package.Title);
                    f.MegaCopyTo(newPath);
                    Log.InfoFormat("File copied {0} {1} {2} {3}", f.FullName, newPath, package.Id, package.Title);
                }
                //Sets//setid//Cards//Proxies

                var setsDir      = Path.Combine(Paths.Get().DatabasePath, package.Id, "Sets");
                var imageSetsDir = Path.Combine(Paths.Get().ImageDatabasePath, package.Id, "Sets");
                if (!Directory.Exists(imageSetsDir))
                {
                    Directory.CreateDirectory(imageSetsDir);
                }

                Log.InfoFormat("Installing decks {0} {1}", package.Id, package.Title);
                var game = GameManager.Get().GetById(new Guid(package.Id));
                if (game == null)
                {
                    throw new UserMessageException("Game {0} could not be installed. Please restart your computer and try again", package.Title);
                }
                if (Directory.Exists(Path.Combine(game.InstallPath, "Decks")))
                {
                    foreach (
                        var f in
                        new DirectoryInfo(Path.Combine(game.InstallPath, "Decks")).GetFiles(
                            "*.o8d", SearchOption.AllDirectories))
                    {
                        Log.InfoFormat("Found deck file {0} {1} {2}", f.FullName, package.Id, package.Title);
                        var relPath = f.FullName.Replace(new DirectoryInfo(Path.Combine(game.InstallPath, "Decks")).FullName, "").TrimStart('\\');
                        var newPath = Path.Combine(Paths.Get().DeckPath, game.Name, relPath);
                        Log.InfoFormat("Creating directories {0} {1} {2}", f.FullName, package.Id, package.Title);
                        if (new DirectoryInfo(newPath).Exists)
                        {
                            Directory.Move(newPath, Paths.Get().GraveyardPath);
                        }
                        Directory.CreateDirectory(new FileInfo(newPath).Directory.FullName);
                        Log.InfoFormat("Copying deck to {0} {1} {2} {3}", f.FullName, newPath, package.Id, package.Title);
                        f.MegaCopyTo(newPath);
                    }
                }

                foreach (var set in game.Sets())
                {
                    Log.InfoFormat("Checking set for decks {0} {1} {2}", setsDir, package.Id, package.Title);
                    var dp = set.DeckPath;
                    Log.InfoFormat("Got deck uri {0}", dp);
                    var decki = new DirectoryInfo(dp);
                    if (!decki.Exists)
                    {
                        Log.InfoFormat("No decks exist for set {0} {1} {2}", setsDir, package.Id, package.Title);
                        continue;
                    }
                    Log.InfoFormat("Finding deck files in set {0} {1} {2}", setsDir, package.Id, package.Title);
                    foreach (var f in decki.GetFiles("*.o8d", SearchOption.AllDirectories))
                    {
                        Log.InfoFormat("Found deck file {0} {1} {2} {3}", f.FullName, setsDir, package.Id, package.Title);
                        var relPath = f.FullName.Replace(decki.FullName, "").TrimStart('\\');
                        var newPath = Path.Combine(Paths.Get().DeckPath, game.Name, relPath);
                        Log.InfoFormat("Creating directories {0} {1} {2} {3}", f.FullName, setsDir, package.Id, package.Title);
                        Directory.CreateDirectory(new FileInfo(newPath).Directory.FullName);
                        Log.InfoFormat("Copying deck to {0} {1} {2} {3} {4}", f.FullName, newPath, setsDir, package.Id, package.Title);
                        f.MegaCopyTo(newPath);
                    }
                }

                Log.InfoFormat("Deleting proxy cards {0} {1} {2}", setsDir, package.Id, package.Title);
                // Clear out all proxies if they exist
                foreach (var setdir in new DirectoryInfo(imageSetsDir).GetDirectories())
                {
                    var dirString = Path.Combine(setdir.FullName, "Cards", "Proxies");
                    var pdir      = new DirectoryInfo(dirString);
                    Log.InfoFormat("Checking proxy dir {0} {1} {2}", pdir, package.Id, package.Title);
                    if (!pdir.Exists)
                    {
                        Log.InfoFormat("Proxy dir doesn't exist {0} {1} {2}", pdir, package.Id, package.Title);
                        continue;
                    }
                    try
                    {
                        Log.InfoFormat("Deleting proxy dir {0} {1} {2}", pdir, package.Id, package.Title);
                        pdir.MoveTo(Paths.Get().GraveyardPath);
                        Log.InfoFormat("Deleted proxy dir {0} {1} {2}", pdir, package.Id, package.Title);
                        Directory.CreateDirectory(dirString);
                    }
                    catch (Exception e)
                    {
                        Log.WarnFormat("Could not delete proxy directory {0}", pdir.FullName);
                    }
                }
                Log.InfoFormat("Fire game list changed {0} {1}", package.Id, package.Title);
                this.OnGameListChanged();
                Log.InfoFormat("Game list changed fired {0} {1}", package.Id, package.Title);

                //copy images over to imagedatabase
                foreach (var setdir in new DirectoryInfo(setsDir).GetDirectories())
                {
                    var cdir = new DirectoryInfo(Path.Combine(setdir.FullName, "Cards"));
                    if (cdir.Exists)
                    {
                        IEnumerable <FileInfo> fiArr = cdir.GetFiles("*.*", SearchOption.TopDirectoryOnly).Where(s => !s.FullName.EndsWith(".xml", StringComparison.CurrentCultureIgnoreCase));
                        foreach (FileInfo fi in fiArr)
                        {
                            string copyDirPath = Path.Combine(Paths.Get().ImageDatabasePath, package.Id, "Sets", setdir.Name, "Cards");
                            if (!Directory.Exists(copyDirPath))
                            {
                                Directory.CreateDirectory(copyDirPath);
                            }
                            fi.CopyTo(Path.Combine(copyDirPath, fi.Name), true);
                            fi.Delete();
                        }
                    }
                }
            }
            finally
            {
                Log.InfoFormat("Done {0} {1}", package.Id, package.Title);
            }
        }
Example #27
0
 public static bool ResetSkin()
 {
     Utils.WriteAllText(Paths.GetPath("skin.json"), JsonConvert.SerializeObject(new Skin()));
     SkinEngine.LoadSkin();
     return(true);
 }
Example #28
0
 public TemplateCache(IEngineEnvironmentSettings environmentSettings)
 {
     _environmentSettings = environmentSettings;
     _paths       = new Paths(environmentSettings);
     TemplateInfo = new List <TemplateInfo>();
 }
        public static async Task CleanupPlugins()
        {
            Action <string> deleteDirOrFile = (string path) => {
                if (Directory.Exists(path))
                {
                    try { Directory.Delete(path, true); } catch { }
                }
                if (File.Exists(path))
                {
                    try { File.Delete(path); } catch { }
                }
            };
            Func <string, List <string> > getObsoletePaths = (string dirPath) => {
                var sorted = Directory.GetDirectories(dirPath, "*.*", SearchOption.TopDirectoryOnly).OrderBy(fullPathDir => {
                    var verStr = fullPathDir.Replace(dirPath, "").Replace("\\", "").Trim();
                    return(Version.TryParse(verStr, out var ver) ? ver : new Version(1, 0));
                }).ToList();
                sorted.Remove(sorted.LastOrDefault());
                return(sorted);
            };

            Logger.Info("MinerPluginsManager", "CleanupPlugins START");
            try
            {
                Logger.Info("MinerPluginsManager", "CleanupPlugins EXECUTE");
                string minerPluginsPath          = Paths.MinerPluginsPath();
                var    zipPackages               = Directory.GetFiles(Paths.RootPath("plugins_packages"), "*.zip", SearchOption.TopDirectoryOnly);
                var    installedExternalPackages = Directory.GetDirectories(minerPluginsPath, "*", SearchOption.TopDirectoryOnly);
                foreach (var installedPath in installedExternalPackages)
                {
                    try
                    {
                        var uuid = installedPath.Replace(minerPluginsPath, "").Trim('\\');
                        if (!System.Guid.TryParse(uuid, out var _))
                        {
                            continue;
                        }
                        var zipPackage = zipPackages.FirstOrDefault(package => package.Contains(uuid));
                        if (zipPackage == null)
                        {
                            continue;
                        }
                        // cleanup old bins and dll's
                        var removePackageDirBins = getObsoletePaths(Path.Combine(installedPath, "bins"));
                        foreach (var removeDir in removePackageDirBins)
                        {
                            deleteDirOrFile(removeDir);
                        }

                        var removePackageDirDlls = getObsoletePaths(Path.Combine(installedPath, "dlls"));
                        foreach (var removeDir in removePackageDirDlls)
                        {
                            deleteDirOrFile(removeDir);
                        }

                        var installedPackageRootDlls = Directory.GetFiles(installedPath, "*.dll", SearchOption.TopDirectoryOnly);
                        if (ConfigManager.IsVersionChanged || installedPackageRootDlls.Length > 1)
                        {
                            foreach (var dllFile in installedPackageRootDlls)
                            {
                                deleteDirOrFile(dllFile);
                            }
                            await ArchiveHelpers.ExtractFileAsync(zipPackage, installedPath, null, CancellationToken.None);
                        }
                    }
                    catch (Exception e)
                    {
                        Logger.Error("MinerPluginsManager", $"CleanupPlugins {installedPath} Error: {e.Message}");
                    }
                }
            }
            catch (Exception e)
            {
                Logger.Error("MinerPluginsManager", $"CleanupPlugins Error: {e.Message}");
            }
        }
Example #30
0
        protected override void Execute(GVFSEnlistment enlistment)
        {
            string diagnosticsRoot = Path.Combine(enlistment.DotGVFSRoot, "diagnostics");

            if (!Directory.Exists(diagnosticsRoot))
            {
                Directory.CreateDirectory(diagnosticsRoot);
            }

            string archiveFolderPath = Path.Combine(diagnosticsRoot, "gvfs_" + DateTime.Now.ToString("yyyyMMdd_HHmmss"));

            Directory.CreateDirectory(archiveFolderPath);

            using (FileStream diagnosticLogFile = new FileStream(Path.Combine(archiveFolderPath, "diagnostics.log"), FileMode.CreateNew))
                using (this.diagnosticLogFileWriter = new StreamWriter(diagnosticLogFile))
                {
                    this.WriteMessage("Collecting diagnostic info into temp folder " + archiveFolderPath);

                    this.WriteMessage(string.Empty);
                    this.WriteMessage("gvfs version " + ProcessHelper.GetCurrentProcessVersion());

                    GitVersion gitVersion = null;
                    string     error      = null;
                    if (!string.IsNullOrEmpty(enlistment.GitBinPath) && GitProcess.TryGetVersion(enlistment.GitBinPath, out gitVersion, out error))
                    {
                        this.WriteMessage("git version " + gitVersion.ToString());
                    }
                    else
                    {
                        this.WriteMessage("Could not determine git version. " + error);
                    }

                    this.WriteMessage(enlistment.GitBinPath);
                    this.WriteMessage(string.Empty);
                    this.WriteMessage("Enlistment root: " + enlistment.EnlistmentRoot);
                    this.WriteMessage("Cache Server: " + CacheServerResolver.GetCacheServerFromConfig(enlistment));

                    string localCacheRoot;
                    string gitObjectsRoot;
                    this.GetLocalCachePaths(enlistment, out localCacheRoot, out gitObjectsRoot);
                    string actualLocalCacheRoot = !string.IsNullOrWhiteSpace(localCacheRoot) ? localCacheRoot : gitObjectsRoot;
                    this.WriteMessage("Local Cache: " + actualLocalCacheRoot);
                    this.WriteMessage(string.Empty);

                    this.PrintDiskSpaceInfo(actualLocalCacheRoot, this.EnlistmentRootPathParameter);

                    this.RecordVersionInformation();

                    this.ShowStatusWhileRunning(
                        () =>
                        this.RunAndRecordGVFSVerb <StatusVerb>(archiveFolderPath, "gvfs_status.txt") != ReturnCode.Success ||
                        this.RunAndRecordGVFSVerb <UnmountVerb>(archiveFolderPath, "gvfs_unmount.txt", verb => verb.SkipLock = true) == ReturnCode.Success,
                        "Unmounting",
                        suppressGvfsLogMessage: true);

                    this.ShowStatusWhileRunning(
                        () =>
                    {
                        // .gvfs
                        this.CopyAllFiles(enlistment.EnlistmentRoot, archiveFolderPath, GVFSConstants.DotGVFS.Root, copySubFolders: false);

                        // driver
                        if (this.FlushKernelDriverLogs())
                        {
                            string kernelLogsFolderPath = GVFSPlatform.Instance.KernelDriver.LogsFolderPath;

                            // This copy sometimes fails because the OS has an exclusive lock on the etl files. The error is not actionable
                            // for the user so we don't write the error message to stdout, just to our own log file.
                            this.CopyAllFiles(Path.GetDirectoryName(kernelLogsFolderPath), archiveFolderPath, Path.GetFileName(kernelLogsFolderPath), copySubFolders: false, hideErrorsFromStdout: true);
                        }

                        // .git
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Root, copySubFolders: false);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Hooks.Root, copySubFolders: false);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Info.Root, copySubFolders: false);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Logs.Root, copySubFolders: true);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Refs.Root, copySubFolders: true);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Objects.Info.Root, copySubFolders: false);
                        this.LogDirectoryEnumeration(enlistment.WorkingDirectoryRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGit.Objects.Root), GVFSConstants.DotGit.Objects.Pack.Root, "packs-local.txt");
                        this.LogLooseObjectCount(enlistment.WorkingDirectoryRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGit.Objects.Root), GVFSConstants.DotGit.Objects.Root, "objects-local.txt");

                        // databases
                        this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGVFS.Root), GVFSConstants.DotGVFS.Databases.Name, copySubFolders: false);

                        // local cache
                        this.CopyLocalCacheData(archiveFolderPath, localCacheRoot, gitObjectsRoot);

                        // corrupt objects
                        this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGVFS.Root), GVFSConstants.DotGVFS.CorruptObjectsName, copySubFolders: false);

                        if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSService)
                        {
                            // service
                            this.CopyAllFiles(
                                Paths.GetServiceDataRoot(string.Empty),
                                archiveFolderPath,
                                this.ServiceName,
                                copySubFolders: true);
                        }

                        if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
                        {
                            // upgrader
                            this.CopyAllFiles(
                                ProductUpgraderInfo.GetUpgradesDirectoryPath(),
                                archiveFolderPath,
                                DeprecatedUpgradeLogsDirectory,
                                copySubFolders: true,
                                targetFolderName: Path.Combine(ProductUpgraderInfo.UpgradeDirectoryName, DeprecatedUpgradeLogsDirectory));

                            this.CopyAllFiles(
                                ProductUpgraderInfo.GetUpgradesDirectoryPath(),
                                archiveFolderPath,
                                ProductUpgraderInfo.LogDirectory,
                                copySubFolders: true,
                                targetFolderName: Path.Combine(ProductUpgraderInfo.UpgradeDirectoryName, ProductUpgraderInfo.LogDirectory));

                            this.LogDirectoryEnumeration(
                                ProductUpgraderInfo.GetUpgradesDirectoryPath(),
                                Path.Combine(archiveFolderPath, ProductUpgraderInfo.UpgradeDirectoryName),
                                ProductUpgraderInfo.DownloadDirectory,
                                "downloaded-assets.txt");
                        }

                        if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSConfig)
                        {
                            this.CopyFile(Paths.GetServiceDataRoot(string.Empty), archiveFolderPath, LocalGVFSConfig.FileName);
                        }

                        return(true);
                    },
                        "Copying logs");

                    this.ShowStatusWhileRunning(
                        () => this.RunAndRecordGVFSVerb <MountVerb>(archiveFolderPath, "gvfs_mount.txt") == ReturnCode.Success,
                        "Mounting",
                        suppressGvfsLogMessage: true);

                    this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGVFS.Root), "logs", copySubFolders: false);
                }

            string zipFilePath = archiveFolderPath + ".zip";

            this.ShowStatusWhileRunning(
                () =>
            {
                ZipFile.CreateFromDirectory(archiveFolderPath, zipFilePath);
                this.fileSystem.DeleteDirectory(archiveFolderPath);

                return(true);
            },
                "Creating zip file",
                suppressGvfsLogMessage: true);

            this.Output.WriteLine();
            this.Output.WriteLine("Diagnostics complete. All of the gathered info, as well as all of the output above, is captured in");
            this.Output.WriteLine(zipFilePath);
        }
Example #31
0
 public Installer(IEngineEnvironmentSettings environmentSettings)
 {
     _environmentSettings = environmentSettings;
     _paths = new Paths(environmentSettings);
 }
Example #32
0
        internal static string BufferPathInvoke(string path, Func <string, StringBuffer, uint> invoker, bool utilizeExtendedSyntax = true)
        {
            if (path == null)
            {
                return(null);
            }
            string originalPath = path;

            bool hadExtendedPrefix   = Paths.IsExtended(path);
            bool addedExtendedPrefix = false;

            if (utilizeExtendedSyntax && !hadExtendedPrefix && (path.Length > Paths.MaxPath))
            {
                path = Paths.AddExtendedPrefix(path);
                addedExtendedPrefix = true;
            }

            return(StringBufferCache.CachedBufferInvoke(Paths.MaxPath, (buffer) =>
            {
                uint returnValue = 0;

                while ((returnValue = invoker(path, buffer)) > (uint)buffer.CharCapacity)
                {
                    // Need more room for the output string
                    buffer.EnsureCharCapacity(returnValue);
                }

                if (returnValue == 0)
                {
                    // Failed
                    int error = Marshal.GetLastWin32Error();
                    throw GetIoExceptionForError(error, originalPath);
                }

                buffer.Length = returnValue;

                uint startIndex = 0;
                if (addedExtendedPrefix && buffer.StartsWithOrdinal(Paths.ExtendedPathPrefix))
                {
                    // Remove the prefix
                    if (buffer.StartsWithOrdinal(Paths.ExtendedUncPrefix))
                    {
                        // UNC, need to convert from \\?\UNC\ to \\.
                        startIndex = (uint)Paths.ExtendedUncPrefix.Length - 2;
                        buffer[startIndex] = Paths.DirectorySeparator;
                    }
                    else
                    {
                        startIndex = (uint)Paths.ExtendedPathPrefix.Length;
                    }
                }

                // If the string did not change, return the original (to cut back on identical string pressure)
                if (buffer.SubStringEquals(originalPath, startIndex: startIndex))
                {
                    return originalPath;
                }
                else
                {
                    return buffer.SubString(startIndex: startIndex);
                }
            }));
        }
Example #33
0
        public bool TrySetConfig(out string error)
        {
            string coreGVFSFlags = Convert.ToInt32(
                GitCoreGVFSFlags.BlockCommands |
                GitCoreGVFSFlags.MissingOk |
                GitCoreGVFSFlags.FetchSkipReachabilityAndUploadPack |
                GitCoreGVFSFlags.PrefetchDuringFetch)
                                   .ToString();

            string expectedHooksPath = Path.Combine(this.Context.Enlistment.WorkingDirectoryRoot, ScalarConstants.DotGit.Hooks.Root);

            expectedHooksPath = Paths.ConvertPathToGitFormat(expectedHooksPath);

            if (!this.UseGvfsProtocol.HasValue)
            {
                this.UseGvfsProtocol = this.Context.Enlistment.UsesGvfsProtocol;
            }

            // These settings are required for normal Scalar functionality.
            // They will override any existing local configuration values.
            //
            // IMPORTANT! These must parallel the settings in ControlGitRepo:Initialize
            //
            Dictionary <string, string> requiredSettings = new Dictionary <string, string>
            {
                { "am.keepcr", "true" },
                { "core.autocrlf", "false" },
                { "checkout.optimizenewbranch", "true" },
                { "core.fscache", "true" },
                { "core.multiPackIndex", "true" },
                { "core.preloadIndex", "true" },
                { "core.safecrlf", "false" },
                { "core.untrackedCache", ScalarPlatform.Instance.FileSystem.SupportsUntrackedCache ? "true" : "false" },
                { "core.filemode", ScalarPlatform.Instance.FileSystem.SupportsFileMode ? "true" : "false" },
                { "core.bare", "false" },
                { "core.logallrefupdates", "true" },
                { "core.hookspath", expectedHooksPath },
                { GitConfigSetting.CredentialUseHttpPath, "true" },
                { "credential.validate", "false" },
                { "gc.auto", "0" },
                { "gui.gcwarning", "false" },
                { "index.threads", "true" },
                { "index.version", "4" },
                { "log.excludeDecoration", "refs/scalar/*" },
                { "merge.stat", "false" },
                { "merge.renames", "false" },
                { "pack.useBitmaps", "false" },
                { "pack.useSparse", "true" },
                { "receive.autogc", "false" },
                { "reset.quiet", "true" },
                { "feature.manyFiles", "false" },
                { "feature.experimental", "false" },
                { "fetch.unpackLimit", "1" },
                { "fetch.writeCommitGraph", "false" },
            };

            if (this.UseGvfsProtocol.Value)
            {
                requiredSettings.Add("core.gvfs", coreGVFSFlags);
                requiredSettings.Add(ScalarConstants.GitConfig.UseGvfsHelper, "true");
                requiredSettings.Add("http.version", "HTTP/1.1");
            }

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                requiredSettings.Add("http.sslBackend", "schannel");
            }

            // If we do not use the GVFS protocol, then these config settings
            // are in fact optional.
            if (!this.TrySetConfig(requiredSettings, isRequired: this.UseGvfsProtocol.Value, out error))
            {
                error = $"Failed to set some required settings: {error}";
                this.Context.Tracer.RelatedError(error);
                return(false);
            }

            // These settings are optional, because they impact performance but not functionality of Scalar.
            // These settings should only be set by the clone or repair verbs, so that they do not
            // overwrite the values set by the user in their local config.
            Dictionary <string, string> optionalSettings = new Dictionary <string, string>
            {
                { "status.aheadbehind", "false" },
            };

            if (this.UseGvfsProtocol.Value)
            {
                // If a user's global config has "status.submoduleSummary=true", then
                // that could slow "git status" significantly here, even though the
                // GVFS protocol forbids submodules. Still, disable it optionally in
                // case the user really wants it in their local config.
                optionalSettings.Add("status.submoduleSummary", "false");
            }

            if (!this.TrySetConfig(optionalSettings, isRequired: false, out error))
            {
                error = $"Failed to set some optional settings: {error}";
                this.Context.Tracer.RelatedError(error);
                return(false);
            }

            return(this.ConfigureWatchmanIntegration(out error));
        }
Example #34
0
        static void LoadLegacyExtensionsFromIvyFiles()
        {
            //We can't use the cached native type scanner here since this is called to early for that to be built up.

            HashSet <string> ivyFiles;

            try
            {
                ivyFiles = new HashSet <string>();

                string unityExtensionsFolder = FileUtil.CombinePaths(Directory.GetParent(EditorApplication.applicationPath).ToString(), "Data", "UnityExtensions");
                string playbackEngineFolders = FileUtil.CombinePaths(Directory.GetParent(EditorApplication.applicationPath).ToString(), "PlaybackEngines");

                foreach (var searchPath in new[]
                {
                    FileUtil.NiceWinPath(EditorApplication.applicationContentsPath),
                    FileUtil.NiceWinPath(unityExtensionsFolder),
                    FileUtil.NiceWinPath(playbackEngineFolders)
                })
                {
                    if (!Directory.Exists(searchPath))
                    {
                        continue;
                    }

                    ivyFiles.UnionWith(Directory.GetFiles(searchPath, "ivy.xml", SearchOption.AllDirectories));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error scanning for extension ivy.xml files: {0}", ex);
                return;
            }

            var packages = new Dictionary <string, List <IvyPackageFileData> >();

            var artifactRegex = new Regex(@"<artifact(\s+(name=""(?<name>[^""]*)""|type=""(?<type>[^""]*)""|ext=""(?<ext>[^""]*)""|e:guid=""(?<guid>[^""]*)""))+\s*/>",
                                          RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);

            foreach (var ivyFile in ivyFiles)
            {
                try
                {
                    var ivyFileContent = File.ReadAllText(ivyFile);
                    var artifacts      = artifactRegex.Matches(ivyFileContent).Cast <Match>()
                                         .Select(IvyPackageFileData.CreateFromRegexMatch).ToList();

                    var packageDir = Path.GetDirectoryName(ivyFile);
                    packages.Add(packageDir, artifacts);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Error reading extensions from ivy.xml file at {0}: {1}", ivyFile, ex);
                }
            }

            try
            {
                foreach (var packageInfo in packages)
                {
                    var files = packageInfo.Value;
                    foreach (var packageInfoFile in files)
                    {
                        string fullPath = Paths.NormalizePath(Path.Combine(packageInfo.Key, packageInfoFile.filename));

                        if (!File.Exists(fullPath))
                        {
                            Debug.LogWarningFormat(
                                "Missing assembly \t{0} listed in ivy file {1}. Extension support may be incomplete.", fullPath,
                                packageInfo.Key);
                        }

                        if (!packageInfoFile.IsDll)
                        {
                            continue;
                        }

                        if (!string.IsNullOrEmpty(packageInfoFile.guid))
                        {
                            InternalEditorUtility.RegisterExtensionDll(fullPath.Replace('\\', '/'),
                                                                       packageInfoFile.guid);
                        }
                        else
                        {
                            InternalEditorUtility.RegisterPrecompiledAssembly(fullPath, fullPath);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error scanning for extensions. {0}", ex);
            }
        }
Example #35
0
 private static string CombinePaths(params string[] paths)
 {
     return(Paths.Combine(paths));
 }
Example #36
0
        ////////////////////////////////////////////////

        static bool LoadFromFile(string filename, Paths ppg, int dec_places, int xOffset = 0, int yOffset = 0)
        {
            double scaling;
            scaling = Math.Pow(10, dec_places);

            ppg.Clear();
            if (!File.Exists(filename)) return false;
            StreamReader sr = new StreamReader(filename);
            if (sr == null) return false;
            string line;
            if ((line = sr.ReadLine()) == null) return false;
            int polyCnt, vertCnt;
            if (!Int32.TryParse(line, out polyCnt) || polyCnt < 0) return false;
            ppg.Capacity = polyCnt;
            for (int i = 0; i < polyCnt; i++)
            {
                if ((line = sr.ReadLine()) == null) return false;
                if (!Int32.TryParse(line, out vertCnt) || vertCnt < 0) return false;
                Path pg = new Path(vertCnt);
                ppg.Add(pg);
                if (scaling > 0.999 & scaling < 1.001)
                    for (int j = 0; j < vertCnt; j++)
                    {
                        Int64 x, y;
                        if ((line = sr.ReadLine()) == null) return false;
                        char[] delimiters = new char[] { ',', ' ' };
                        string[] vals = line.Split(delimiters);
                        if (vals.Length < 2) return false;
                        if (!Int64.TryParse(vals[0], out x)) return false;
                        if (!Int64.TryParse(vals[1], out y))
                            if (vals.Length < 2 || !Int64.TryParse(vals[2], out y)) return false;
                        x = x + xOffset;
                        y = y + yOffset;
                        pg.Add(new IntPoint(x, y));
                    }
                else
                    for (int j = 0; j < vertCnt; j++)
                    {
                        double x, y;
                        if ((line = sr.ReadLine()) == null) return false;
                        char[] delimiters = new char[] { ',', ' ' };
                        string[] vals = line.Split(delimiters);
                        if (vals.Length < 2) return false;
                        if (!double.TryParse(vals[0], out x)) return false;
                        if (!double.TryParse(vals[1], out y))
                            if (vals.Length < 2 || !double.TryParse(vals[2], out y)) return false;
                        x = x * scaling + xOffset;
                        y = y * scaling + yOffset;
                        pg.Add(new IntPoint((Int64)Math.Round(x), (Int64)Math.Round(y)));
                    }
            }
            return true;
        }
Example #37
0
 public TemplateCreator(IEngineEnvironmentSettings environmentSettings)
 {
     _environmentSettings = environmentSettings;
     _paths = new Paths(environmentSettings);
 }
Example #38
0
        ////////////////////////////////////////////////
        
        static void Main(string[] args)
        {
          ////quick test with random polygons ...
          //Paths ss = new Paths(1), cc = new Paths(1), sss = new Paths();
          //Random r = new Random((int)DateTime.Now.Ticks);
          //int scale = 1000000000; //tests 128bit math
          //ss.Add(MakeRandomPolygon(r, 400, 350, 9, scale));
          //cc.Add(MakeRandomPolygon(r, 400, 350, 9, scale));
          //Clipper cpr = new Clipper();
          //cpr.AddPaths(ss, PolyType.ptSubject, true);
          //cpr.AddPaths(cc, PolyType.ptClip, true);
          //cpr.Execute(ClipType.ctUnion, sss, PolyFillType.pftNonZero, PolyFillType.pftNonZero);
          //sss = Clipper.OffsetPolygons(sss, -5.0 * scale, JoinType.jtMiter, 4);
          //SVGBuilder svg1 = new SVGBuilder();
          //svg1.style.brushClr = Color.FromArgb(0x20, 0, 0, 0x9c);
          //svg1.style.penClr = Color.FromArgb(0xd3, 0xd3, 0xda);
          //svg1.AddPaths(ss);
          //svg1.style.brushClr = Color.FromArgb(0x20, 0x9c, 0, 0);
          //svg1.style.penClr = Color.FromArgb(0xff, 0xa0, 0x7a);
          //svg1.AddPaths(cc);
          //svg1.style.brushClr = Color.FromArgb(0xAA, 0x80, 0xff, 0x9c);
          //svg1.style.penClr = Color.FromArgb(0, 0x33, 0);
          //svg1.AddPaths(sss);
          //svg1.SaveToFile("solution.svg", 1.0 / scale);
          //return;

          if (args.Length < 5)
            {
                string appname = System.Environment.GetCommandLineArgs()[0];
                appname = System.IO.Path.GetFileName(appname);
                Console.WriteLine("");
                Console.WriteLine("Usage:");
                Console.WriteLine("  {0} CLIPTYPE s_file c_file INPUT_DEC_PLACES SVG_SCALE [S_FILL, C_FILL]", appname);
                Console.WriteLine("  where ...");
                Console.WriteLine("  CLIPTYPE = INTERSECTION|UNION|DIFFERENCE|XOR");
                Console.WriteLine("  FILLMODE = NONZERO|EVENODD");
                Console.WriteLine("  INPUT_DEC_PLACES = signific. decimal places for subject & clip coords.");
                Console.WriteLine("  SVG_SCALE = scale of SVG image as power of 10. (Fractions are accepted.)");
                Console.WriteLine("  both S_FILL and C_FILL are optional. The default is EVENODD.");
                Console.WriteLine("Example:");
                Console.WriteLine("  Intersect polygons, rnd to 4 dec places, SVG is 1/100 normal size ...");
                Console.WriteLine("  {0} INTERSECTION subj.txt clip.txt 0 0 NONZERO NONZERO", appname);
                return;
            }

            ClipType ct;
            switch (args[0].ToUpper())
            {
                case "INTERSECTION": ct = ClipType.ctIntersection; break;
                case "UNION": ct = ClipType.ctUnion; break;
                case "DIFFERENCE": ct = ClipType.ctDifference; break;
                case "XOR": ct = ClipType.ctXor; break;
                default: Console.WriteLine("Error: invalid operation - {0}", args[0]); return;
            }

            string subjFilename = args[1];
            string clipFilename = args[2];
            if (!File.Exists(subjFilename))
            {
                Console.WriteLine("Error: file - {0} - does not exist.", subjFilename);
                return;
            }
            if (!File.Exists(clipFilename))
            {
                Console.WriteLine("Error: file - {0} - does not exist.", clipFilename);
                return;
            }

            int decimal_places = 0;
            if (!Int32.TryParse(args[3], out decimal_places))
            {
                Console.WriteLine("Error: invalid number of decimal places - {0}", args[3]);
                return;
            }
            if (decimal_places > 8) decimal_places = 8;
            else if (decimal_places < 0) decimal_places = 0;

            double svg_scale = 0;
            if (!double.TryParse(args[4], out svg_scale))
            {
                Console.WriteLine("Error: invalid value for SVG_SCALE - {0}", args[4]);
                return;
            }
            if (svg_scale < -18) svg_scale = -18;
            else if (svg_scale > 18) svg_scale = 18;
            svg_scale = Math.Pow(10, svg_scale - decimal_places);//nb: also compensate for decimal places


            PolyFillType pftSubj = PolyFillType.pftEvenOdd;
            PolyFillType pftClip = PolyFillType.pftEvenOdd;
            if (args.Length > 6)
            {
                switch (args[5].ToUpper())
                {
                    case "EVENODD": pftSubj = PolyFillType.pftEvenOdd; break;
                    case "NONZERO": pftSubj = PolyFillType.pftNonZero; break;
                    default: Console.WriteLine("Error: invalid cliptype - {0}", args[5]); return;
                }
                switch (args[6].ToUpper())
                {
                    case "EVENODD": pftClip = PolyFillType.pftEvenOdd; break;
                    case "NONZERO": pftClip = PolyFillType.pftNonZero; break;
                    default: Console.WriteLine("Error: invalid cliptype - {0}", args[6]); return;
                }
            }

            Paths subjs = new Paths();
            Paths clips = new Paths();
            if (!LoadFromFile(subjFilename, subjs, decimal_places))
            {
                Console.WriteLine("Error processing subject polygons file - {0} ", subjFilename);
                OutputFileFormat();
                return;
            }
            if (!LoadFromFile(clipFilename, clips, decimal_places))
            {
                Console.WriteLine("Error processing clip polygons file - {0} ", clipFilename);
                OutputFileFormat();
                return;
            }

            Console.WriteLine("wait ...");
            Clipper cp = new Clipper();
            cp.AddPaths(subjs, PolyType.ptSubject, true);
            cp.AddPaths(clips, PolyType.ptClip, true);

            Paths solution = new Paths();
            //Paths solution = new Paths();
            if (cp.Execute(ct, solution, pftSubj, pftClip))
            {
                SaveToFile("solution.txt", solution, decimal_places);

                //solution = Clipper.OffsetPolygons(solution, -4, JoinType.jtRound);

                SVGBuilder svg = new SVGBuilder();
                svg.style.brushClr = Color.FromArgb(0x20, 0, 0, 0x9c);
                svg.style.penClr = Color.FromArgb(0xd3, 0xd3, 0xda);
                svg.AddPaths(subjs);
                svg.style.brushClr = Color.FromArgb(0x20, 0x9c, 0, 0);
                svg.style.penClr = Color.FromArgb(0xff, 0xa0, 0x7a);
                svg.AddPaths(clips);
                svg.style.brushClr = Color.FromArgb(0xAA, 0x80, 0xff, 0x9c);
                svg.style.penClr = Color.FromArgb(0, 0x33, 0);
                svg.AddPaths(solution);
                svg.SaveToFile("solution.svg", svg_scale);

                Console.WriteLine("finished!");
            }
            else
            {
                Console.WriteLine("failed!");
            }
        }
 //Clipper
 public static List <Polygon> ToPolygons(this Paths v)
 {
     return(v.Select(ToPolygon).ToList());
 }
        void calculateRegionPath(ClipType clipType)
        {
            Clipper c = new Clipper();

            var subjects = solution;
            //subjects.Add (solution);

            var clips = new Paths ();

            foreach (var path in regionList [regionList.Count - 1].regionPath)
                clips.Add (path);

            c.AddPolygons(subjects, PolyType.ptSubject);
            c.AddPolygons(clips, PolyType.ptClip);

            solution.Clear();

            bool succeeded = c.Execute(clipType, solution, SUBJ_FILL_TYPE, CLIP_FILL_TYPE);

            if (succeeded)
            {
                PathsToInternalPath (solution);

                // Not sure what this is returning
            //				var bounds = c.GetBounds ();
            //				regionBounds.X = bounds.left / scale;
            //				regionBounds.Y = bounds.top / scale;
            //				regionBounds.Width = (bounds.right - bounds.left) / scale;
            //				regionBounds.Height = (bounds.bottom - bounds.top) / scale;

                if (regionPath.IsEmpty)
                    regionBounds = RectangleF.Empty;
                else
                    regionBounds = regionPath.BoundingBox;

            }
        }
Example #41
0
 internal bool extract(ZipEntry entry, out Guid gameGuid, Guid testGuid)
 {
     try
     {
         Log.InfoFormat("Extracting {0},{1}", entry.FileName, testGuid);
         bool ret = false;
         gameGuid = testGuid;
         string[] split = entry.FileName.Split('/');
         Log.InfoFormat("Split file name {0},{1}", entry.FileName, testGuid);
         if (split.Length == 5)
         {
             Log.InfoFormat("File name right count {0},{1}", entry.FileName, testGuid);
             O8cEntry o8cEntry = new O8cEntry()
             {
                 gameGuid  = split[0],
                 setsDir   = split[1],
                 setGuid   = split[2],
                 cardsDir  = split[3],
                 cardImage = split[4]
             };
             Log.InfoFormat("Checking if testGuid is empty {0},{1}", entry.FileName, testGuid);
             if (testGuid.Equals(Guid.Empty))
             {
                 Log.InfoFormat("testGuid is empty {0},{1}", entry.FileName, testGuid);
                 testGuid = Guid.Parse(o8cEntry.gameGuid);
                 gameGuid = Guid.Parse(o8cEntry.gameGuid);
                 Log.InfoFormat("Setting gameguid and testguid {0},{1},{2}", entry.FileName, testGuid, gameGuid);
             }
             Log.InfoFormat("Checking if {0}=={1} {2}", testGuid, o8cEntry.gameGuid, entry.FileName);
             if (!testGuid.Equals(Guid.Parse(o8cEntry.gameGuid)))
             {
                 Log.InfoFormat("{0}!={1} {2}", testGuid, o8cEntry.gameGuid, entry.FileName);
                 return(ret);
             }
             Log.InfoFormat("Checking if should extract part {0},{1}", entry.FileName, testGuid);
             if (ShouldExtract(o8cEntry))
             {
                 Log.InfoFormat(
                     "Should extract, so extracting {0},{1},{2}",
                     Paths.Get().ImageDatabasePath,
                     entry.FileName,
                     testGuid);
                 entry.Extract(Paths.Get().ImageDatabasePath, ExtractExistingFileAction.OverwriteSilently);
                 Log.InfoFormat("Extracted {0},{1},{2}", Paths.Get().ImageDatabasePath, entry.FileName, testGuid);
                 ret = true;
             }
         }
         Log.InfoFormat("Finishing {0},{1},{2}", ret, entry.FileName, testGuid);
         return(ret);
     }
     catch (IOException e)
     {
         throw new UserMessageException("Error extracting {0} to {1}\n{2}", entry.FileName, Paths.Get().DatabasePath, e.Message);
     }
     finally
     {
         Log.InfoFormat("Finished {0},{1}", entry.FileName, testGuid);
     }
 }
 //:
 //this (type, obj, new Paths<List<IntPoint>>(path), clipType)
 public RegionEntry(RegionType type, object obj, Path path, RegionClipType clipType)
 {
     regionType = type;
     regionObject = obj;
     regionPath = new Paths() { path };
     regionClipType = clipType;
 }
Example #43
0
        ////////////////////////////////////////////////

        static bool LoadFromFile(string filename, Paths ppg, int dec_places, int xOffset = 0, int yOffset = 0)
        {
            double scaling;

            scaling = Math.Pow(10, dec_places);

            ppg.Clear();
            if (!File.Exists(filename))
            {
                return(false);
            }
            StreamReader sr = new StreamReader(filename);

            if (sr == null)
            {
                return(false);
            }
            string line;

            if ((line = sr.ReadLine()) == null)
            {
                return(false);
            }
            int polyCnt, vertCnt;

            if (!Int32.TryParse(line, out polyCnt) || polyCnt < 0)
            {
                return(false);
            }
            ppg.Capacity = polyCnt;
            for (int i = 0; i < polyCnt; i++)
            {
                if ((line = sr.ReadLine()) == null)
                {
                    return(false);
                }
                if (!Int32.TryParse(line, out vertCnt) || vertCnt < 0)
                {
                    return(false);
                }
                Path pg = new Path(vertCnt);
                ppg.Add(pg);
                if (scaling > 0.999 & scaling < 1.001)
                {
                    for (int j = 0; j < vertCnt; j++)
                    {
                        Int64 x, y;
                        if ((line = sr.ReadLine()) == null)
                        {
                            return(false);
                        }
                        char[]   delimiters = new char[] { ',', ' ' };
                        string[] vals       = line.Split(delimiters);
                        if (vals.Length < 2)
                        {
                            return(false);
                        }
                        if (!Int64.TryParse(vals[0], out x))
                        {
                            return(false);
                        }
                        if (!Int64.TryParse(vals[1], out y))
                        {
                            if (vals.Length < 2 || !Int64.TryParse(vals[2], out y))
                            {
                                return(false);
                            }
                        }
                        x = x + xOffset;
                        y = y + yOffset;
                        pg.Add(new IntPoint(x, y));
                    }
                }
                else
                {
                    for (int j = 0; j < vertCnt; j++)
                    {
                        double x, y;
                        if ((line = sr.ReadLine()) == null)
                        {
                            return(false);
                        }
                        char[]   delimiters = new char[] { ',', ' ' };
                        string[] vals       = line.Split(delimiters);
                        if (vals.Length < 2)
                        {
                            return(false);
                        }
                        if (!double.TryParse(vals[0], out x))
                        {
                            return(false);
                        }
                        if (!double.TryParse(vals[1], out y))
                        {
                            if (vals.Length < 2 || !double.TryParse(vals[2], out y))
                            {
                                return(false);
                            }
                        }
                        x = x * scaling + xOffset;
                        y = y * scaling + yOffset;
                        pg.Add(new IntPoint((Int64)Math.Round(x), (Int64)Math.Round(y)));
                    }
                }
            }
            return(true);
        }
Example #44
0
 public SchedulerTestBase(ITestOutputHelper output)
     : base(output)
 {
     m_paths       = new Paths(Context.PathTable);
     m_fileFreshId = 0;
 }
Example #45
0
 private void OnDisable()
 {
     Options.instance.SaveToFile(Paths.GetOptionsFilePath());
 }
Example #46
0
 public void GetFinalPathNameTest()
 {
     Assert.AreEqual(@"C:\Users", Paths.GetFinalPathName(@"c:\Documents and Settings"));
     Assert.AreEqual(@"C:\Users", Paths.GetFinalPathName(@"C:\Users"));
     Assert.AreEqual(@"\\server\someunc\testpath", Paths.GetFinalPathName(@"\\server\someunc\testpath"));
 }
Example #47
0
      //------------------------------------------------------------------------------

      public static Paths ClosedPathsFromPolyTree(PolyTree polytree)
      {
        Paths result = new Paths();
        result.Capacity = polytree.Total;
        AddPolyNodeToPaths(polytree, NodeType.ntClosed, result);
        return result;
      }
 /// <summary>
 /// Initializes a new instance of the <see cref="Submenu"/> class and determines the path of the mdi client
 /// </summary>
 public Submenu()
 {
     this.repository = Paths.Instance;
 }
Example #49
0
        static void Main(string[] argv)
        {
            BUILD_TAG.ASSERT_COMPATIBLE_BUILDS();
            // Set working directory to exe
            var pathSet = false;
            var path    = Path.GetDirectoryName(Application.ExecutablePath);

            if (path != null)
            {
                Paths.SetRoot(path);
                Environment.CurrentDirectory = path;
                pathSet = true;
            }

            // Add common folder to path for launched processes
            var pathVar = Environment.GetEnvironmentVariable("PATH");

            pathVar += ";" + Path.Combine(Environment.CurrentDirectory, "common");
            Environment.SetEnvironmentVariable("PATH", pathVar);


            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
            // set security protocols
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol  = SecurityProtocolType.Tls
                                                    | SecurityProtocolType.Tls11
                                                    | SecurityProtocolType.Tls12
                                                    | SecurityProtocolType.Ssl3;

            // #1 first initialize config
            ConfigManager.InitializeConfig();

            // PRODUCTION NEW
#if (TESTNET || TESTNETDEV || PRODUCTION_NEW)
            // on new production we allow only one instance
            try
            {
                var current = Process.GetCurrentProcess();
                foreach (var process in Process.GetProcessesByName(current.ProcessName))
                {
                    if (process.Id != current.Id)
                    {
                        // already running instance, return from Main
                        MessageBox.Show(Tr("{0} can run only one instance at a time.", NHMProductInfo.Name),
                                        Tr("{0} Already Running", NHMProductInfo.Name),
                                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }
            }
            catch { }
#else
            // PRODUCTION OLD
            // #2 check if multiple instances are allowed
            if (ConfigManager.GeneralConfig.AllowMultipleInstances == false)
            {
                try
                {
                    var current = Process.GetCurrentProcess();
                    foreach (var process in Process.GetProcessesByName(current.ProcessName))
                    {
                        if (process.Id != current.Id)
                        {
                            // already running instance, return from Main
                            return;
                        }
                    }
                }
                catch { }
            }
#endif


            // TODO set logging level
            Logger.ConfigureWithFile(ConfigManager.GeneralConfig.LogToFile, Level.Info, ConfigManager.GeneralConfig.LogMaxFileSize);

            if (ConfigManager.GeneralConfig.DebugConsole)
            {
                PInvokeHelpers.AllocConsole();
            }

            // init active display currency after config load
            ExchangeRateApi.ActiveDisplayCurrency = ConfigManager.GeneralConfig.DisplayCurrency;

            Logger.Info("NICEHASH", $"Starting up {ApplicationStateManager.Title}");

            if (!pathSet)
            {
                Logger.Info("NICEHASH", "Path not set to executable");
            }

            // check TOS
            if (ConfigManager.GeneralConfig.agreedWithTOS != ApplicationStateManager.CurrentTosVer)
            {
                Logger.Info("NICEHASH", $"TOS differs! agreed: {ConfigManager.GeneralConfig.agreedWithTOS} != Current {ApplicationStateManager.CurrentTosVer}. Showing TOS Form.");

                Application.Run(new FormEula());
                // check TOS after
                if (ConfigManager.GeneralConfig.agreedWithTOS != ApplicationStateManager.CurrentTosVer)
                {
                    Logger.Info("NICEHASH", "TOS differs AFTER TOS confirmation FORM");
                    // TOS not confirmed return from Main
                    return;
                }
            }

            // if config created show language select
            if (string.IsNullOrEmpty(ConfigManager.GeneralConfig.Language))
            {
                if (Translations.GetAvailableLanguagesNames().Count > 1)
                {
                    Application.Run(new Form_ChooseLanguage());
                }
                else
                {
                    ConfigManager.GeneralConfig.Language = "en";
                    ConfigManager.GeneralConfigFileCommit();
                }
            }
            Translations.SetLanguage(ConfigManager.GeneralConfig.Language);

            // if system requirements are not ensured it will fail the program
            var canRun = ApplicationStateManager.SystemRequirementsEnsured();
            if (!canRun)
            {
                return;
            }

            // 3rdparty miners TOS check if setting set
            if (ConfigManager.GeneralConfig.Use3rdPartyMiners == Use3rdPartyMiners.NOT_SET)
            {
                Application.Run(new Form_3rdParty_TOS());
                ConfigManager.GeneralConfigFileCommit();
            }

            // PRODUCTION
#if !(TESTNET || TESTNETDEV || PRODUCTION_NEW)
            // if no BTC address show login/register form
            if (ConfigManager.GeneralConfig.BitcoinAddress.Trim() == "")
            {
                Application.Run(new EnterBTCDialogSwitch());
            }
#endif
            Application.Run(new Form_Main());
        }
Example #50
0
 public void GetSafeFilenameTest()
 {
     Assert.AreEqual("test aaa", Paths.GetSafePathName("test >> aaa "));
 }
        static void WidenPath(GraphicsPath path, Pen pen, out List<PointF> widePoints, out List<byte> wideTypes)
        {
            widePoints = new List<PointF> ();
            wideTypes = new List<byte> ();

            var pathData = path.PathData;

            var iterator = new GraphicsPathIterator(path);
            var subPaths = iterator.SubpathCount;

            int startIndex = 0;
            int endIndex = 0;
            bool isClosed = false;

            var flattenedSubpath = new Paths();
            var offsetPaths = new Paths();

            var width = (pen.Width / 2) * scale;
            var miterLimit = pen.MiterLimit * scale;

            var joinType = JoinType.jtMiter;
            switch (pen.LineJoin)
            {
            case LineJoin.Round:
                joinType = JoinType.jtRound;
                break;
            case LineJoin.Bevel:
                joinType = JoinType.jtSquare;
                break;
            }

            for (int sp = 0; sp < subPaths; sp++)
            {

                var numOfPoints = iterator.NextSubpath(out startIndex, out endIndex, out isClosed);
                //Console.WriteLine("subPath {0} - from {1} to {2} closed {3}", sp+1, startIndex, endIndex, isClosed);

                var subPoints = pathData.Points.Skip(startIndex).Take(numOfPoints).ToArray();

                //for (int pp = startIndex; pp <= endIndex; pp++)
                //{
                //    Console.WriteLine("         {0} - {1}", pathData.Points[pp], (PathPointType)pathData.Types[pp]);
                //}

                // Load our Figure Subpath
                flattenedSubpath.Clear();
                flattenedSubpath.Add(Region.PointFArrayToIntArray(subPoints, scale));

                // Calculate the outter offset region
                var outerOffsets = Clipper.OffsetPaths(flattenedSubpath, width, joinType, EndType.etClosed, miterLimit);
                // Calculate the inner offset region
                var innerOffsets = Clipper.OffsetPaths(flattenedSubpath, -width, joinType, EndType.etClosed, miterLimit);

                // Add the offsets to our paths
                offsetPaths.AddRange(outerOffsets);

                // revers our innerOffsets so that they create a hole when filling
                Clipper.ReversePaths (innerOffsets);
                offsetPaths.AddRange(innerOffsets);

            }

            foreach (var offPath in offsetPaths)
            {
                if (offPath.Count < 1)
                    continue;

                var pointArray = Region.PathToPointFArray(offPath, scale);

                var type = (byte)PathPointType.Start;
                widePoints.Add (pointArray [0]);
                wideTypes.Add (type);

                type = (byte)PathPointType.Line;
                for (int i = 1; i < offPath.Count; i++)
                {
                    widePoints.Add (pointArray [i]);
                    wideTypes.Add (type);

                }

                if (widePoints.Count > 0)
                    wideTypes [wideTypes.Count-1] = (byte) (wideTypes [wideTypes.Count-1] | (byte) PathPointType.CloseSubpath);

            }
        }
Example #52
0
 public void FixSeparatorsTest()
 {
     Assert.AreEqual(@"D:\GOG Games\Albion\DOSBOX\dosbox.exe", Paths.FixSeparators(@"D:/GOG Games//Albion\\\DOSBOX\\dosbox.exe"));
 }
Example #53
0
 ////////////////////////////////////////////////
 static void SaveToFile(string filename, Paths ppg, int dec_places)
 {
     double scaling = Math.Pow(10, dec_places);
     StreamWriter writer = new StreamWriter(filename);
     if (writer == null) return;
     writer.Write("{0}\r\n", ppg.Count);
     foreach (Path pg in ppg)
     {
         writer.Write("{0}\r\n", pg.Count);
         foreach (IntPoint ip in pg)
             writer.Write("{0:0.####}, {1:0.####}\r\n", (double)ip.X / scaling, (double)ip.Y / scaling);
     }
     writer.Close();
 }
        async Task BuildIndexType(IList <Post> data)
        {
            {
                await BuildDataIdList(data.Where(
                                          x => x.Type is PostType.Article).ToList().Select(x => x.Id).IgnoreNull().ToArray(), Paths.GetArticleRoot(RootPath)).ConfigureAwait(false);
            }

            {
                await BuildDataIdList(data.Where(
                                          x => x.Type is PostType.Slides).ToList().Select(x => x.Id).IgnoreNull().ToArray(), Paths.GetSlidesRoot(RootPath)).ConfigureAwait(false);
            }

            {
                await BuildDataIdList(data.Where(
                                          x => x.Type is PostType.Note).ToList().Select(x => x.Id).IgnoreNull().ToArray(), Paths.GetNoteRoot(RootPath)).ConfigureAwait(false);
            }
        }
 public IEnumerator <PathEntry> GetEnumerator() => Paths.GetEnumerator();
 public PathEntry this[string system, string type] =>
 Paths.FirstOrDefault(p => p.IsSystem(system) && p.Type == type)
 ?? TryGetDebugPath(system, type);
        void PathsToInternalPath(Paths paths)
        {
            regionPath = new CGPath ();

            foreach (var poly in solution)
            {
                regionPath.MoveToPoint(IntPointToPointF(poly[0]));

                for (var p =1; p < poly.Count; p++)
                {
                    regionPath.AddLineToPoint (IntPointToPointF (poly [p]));
                }
            }
        }
        public IRequest Marshall(CreateInvalidationRequest createInvalidationRequest)
        {
            IRequest request = new DefaultRequest(createInvalidationRequest, "AmazonCloudFront");



            request.HttpMethod = "POST";
            string uriResourcePath = "2013-11-22/distribution/{DistributionId}/invalidation";

            uriResourcePath = uriResourcePath.Replace("{DistributionId}", createInvalidationRequest.IsSetDistributionId() ? createInvalidationRequest.DistributionId.ToString() : "");

            if (uriResourcePath.Contains("?"))
            {
                int    queryIndex  = uriResourcePath.IndexOf("?", StringComparison.OrdinalIgnoreCase);
                string queryString = uriResourcePath.Substring(queryIndex + 1);

                uriResourcePath = uriResourcePath.Substring(0, queryIndex);


                foreach (string s in queryString.Split('&', ';'))
                {
                    string[] nameValuePair = s.Split('=');
                    if (nameValuePair.Length == 2 && nameValuePair[1].Length > 0)
                    {
                        request.Parameters.Add(nameValuePair[0], nameValuePair[1]);
                    }
                    else
                    {
                        request.Parameters.Add(nameValuePair[0], null);
                    }
                }
            }

            request.ResourcePath = uriResourcePath;


            StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);

            using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
            {
                Encoding = System.Text.Encoding.UTF8, OmitXmlDeclaration = true
            }))
            {
                if (createInvalidationRequest != null)
                {
                    InvalidationBatch invalidationBatchInvalidationBatch = createInvalidationRequest.InvalidationBatch;
                    if (invalidationBatchInvalidationBatch != null)
                    {
                        xmlWriter.WriteStartElement("InvalidationBatch", "http://cloudfront.amazonaws.com/doc/2013-11-22/");
                        if (invalidationBatchInvalidationBatch != null)
                        {
                            Paths pathsPaths = invalidationBatchInvalidationBatch.Paths;
                            if (pathsPaths != null)
                            {
                                xmlWriter.WriteStartElement("Paths", "http://cloudfront.amazonaws.com/doc/2013-11-22/");
                                if (pathsPaths.IsSetQuantity())
                                {
                                    xmlWriter.WriteElementString("Quantity", "http://cloudfront.amazonaws.com/doc/2013-11-22/", pathsPaths.Quantity.ToString(CultureInfo.InvariantCulture));
                                }

                                if (pathsPaths != null)
                                {
                                    List <string> pathsPathsitemsList = pathsPaths.Items;
                                    if (pathsPathsitemsList != null && pathsPathsitemsList.Count > 0)
                                    {
                                        int pathsPathsitemsListIndex = 1;
                                        xmlWriter.WriteStartElement("Items", "http://cloudfront.amazonaws.com/doc/2013-11-22/");
                                        foreach (string pathsPathsitemsListValue in pathsPathsitemsList)
                                        {
                                            xmlWriter.WriteStartElement("Path", "http://cloudfront.amazonaws.com/doc/2013-11-22/");
                                            xmlWriter.WriteValue(pathsPathsitemsListValue);
                                            xmlWriter.WriteEndElement();


                                            pathsPathsitemsListIndex++;
                                        }
                                        xmlWriter.WriteEndElement();
                                    }
                                }
                                xmlWriter.WriteEndElement();
                            }
                        }
                        if (invalidationBatchInvalidationBatch.IsSetCallerReference())
                        {
                            xmlWriter.WriteElementString("CallerReference", "http://cloudfront.amazonaws.com/doc/2013-11-22/", invalidationBatchInvalidationBatch.CallerReference.ToString(CultureInfo.InvariantCulture));
                        }
                        xmlWriter.WriteEndElement();
                    }
                }
            }
            try
            {
                string content = stringWriter.ToString();
                request.Content = System.Text.Encoding.UTF8.GetBytes(content);
                request.Headers["Content-Type"] = "application/xml";
            }
            catch (EncoderFallbackException e)
            {
                throw new AmazonServiceException("Unable to marshall request to XML", e);
            }


            return(request);
        }
 public RegionEntry(RegionType type, object obj, Paths path, RegionClipType clipType)
 {
     regionType = type;
     regionObject = obj;
     regionPath = path;
     regionClipType = clipType;
 }
Example #60
0
        public static async Task MainLoop(string interpFramesPath)
        {
            try
            {
                UpdateChunkAndBufferSizes();

                interpFramesFolder = interpFramesPath;
                videoChunksFolder  = Path.Combine(interpFramesPath.GetParentDir(), Paths.chunksDir);
                if (Interpolate.currentlyUsingAutoEnc)
                {
                    Directory.CreateDirectory(videoChunksFolder);
                }

                encodedFrameLines.Clear();
                unencodedFrameLines.Clear();

                Logger.Log($"[AutoEnc] Starting AutoEncode MainLoop - Chunk Size: {chunkSize} Frames - Safety Buffer: {safetyBufferFrames} Frames", true);
                int    videoIndex = 1;
                string encFile    = Path.Combine(interpFramesPath.GetParentDir(), Paths.GetFrameOrderFilename(Interpolate.current.interpFactor));
                interpFramesLines = IOUtils.ReadLines(encFile).Select(x => x.Split('/').Last().Remove("'").Split('#').First()).ToArray();     // Array with frame filenames

                while (!Interpolate.canceled && GetInterpFramesAmount() < 2)
                {
                    await Task.Delay(2000);
                }

                int lastEncodedFrameNum = 0;

                while (HasWorkToDo())    // Loop while proc is running and not all frames have been encoded
                {
                    if (Interpolate.canceled)
                    {
                        return;
                    }

                    Logger.Log($"AutoEnc Loop iteration runs. Paused: {paused}", true);

                    if (paused)
                    {
                        await Task.Delay(200);

                        continue;
                    }

                    unencodedFrameLines.Clear();

                    for (int vfrLine = lastEncodedFrameNum; vfrLine < interpFramesLines.Length; vfrLine++)
                    {
                        unencodedFrameLines.Add(vfrLine);
                    }

                    bool aiRunning = !AiProcess.lastAiProcess.HasExited;

                    if (unencodedFrameLines.Count > 0 && (unencodedFrameLines.Count >= (chunkSize + safetyBufferFrames) || !aiRunning))     // Encode every n frames, or after process has exited
                    {
                        try
                        {
                            List <int> frameLinesToEncode = aiRunning ? unencodedFrameLines.Take(chunkSize).ToList() : unencodedFrameLines;     // Take all remaining frames if process is done
                            string     lastOfChunk        = Path.Combine(interpFramesPath, interpFramesLines[frameLinesToEncode.Last()]);

                            if (!File.Exists(lastOfChunk))
                            {
                                Logger.Log($"[AutoEnc] Last frame of chunk doesn't exist; skipping loop iteration ({lastOfChunk})", true);
                                await Task.Delay(500);

                                continue;
                            }

                            busy = true;
                            string outpath      = Path.Combine(videoChunksFolder, "chunks", $"{videoIndex.ToString().PadLeft(4, '0')}{FFmpegUtils.GetExt(Interpolate.current.outMode)}");
                            int    firstLineNum = frameLinesToEncode.First();
                            int    lastLineNum  = frameLinesToEncode.Last();
                            Logger.Log($"[AutoEnc] Encoding Chunk #{videoIndex} to '{outpath}' using line {firstLineNum} ({Path.GetFileName(interpFramesLines[firstLineNum])}) through {lastLineNum} ({Path.GetFileName(Path.GetFileName(interpFramesLines[frameLinesToEncode.Last()]))})", true, false, "ffmpeg");

                            await CreateVideo.EncodeChunk(outpath, Interpolate.current.outMode, firstLineNum, frameLinesToEncode.Count);

                            if (Interpolate.canceled)
                            {
                                return;
                            }

                            if (aiRunning && Config.GetInt("autoEncMode") == 2)
                            {
                                Task.Run(() => DeleteOldFramesAsync(interpFramesPath, frameLinesToEncode));
                            }

                            if (Interpolate.canceled)
                            {
                                return;
                            }

                            encodedFrameLines.AddRange(frameLinesToEncode);

                            Logger.Log("Done Encoding Chunk #" + videoIndex, true, false, "ffmpeg");
                            lastEncodedFrameNum = (frameLinesToEncode.Last() + 1);

                            videoIndex++;
                            busy = false;
                        }
                        catch (Exception e)
                        {
                            Logger.Log($"AutoEnc Chunk Encoding Error: {e.Message}. Stack Trace:\n{e.StackTrace}");
                            Interpolate.Cancel("Auto-Encode encountered an error.");
                        }
                    }
                    await Task.Delay(50);
                }

                if (Interpolate.canceled)
                {
                    return;
                }
                await CreateVideo.ChunksToVideos(Interpolate.current.tempFolder, videoChunksFolder, Interpolate.current.outPath);
            }
            catch (Exception e)
            {
                Logger.Log($"AutoEnc Error: {e.Message}. Stack Trace:\n{e.StackTrace}");
                Interpolate.Cancel("Auto-Encode encountered an error.");
            }
        }