コード例 #1
0
 public List <MapFile> GetFilesByExtents(Geometry.Extent2D extents)
 {
     return(MapFiles.Where(x => x.Extents.IsCrossedBy(extents)).ToList());
 }
コード例 #2
0
 public List <MapFile> GetFilesByLayers(params string[] layers)
 {
     return(MapFiles.Where(x => x.Layers.Any(y => layers.Contains(y))).ToList());
 }
コード例 #3
0
 public List <MapFile> GetFilesByLods(params int[] lods)
 {
     return(MapFiles.Where(x => x.Lods.Any(y => lods.Contains(y))).ToList());
 }
コード例 #4
0
        protected override string[] GenerateArguments()
        {
            var builder = new List <string>();

            if (Package != null)
            {
                builder.Add(ToolOptions.OutputPackage.AsArg());
                builder.Add(Package.ItemSpec);
            }

            if (Manifest != null)
            {
                builder.Add(ToolOptions.InputManifest.AsArg());
                builder.Add(Manifest.ItemSpec);
            }

            if (Assemblies != null)
            {
                foreach (var asm in Assemblies)
                {
                    builder.Add(ToolOptions.InputAssembly.AsArg());
                    builder.Add(asm.ItemSpec);
                }
            }

            if (ResourcesFolder != null)
            {
                builder.Add(ToolOptions.ResourcesFolder.AsArg());
                builder.Add(ResourcesFolder.ItemSpec);
            }

            if (DexFiles != null)
            {
                foreach (var x in DexFiles.Where(x => x != null))
                {
                    builder.Add(ToolOptions.InputCodeFile.AsArg());
                    builder.Add(x.ItemSpec);
                }
            }

            if (NativeCodeLibraries != null)
            {
                foreach (var x in NativeCodeLibraries.Where(x => x != null))
                {
                    builder.Add(ToolOptions.NativeCodeLibrary.AsArg());
                    builder.Add(x.ItemSpec);
                }
            }

            if (MapFiles != null)
            {
                foreach (var x in MapFiles.Where(x => x != null))
                {
                    builder.Add(ToolOptions.InputMapFile.AsArg());
                    builder.Add(x.ItemSpec);
                }
            }

            if (Certificate != null)
            {
                builder.Add(ToolOptions.CertificatePath.AsArg());
                builder.Add(Certificate.ItemSpec);
            }

            if (!string.IsNullOrEmpty(CertificatePassword))
            {
                builder.Add(ToolOptions.CertificatePassword.AsArg());
                builder.Add(CertificatePassword);
            }

            if (!string.IsNullOrEmpty(CertificateThumbprint))
            {
                builder.Add(ToolOptions.CertificateThumbprint.AsArg());
                builder.Add(CertificateThumbprint);
            }

            if (FreeAppsKeyPath != null)
            {
                builder.Add(ToolOptions.FreeAppsKeyPath.AsArg());
                builder.Add(FreeAppsKeyPath.ItemSpec);
            }

            if (DebugToken != null)
            {
                builder.Add(ToolOptions.DebugToken.AsArg());
                builder.Add(DebugToken.ItemSpec);
            }

            if (!string.IsNullOrEmpty(PackageName))
            {
                builder.Add(ToolOptions.PackageName.AsArg());
                builder.Add(PackageName);
            }

            builder.AddTarget();
            return(builder.ToArray());
        }