public DiskSpaceNotification(string path, PathType pathType, double freeSpaceInBytes, double freeSpaceInPercentage) { Path = path; PathType = pathType; FreeSpaceInBytes = freeSpaceInBytes; FreeSpaceInPercentage = freeSpaceInPercentage; }
private static string GetPathFromRegistry(PathType type) { var mainKey = type == PathType.User ? Registry.CurrentUser : Registry.LocalMachine; try { var subKey = mainKey.OpenSubKey(type == PathType.User ? UserPathKey : SystemPathKey); if (subKey == null) throw new Exception(); var path = subKey .GetValue("Path", "", RegistryValueOptions.DoNotExpandEnvironmentNames) as string; return path; } catch (SecurityException) { MessageBox.Show("An error has occured while trying to open registry.\n" + "Your account probably doesn't have necessary permissions."); Application.Current.Shutdown(); } catch (UnauthorizedAccessException) { MessageBox.Show("An error has occured while trying to open registry.\n" + "Your account probably doesn't have necessary permissions."); Application.Current.Shutdown(); } catch (Exception e) { MessageBox.Show("An unknown error has occured while trying to open registry:\n" + e.Message); Application.Current.Shutdown(); } return ""; }
public void AddOption(PathType type, Delivery delivery) { if (delivery == null) throw new ArgumentException("Delivery cannot be null", "delivery"); options[type] = delivery; }
private void FillPathData(Windows.UI.Xaml.Shapes.Path pathInstance, PathType typeOfPath){ var dataPath = string.Empty ; if (typeOfPath == PathType.Book) { dataPath = "M8.15192985534668,0L8.16493034362793,0 8.16493034362793,39.189998626709C8.16493034362793,39.6419982910156 8.31793022155762,40.0549983978271 8.55592918395996,40.2599983215332 8.79993057250977,40.4699993133545 9.08692932128906,40.4329986572266 9.30992889404297,40.173999786377L15.2389297485352,33.1699991226196 20.8559303283691,40.1579990386963C20.9839305877686,40.3139991760254,21.1359310150146,40.3959999084473,21.2879314422607,40.3959999084473L21.6139316558838,40.2689990997314C21.8609313964844,40.0629997253418,22.0179309844971,39.6469993591309,22.0179309844971,39.189998626709L22.0179309844971,0 52.1599340438843,0C53.090934753418,0,53.8439350128174,0.757999420166016,53.8439350128174,1.6879997253418L53.8439350128174,49.3569984436035C53.8439350128174,50.2879981994629,53.090934753418,51.0459976196289,52.1599340438843,51.0459976196289L52.1399345397949,51.0410003662109C52.0039348602295,51.0699996948242,51.8759346008301,51.0909996032715,51.7449340820313,51.0909996032715L8.14793014526367,51.0909996032715C5.61592864990234,51.0909996032715 3.5399284362793,53.0789985656738 3.39693069458008,55.5789985656738 3.39693069458008,55.7309989929199 3.40092849731445,55.8460006713867 3.40092849731445,55.9209976196289L3.39292907714844,56.0529975891113C3.49493026733398,58.5929985046387,5.58692932128906,60.6279983520508,8.14793014526367,60.6279983520508L50.4719343185425,60.6279983520508 50.4719343185425,55.9669990539551C50.4719343185425,55.0359992980957 51.2299346923828,54.2779998779297 52.1599340438843,54.2779998779297 53.090934753418,54.2779998779297 53.8439350128174,55.0359992980957 53.8439350128174,55.9669990539551L53.8439350128174,62.3120002746582C53.8439350128174,63.246997833252,53.090934753418,64,52.1599340438843,64L7.89292907714844,64 7.63792991638184,63.9749984741211C3.3879280090332,63.7070007324219,0.00792694091796875,60.1749992370605,0.00792694091796875,55.8589973449707L0.0229301452636719,55.5669975280762C-0.0290718078613281,50.5599994659424,0.0229301452636719,12.4609990119934,0.0279273986816406,8.3179988861084L0.0119285583496094,8.14099884033203C0.0119285583496094,3.65299892425537,3.6649284362793,0,8.15192985534668,0z"; } else if (typeOfPath == PathType.Key) { dataPath = "M16.547848,26.872497C14.451092,26.916562 12.365034,27.710413 10.729302,29.266098 7.2240894,32.589393 7.0834706,38.118687 10.403706,41.615683 13.72137,45.118677 19.252512,45.263676 22.752474,41.941881 26.247238,38.621584 26.401036,33.097193 23.078072,29.594298 21.314234,27.73567 18.92417,26.822555 16.547848,26.872497z M47.555126,0.0002117157C47.726013,0.0044841766,47.895291,0.073574066,48.021641,0.20638657L52.778168,5.1985388C53.03077,5.4641666,53.020371,5.888484,52.754769,6.1409225L52.232945,6.6370945 58.379608,13.115402C58.632122,13.382402,58.621121,13.806803,58.354809,14.058203L56.356011,15.956708C56.089798,16.207609,55.665879,16.197409,55.413365,15.930308L49.269745,9.4546347 48.00716,10.655153 52.407509,15.294587C52.660187,15.560289,52.649086,15.984593,52.382813,16.237495L50.384396,18.133013C50.118122,18.386015,49.694359,18.375215,49.441685,18.109612L45.04353,13.473104 30.99349,26.832494 31.170538,27.124847C35.031944,33.685067 34.017586,42.279621 28.253817,47.748075 21.549486,54.107365 10.954499,53.828564 4.5965569,47.125475 -1.7705653,40.417484 -1.4855343,29.826198 5.21898,23.462906 10.672487,18.294763 18.680851,17.507213 24.908787,20.994482L25.088602,21.09812 47.078934,0.18294907C47.211735,0.056484222,47.384236,-0.0040607452,47.555126,0.0002117157z"; } if (!string.IsNullOrEmpty(dataPath)) { var b = new Binding { Source = dataPath }; BindingOperations.SetBinding(pathInstance, Windows.UI.Xaml.Shapes.Path.DataProperty, b); } }
/// <summary> /// Create a path from XZ nodes defined in a pathFile. /// The file must be accessible from the executable environment. /// </summary> /// <param name="theStage"> "world's stage" </param> /// <param name="aPathType"> SINGLE, REVERSE, or LOOP path traversal</param> /// <param name="pathFile"> text file, each line a node of X Z values, separated by a single space </x></param> public Path(Stage theStage, PathType aPathType, string pathFile) : base(theStage) { node = new List<NavNode>(); stage = theStage; nextNode = 0; pathType = aPathType; done = false; // read file using (StreamReader fileIn = File.OpenText(pathFile)) { int x, z; string line; string[] tokens; line = fileIn.ReadLine(); do { // use default separators tokens = line.Split(new char[] { }); x = Int32.Parse(tokens[0]); z = Int32.Parse(tokens[1]); node.Add(new NavNode(new Vector3(x, 0, z), NavNode.NavNodeEnum.WAYPOINT)); line = fileIn.ReadLine(); } while (line != null); } }
internal CookieStatus(string name, string path, BrowserType browserType, PathType pathType) { _name = name; _path = path; _browserType = browserType; _pathType = pathType; _displayName = null; }
/// <summary> /// Initializes a new instance of the FileChecksum class, and loads the file's hash (computed immediately) /// </summary> /// <param name="fileName">File to compute hash of</param> /// <param name="basePath">Base path</param> /// <param name="pathType">Path type</param> /// <param name="checksumType">Checksum type</param> public FileChecksum(string fileName, string basePath, PathType pathType, ChecksumType checksumType) { FilePath = fileName; ResolvedFileName = GetFileName(FilePath, basePath, pathType); Checksum = FileUtils.GetFileChecksum(fileName, checksumType); }
public static IEnumerable<PathEntry> ReadDisabledItems(PathType type) { var name = type == PathType.User ? DisabledUserItemsFileName : DisabledSystemItemsFileName; var fullPath = Path.Combine(AppDataPath.AppDataDirPath, name); if (!File.Exists(fullPath)) return new List<PathEntry>(); return File.ReadAllLines(fullPath).Select(x => new PathEntry(x) { Enabled = false }); }
/// <summary> /// Create a path /// </summary> /// <param name="theStage"> "world's stage" </param> /// <param name="apath"> collection of nodes in path</param> /// <param name="aPathType"> SINGLE, REVERSE, or LOOP path traversal</param> public Path(Stage theStage, List<NavNode> aPath, PathType aPathType) : base(theStage) { node = aPath; nextNode = 0; pathType = aPathType; stage = theStage; done = false; }
public static void SavePathToRegistry(PathType type, string path) { #if DEBUG System.Diagnostics.Debug.WriteLine(path); #else Environment.SetEnvironmentVariable("Path", path, type == PathType.User ? EnvironmentVariableTarget.User : EnvironmentVariableTarget.Machine); #endif }
public PathElement(string name, PathType type) { if (string.IsNullOrEmpty(name) && type != PathType.Root) { throw new ArgumentException("Can't have empty name for non root path element"); } _pathType = type; _name = name; }
public static void SaveDisabledItems(PathType type, IEnumerable<PathEntry> items) { var name = type == PathType.User ? DisabledUserItemsFileName : DisabledSystemItemsFileName; var fullPath = Path.Combine(AppDataPath.AppDataDirPath, name); var disabledItems = items.Where(x => x.Enabled == false).Select(x => x.Path); File.WriteAllLines(fullPath, disabledItems); }
/** 初始化处理 */ protected virtual void Config(string vRes, PathType vType) { if (vType == PathType.localResource) { resPath = vRes; loadLinesFromResource (); readLines (); lines = null; // 处理完后清理源缓存 } }
public static PathSpec CreateTemporaryPath(PathType type) { var path = Path.GetRandomFileName(); var spec = path.ToPathSpec().Value; if (type == PathType.File) spec.Create(PathType.File); if (type == PathType.Folder) spec.Create(PathType.Folder); return spec; }
// *********************************************************************************** // CONSTRUCTOR // *********************************************************************************** public Path(PathType type, Vector3[] waypoints, int subdivisionsXSegment, Color? gizmoColor = null) { this.type = type; this.subdivisionsXSegment = subdivisionsXSegment; if (gizmoColor != null) this.gizmoColor = (Color)gizmoColor; AssignWaypoints(waypoints, true); AssignDecoder(type); if (DOTween.isUnityEditor) DOTween.GizmosDelegates.Add(Draw); }
public static bool Contains(Route route, PathType type) { for (uint i = 0x0; i < route.GetNumPaths(); i++) { PathData pathData = route.GetPathData(i); if (pathData.PathType == type) return true; } return false; }
/// <summary> /// Create a path /// </summary> /// <param name="theStage"> "world's stage" </param> /// <param name="apath"> collection of nodes in path</param> /// <param name="aPathType"> SINGLE, REVERSE, or LOOP path traversal</param> public Path(Stage theStage, List<NavNode> aPath, PathType aPathType, bool flag) : base(theStage) { node = aPath; nextNode = 0; pathType = aPathType; stage = theStage; done = false; drawFlag = flag; }
public Path(Point startPoint, Point endPoint, int radius, int width, PathType direction) { this.startPoint = startPoint; this.endPoint = endPoint; this.radius = radius; this.width = width; this.direction = direction; this.StepDistance = 40; CalculateOrigin(); this.outliner = new PathOutliner(this, this.Origin); }
/// <summary> /// Tests whether the given file contents uses the framework. /// </summary> /// <param name="fileContents">Contents of the file as a string to test.</param> /// <param name="bestGuess">True if the method should fall back from definitive to best guess detection.</param> /// <param name="pathType">The type of the file being tests</param> /// <returns>True if the file is a framework dependency, otherwise false.</returns> public virtual bool FileUsesFramework(string fileContents, bool bestGuess, PathType pathType) { if (bestGuess) { var regex = FrameworkSignatureJavaScript; return regex != null && regex.IsMatch(fileContents); } Match match = FrameworkReferenceRegex.Match(fileContents); return match.Success && match.Groups["framework"].Value.Equals(FrameworkKey, StringComparison.OrdinalIgnoreCase); }
public ScmRepository(string scmtype, string path, PathType type) { Path = DeserializePath (path); origPath = path; pathType = type; this.scmType = scmtype; Status = ScmRepositoryStatus.Unknown; statusUpdateTime = DateTime.MinValue; ActiveStatusUpdateInterval = -1; IdleStatusUpdateInterval = -1; Disable = false; }
public EventLogQuery(string path, PathType pathType, string query) { this.session = EventLogSession.GlobalSession; this.path = path; // can be null this.pathType = pathType; if (query == null) { if (path == null) throw new ArgumentNullException("path"); } else { this.query = query; } }
public static void Create(this PathSpec path, PathType pathType) { switch (pathType) { case PathType.Folder: Directory.CreateDirectory(path.ToString()); break; case PathType.File: File.WriteAllText(path.ToString(), string.Empty); break; default: throw new ArgumentException(nameof(pathType)); } }
public static void AssertBadPath( string path, PathType type) { try { ParsedPath pp = new ParsedPath(path, type); Assert.IsNotNull(pp); Assert.Fail("Badly formed path not caught"); } catch (Exception e) { Assert.IsTrue(e is ArgumentException); } }
static async Task copyToSource(PathChange change, PathType kind) { switch (kind) { case PathType.Directory: DirectorySynchronizer.createDirectory(change, change.Source); if (change.Mode == ChangeMode.Deep && change.Configuration.Sync) await sync(change); break; case PathType.File: await FileSynchronizer.copyFile(change, change.Target, change.Source); break; } }
internal EventLogInformation(EventLogSession session, string channelName, PathType pathType) { EventLogPermissionHolder.GetEventLogPermission().Demand(); EventLogHandle logHandle = NativeWrapper.EvtOpenLog(session.Handle, channelName, pathType); using (logHandle) { creationTime = (DateTime?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogCreationTime); lastAccessTime = (DateTime?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogLastAccessTime); lastWriteTime = (DateTime?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogLastWriteTime); fileSize = (long?)((ulong?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogFileSize)); fileAttributes = (int?)((uint?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogAttributes)); recordCount = (long?)((ulong?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogNumberOfLogRecords)); oldestRecordNumber = (long?)((ulong?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogOldestRecordNumber)); isLogFull = (bool?)NativeWrapper.EvtGetLogInfo(logHandle, UnsafeNativeMethods.EvtLogPropertyId.EvtLogFull); } }
/// <summary> /// Standard way of creating file paths in the Framework /// </summary> /// <param name="type">Use ConfigurableControl.PathType enum</param> /// <param name="filePath">path to process</param> /// <param name="global">non-site specific path</param> /// <param name="useSite">site specific path</param> /// <param name="useDefault"></param> /// <param name="useSection"></param> /// <returns></returns> protected virtual string GetPath( PathType type, string filePath, bool global, bool useSite, bool useDefault, bool useSection) { //check if starts with pages or content, remove "/pages/v*/" or "/content/v*/" if (filePath.StartsWith("/pages")) { filePath = filePath.Remove(0, 9); } else if (filePath.StartsWith("pages")) { filePath = filePath.Remove(0, 8); } else if (filePath.StartsWith("/content")) { filePath = filePath.Remove(0, 11); } else if (filePath.StartsWith("content")) { filePath = filePath.Remove(0, 10); } string site; //if the path is global or not site specific, set site to nothing if (useSite && !global) { site = "/" + this.Page.Site; } else { site = ""; } string rootPath = ""; switch (type) { case PathType.CONTENT: rootPath = WebInfo.ContentPath; //if pages language defined then append it to the site string language = (this.Page.Language == null) ? "" : "/" + this.Page.Language; site = site + language; break; case PathType.PAGES: if (useDefault) { site = "default"; } rootPath = WebInfo.PagesPath; break; } return string.Format("/{0}v{1}{2}{3}", rootPath, this.Page.Version, site, filePath); }
/// <summary> /// Create a path from array /// </summary> /// <param name="theStage"> "world's stage" </param> /// <param name="apath"> collection of nodes in path</param> /// <param name="pathNode"> int[x,z] array of WayPoint positions for path</param> /// <param name="aPathType"> SINGLE, REVERSE, or LOOP path traversal</param> public Path(Stage theStage, int[,] pathNode, PathType aPathType) : base(theStage) { nextNode = 0; pathType = aPathType; stage = theStage; done = false; int spacing = stage.Spacing; int x, z; // make a simple path, show how to set the type of the NavNode outside of construction. node = new List<NavNode>(); for(int i = 0; i < pathNode.Length/2; i++) { x = pathNode[i, 0]; z = pathNode[i, 1]; node.Add(new NavNode(new Vector3(x * spacing, stage.Terrain.surfaceHeight(x, z), z * spacing), NavNode.NavNodeEnum.WAYPOINT) ); } }
public static string GetPath(PathType type) { switch (type) { case PathType.Desktop: return Paths.GetDesktopPath(); break; case PathType.WindowsStartMenu: return Paths.GetWindowsStartMenuPath(); break; case PathType.UnixLocalXDGApplications: return Paths.UnixLocalXDGApplications(); break; case PathType.UnixGlobalXDGApplications: return Paths.UnixGlobalXDGApplications(); break; } return null; }
public void AddItemToFileBrowser(string name, string size, PathType type, int imageIndex) { try { ListViewItem lvi = new ListViewItem(new string[] { name, size, (type != PathType.Back) ? type.ToString() : string.Empty }) { Tag = type, ImageIndex = imageIndex }; lstDirectory.Invoke((MethodInvoker)delegate { lstDirectory.Items.Add(lvi); }); } catch (InvalidOperationException) { } }
/// <summary> /// Creates an engine of the specified directory under corpus\. /// <para /> /// The database .xml file should be in corpus\, named the same as the subdirectory. /// </summary> /// <param name="subdirectory">Subdirectory of corpus\ to use</param> /// <param name="excludePattern">Exclude pattern</param> /// <param name="matchPattern">Match pattern</param> /// <param name="matchType">Match type</param> /// <param name="pathType">Path type</param> /// <param name="checksumType">Checksum type</param> /// <returns>Checksum Engine</returns> protected static Engine CreateEngine( string subdirectory, string excludePattern = "", string matchPattern = "*", MatchType matchType = MatchType.Wildcard, PathType pathType = PathType.RelativePath, ChecksumType checksumType = ChecksumType.MD5) { Engine engine = new Engine( GetCorpusDatabase(subdirectory), new NullReporter(), GetCorpusDirectory(subdirectory), excludePattern, matchPattern, matchType, pathType, checksumType); return engine; }
protected override HitObject CreateSlider(Vector2 position, bool newCombo, int comboOffset, Vector2[] controlPoints, double length, PathType pathType, int repeatCount, List <List <SampleInfo> > nodeSamples) { return(new ConvertSlider { X = position.X, ControlPoints = controlPoints, Distance = length, PathType = pathType, NodeSamples = nodeSamples, RepeatCount = repeatCount }); }
public static Sprite[] GetPathSprite(PathType type) { LazyInit(); return(pathSprites[type]); }
public SvnRepository(string path, PathType type) : base("Svn", path, type) { }
public TestContext BuildContext(IEnumerable <PathInfo> files, TestOptions options) { if (files == null) { throw new ArgumentNullException("testFilePathInfo"); } if (!files.Any()) { ChutzpahTracer.TraceInformation("No files given to build test context for"); return(null); } var fileCount = files.Count(); var allFilePathString = string.Join(",", files.Select(x => x.FullPath)); ChutzpahTracer.TraceInformation("Building test context for '{0}'", allFilePathString); // Make sure all test paths have been resolved to real files var missingPaths = files.Where(x => x.FullPath == null).ToList(); if (missingPaths.Any()) { throw new FileNotFoundException("Unable to find files: " + string.Join(",", missingPaths.Select(x => x.Path))); } // Make sure all test paths have a valid file type if (!files.Select(x => x.Type).All(IsValidTestPathType)) { throw new ArgumentException("Expecting a .js, .ts, .coffee or .html file or a url"); } if (fileCount > 1 && files.Any(x => x.Type == PathType.Url || x.Type == PathType.Html)) { throw new InvalidOperationException("Cannot build a batch context for Url or Html test files"); } // We use the first file's directory to find the chutzpah.json file and to test framework // since we assume all files in the batch must have the same values for those PathType firstFileKind = files.First().Type; string firstFilePath = files.First().FullPath; var chutzpahTestSettings = settingsService.FindSettingsFile(firstFilePath, options.ChutzpahSettingsFileEnvironments); // Exclude any files that are not included based on the settings file var testedPaths = files.Select(f => new { File = f, IsIncluded = IsTestPathIncluded(f.FullPath, chutzpahTestSettings) }).ToList(); if (testedPaths.Any(x => !x.IsIncluded)) { var pathString = string.Join(",", testedPaths.Where(x => !x.IsIncluded).Select(x => x.File.FullPath)); ChutzpahTracer.TraceInformation("Excluding test files {0} given chutzpah.json settings", pathString); files = testedPaths.Where(x => x.IsIncluded).Select(x => x.File).ToList(); if (!files.Any()) { return(null); } } string firstTestFileText; if (firstFileKind == PathType.Url) { firstTestFileText = httpClient.GetContent(firstFilePath); } else { firstTestFileText = fileSystem.GetText(firstFilePath); } IFrameworkDefinition definition; if (TryDetectFramework(firstTestFileText, firstFileKind, chutzpahTestSettings, out definition)) { // For HTML test files we don't need to create a test harness to just return this file if (firstFileKind == PathType.Html || firstFileKind == PathType.Url) { ChutzpahTracer.TraceInformation("Test kind is {0} so we are trusting the supplied test harness and not building our own", firstFileKind); return(new TestContext { ReferencedFiles = new List <ReferencedFile> { new ReferencedFile { IsFileUnderTest = true, Path = firstFilePath } }, InputTestFiles = new[] { firstFilePath }, FirstInputTestFile = firstFilePath, InputTestFilesString = firstFilePath, TestHarnessPath = firstFilePath, IsRemoteHarness = firstFileKind == PathType.Url, TestRunner = definition.GetTestRunner(chutzpahTestSettings), }); } var temporaryFiles = new List <string>(); string firstInputTestFileDir = Path.GetDirectoryName(firstFilePath); var testHarnessDirectory = GetTestHarnessDirectory(chutzpahTestSettings, firstInputTestFileDir); var referencedFiles = GetFilesUnderTest(files, chutzpahTestSettings).ToList(); referenceProcessor.GetReferencedFiles(referencedFiles, definition, chutzpahTestSettings); IEnumerable <string> deps = definition.GetFileDependencies(chutzpahTestSettings); var coverageEngine = SetupCodeCoverageEngine(options, chutzpahTestSettings, definition, referencedFiles); AddTestFrameworkDependencies(deps, referencedFiles); var testFiles = referencedFiles.Where(x => x.IsFileUnderTest).Select(x => x.Path).ToList(); return(new TestContext { FrameworkDefinition = definition, CoverageEngine = coverageEngine, InputTestFiles = testFiles, FirstInputTestFile = testFiles.FirstOrDefault(), InputTestFilesString = string.Join(",", testFiles), TestHarnessDirectory = testHarnessDirectory, ReferencedFiles = referencedFiles, TestRunner = definition.GetTestRunner(chutzpahTestSettings), TemporaryFiles = temporaryFiles, TestFileSettings = chutzpahTestSettings }); } else { ChutzpahTracer.TraceWarning("Failed to detect test framework for '{0}'", firstFilePath); } return(null); }
public Boolean IsValidPath(PathType type, PathStatus status) { return(PathUtils.IsValidPath(Text, type, status)); }
public string GetPath(int tutorialId, PathType pType) { switch (tutorialId) { case 0: break; case 1: switch (pType) { case PathType.BaseSolutionFolder: return(_commonTutorialPath + "\\Tutorial1_EssentialShortcuts"); case PathType.BaseContentFolder: return(_commonTutorialPath + "\\Content\\Tutorial1"); case PathType.BaseSolutionFile: return(_commonTutorialPath + "\\Tutorial1_EssentialShortcuts\\Tutorial1_EssentialShortcuts.sln"); case PathType.BaseContentFile: return(_commonTutorialPath + "\\Content\\Tutorial1\\Tutorial1Content.xml"); case PathType.WorkCopySolutionFolder: return(_commonWorkCopyPath + "\\Tutorial1_EssentialShortcuts"); case PathType.WorkCopyContentFolder: return(_commonWorkCopyPath + "\\Content\\Tutorial1"); case PathType.WorkCopySolutionFile: return(_commonWorkCopyPath + "\\Tutorial1_EssentialShortcuts\\Tutorial1_EssentialShortcuts.sln"); case PathType.WorkCopyContentFile: return(_commonWorkCopyPath + "\\Content\\Tutorial1\\Tutorial1Content.xml"); default: throw new ArgumentOutOfRangeException(nameof(pType), pType, null); } case 2: break; case 3: switch (pType) { case PathType.BaseSolutionFolder: return(_commonTutorialPath + "\\Tutorial3_WhatsNewReSharper2016.3"); case PathType.BaseContentFolder: return(_commonTutorialPath + "\\Content\\Tutorial3"); case PathType.BaseSolutionFile: return(_commonTutorialPath + "\\Tutorial3_WhatsNewReSharper2016.3\\Tutorial3_WhatsNewReSharper2016.3.sln"); case PathType.BaseContentFile: return(_commonTutorialPath + "\\Content\\Tutorial3\\Tutorial3Content.xml"); case PathType.WorkCopySolutionFolder: return(_commonWorkCopyPath + "\\Tutorial3_WhatsNewReSharper2016.3"); case PathType.WorkCopyContentFolder: return(_commonWorkCopyPath + "\\Content\\Tutorial3"); case PathType.WorkCopySolutionFile: return(_commonWorkCopyPath + "\\Tutorial3_WhatsNewReSharper2016.3\\Tutorial3_WhatsNewReSharper2016.3.sln"); case PathType.WorkCopyContentFile: return(_commonWorkCopyPath + "\\Content\\Tutorial3\\Tutorial3Content.xml"); default: throw new ArgumentOutOfRangeException(nameof(pType), pType, null); } case 4: switch (pType) { case PathType.BaseSolutionFolder: return(_commonTutorialPath + "\\Tutorial4_WhatsNewReSharper2017.1"); case PathType.BaseContentFolder: return(_commonTutorialPath + "\\Content\\Tutorial4"); case PathType.BaseSolutionFile: return(_commonTutorialPath + "\\Tutorial4_WhatsNewReSharper2017.1\\Tutorial4_WhatsNewReSharper2017.1.sln"); case PathType.BaseContentFile: return(_commonTutorialPath + "\\Content\\Tutorial4\\Tutorial4Content.xml"); case PathType.WorkCopySolutionFolder: return(_commonWorkCopyPath + "\\Tutorial4_WhatsNewReSharper2017.1"); case PathType.WorkCopyContentFolder: return(_commonWorkCopyPath + "\\Content\\Tutorial4"); case PathType.WorkCopySolutionFile: return(_commonWorkCopyPath + "\\Tutorial4_WhatsNewReSharper2017.1\\Tutorial4_WhatsNewReSharper2017.1.sln"); case PathType.WorkCopyContentFile: return(_commonWorkCopyPath + "\\Content\\Tutorial4\\Tutorial4Content.xml"); default: throw new ArgumentOutOfRangeException(nameof(pType), pType, null); } case 5: break; } return(null); }
public void ExportLogAndMessages(string path, PathType pathType, string query, string targetFilePath) { this.ExportLogAndMessages(path, pathType, query, targetFilePath, false, CultureInfo.CurrentCulture); }
public SliderPath(PathType type, Vector2[] controlPoints, double?expectedDistance = null) : this(controlPoints.Select((c, i) => new PathControlPoint(c, i == 0 ? (PathType?)type : null)).ToArray(), expectedDistance) { }
// *********************************************************************************** // CONSTRUCTOR // *********************************************************************************** /// <summary> /// Creates a new <see cref="PathPreview" /> based on the given array of <see cref="Vector3" /> points. /// </summary> /// <param name="p_type">Type of path</param> /// <param name="p_path"> /// The <see cref="Vector3" /> array used to create the path. /// </param> public PathPreview(PathType p_type, params Vector3[] p_path) { pathType = p_type; path = new Vector3[p_path.Length]; Array.Copy(p_path, path, path.Length); }
//##### Main path request method ##### public void RequestPath(Vector3 pathStart, Vector3 pathEnd, Action <List <Node>, Vector3[], bool> callback, PathType pathType) { ThreadStart threadStart = delegate { FindPath(pathStart, pathEnd, callback, pathType); //Method on other page }; threadStart.Invoke(); }
/// <summary>Creates a new instance of <see cref="DecompilerContext"/>.</summary> /// <param name="InputPath">The input path that points to a folder/file.</param> /// <param name="PathInputType">The type of path being inputted.</param> public DecompilerContext(String InputPath = "", PathType PathInputType = PathType.File) { this._Path = InputPath; this._PathType = PathInputType; }
public override HitObject Parse(string text) { string[] split = text.Split(','); Vector2 pos = new Vector2((int)Parsing.ParseFloat(split[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseFloat(split[1], Parsing.MAX_COORDINATE_VALUE)); double startTime = Parsing.ParseDouble(split[2]) + Offset; LegacyHitObjectType type = (LegacyHitObjectType)Parsing.ParseInt(split[3]); int comboOffset = (int)(type & LegacyHitObjectType.ComboOffset) >> 4; type &= ~LegacyHitObjectType.ComboOffset; bool combo = type.HasFlag(LegacyHitObjectType.NewCombo); type &= ~LegacyHitObjectType.NewCombo; var soundType = (LegacyHitSoundType)Parsing.ParseInt(split[4]); var bankInfo = new SampleBankInfo(); HitObject result = null; if (type.HasFlag(LegacyHitObjectType.Circle)) { result = CreateHit(pos, combo, comboOffset); if (split.Length > 5) { readCustomSampleBanks(split[5], bankInfo); } } else if (type.HasFlag(LegacyHitObjectType.Slider)) { PathType pathType = PathType.Catmull; double? length = null; string[] pointSplit = split[5].Split('|'); int pointCount = 1; foreach (var t in pointSplit) { if (t.Length > 1) { pointCount++; } } var points = new Vector2[pointCount]; int pointIndex = 1; foreach (string t in pointSplit) { if (t.Length == 1) { switch (t) { case @"C": pathType = PathType.Catmull; break; case @"B": pathType = PathType.Bezier; break; case @"L": pathType = PathType.Linear; break; case @"P": pathType = PathType.PerfectCurve; break; } continue; } string[] temp = t.Split(':'); points[pointIndex++] = new Vector2((int)Parsing.ParseDouble(temp[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseDouble(temp[1], Parsing.MAX_COORDINATE_VALUE)) - pos; } int repeatCount = Parsing.ParseInt(split[6]); if (repeatCount > 9000) { throw new FormatException(@"Repeat count is way too high"); } // osu-stable treated the first span of the slider as a repeat, but no repeats are happening repeatCount = Math.Max(0, repeatCount - 1); if (split.Length > 7) { length = Math.Max(0, Parsing.ParseDouble(split[7], Parsing.MAX_COORDINATE_VALUE)); if (length == 0) { length = null; } } if (split.Length > 10) { readCustomSampleBanks(split[10], bankInfo); } // One node for each repeat + the start and end nodes int nodes = repeatCount + 2; // Populate node sample bank infos with the default hit object sample bank var nodeBankInfos = new List <SampleBankInfo>(); for (int i = 0; i < nodes; i++) { nodeBankInfos.Add(bankInfo.Clone()); } // Read any per-node sample banks if (split.Length > 9 && split[9].Length > 0) { string[] sets = split[9].Split('|'); for (int i = 0; i < nodes; i++) { if (i >= sets.Length) { break; } SampleBankInfo info = nodeBankInfos[i]; readCustomSampleBanks(sets[i], info); } } // Populate node sound types with the default hit object sound type var nodeSoundTypes = new List <LegacyHitSoundType>(); for (int i = 0; i < nodes; i++) { nodeSoundTypes.Add(soundType); } // Read any per-node sound types if (split.Length > 8 && split[8].Length > 0) { string[] adds = split[8].Split('|'); for (int i = 0; i < nodes; i++) { if (i >= adds.Length) { break; } int.TryParse(adds[i], out var sound); nodeSoundTypes[i] = (LegacyHitSoundType)sound; } } // Generate the final per-node samples var nodeSamples = new List <IList <HitSampleInfo> >(nodes); for (int i = 0; i < nodes; i++) { nodeSamples.Add(convertSoundType(nodeSoundTypes[i], nodeBankInfos[i])); } result = CreateSlider(pos, combo, comboOffset, convertControlPoints(points, pathType), length, repeatCount, nodeSamples); // The samples are played when the slider ends, which is the last node result.Samples = nodeSamples[^ 1];
public EventLogQuery(string path, PathType pathType) : this(path, pathType, null) { }
public static void AddPathSprite(PathType type, DungeonSet set) { dungeonSets.Add(type, set); }
public override void Reset() { base.Reset(); gameObject = null; duration = new FsmFloat { UseVariable = false }; setSpeedBased = new FsmBool { UseVariable = false, Value = false }; pathType = PathType.Linear; pathMode = PathMode.Full3D; resolution = new FsmInt { UseVariable = false, Value = 10 }; gizmoColor = new FsmColor { UseVariable = false }; closePath = new FsmBool { UseVariable = false, Value = false }; lockPosition = AxisConstraint.None; lockRotation = AxisConstraint.None; lookAt = LookAt.nothing; lookAtPosition = new FsmVector3 { UseVariable = false, Value = Vector3.zero }; lookAtTarget = new FsmGameObject { UseVariable = false, Value = null }; lookAhead = new FsmFloat { UseVariable = false, Value = 0 }; forwardDirection = new FsmVector3 { UseVariable = false, Value = Vector3.forward }; up = new FsmVector3 { UseVariable = false, Value = Vector3.up }; startEvent = null; finishEvent = null; finishImmediately = new FsmBool { UseVariable = false, Value = false }; startDelay = new FsmFloat { Value = 0 }; easeType = Ease.Linear; loops = new FsmInt { Value = 0 }; loopType = LoopType.Restart; autoKillOnCompletion = new FsmBool { Value = true }; recyclable = new FsmBool { Value = false }; updateType = UpdateType.Normal; isIndependentUpdate = new FsmBool { Value = false }; debugThis = new FsmBool { Value = false }; }
public EventLogReader(string path, PathType pathType) : this(new EventLogQuery(path, pathType), null) { }
public PathInfo(PathType type, string path) { Type = type; Path = path; }
public CompareTextLine(string line) { Line = line; Hash = line.Replace("\t", " ").GetHashCode(); Type = PathType.File; }
public void ExportLogAndMessages(string path, PathType pathType, string query, string targetFilePath, bool tolerateQueryErrors, CultureInfo targetCultureInfo) { ExportLog(path, pathType, query, targetFilePath, tolerateQueryErrors); // Ignore the CultureInfo, pass 0 to use the calling thread's locale NativeWrapper.EvtArchiveExportedLog(this.Handle, targetFilePath, 0, 0); }
internal static partial EventLogHandle EvtOpenLog( EventLogHandle session, [MarshalAs(UnmanagedType.LPWStr)] string path, PathType flags);
public void ExportLog(string path, PathType pathType, string query, string targetFilePath) { this.ExportLog(path, pathType, query, targetFilePath, false); }
///<summary>Main method for starting the pathfinding process.</summary> ///<param name="pathStart">Starting coords</param> ///<param name="pathEnd">Ending coords</param> ///<param name="callback">Callback delegate</param> ///<param name="pathType">Type of path</param> public void FindPath(Vector3 pathStart, Vector3 pathEnd, Action <List <Node>, Vector3[], bool> callback, PathType pathType) { List <Node> nodeWaypoints = new List <Node>(); //All waypoints as Node Vector3[] waypoints = new Vector3[0]; //All waypoints as Vector3 bool pathSuccess = false; //By default the pathSuccess will be false Node startNode = Grid.main.NodeFromWorldPoint(pathStart); //The starting node Node endNode = Grid.main.NodeFromWorldPoint(pathEnd); //The ending node if (pathType == PathType.PointToPoint) { if (CreatePath(startNode, endNode)) { List <Node> waypointNodes = RetracePath(startNode, endNode); List <Node> waypointSimpilifyed = SimplifyPath(waypointNodes); waypoints = ExtractPath(waypointSimpilifyed); } } else if (pathType == PathType.AllPoints) { if (CreatePath(startNode, endNode)) { List <Node> waypointNodes = RetracePath(startNode, endNode); waypoints = ExtractPath(waypointNodes); nodeWaypoints = waypointNodes; //Info } } else if (pathType == PathType.EndOfTheLine) { if (CreatePath(startNode, endNode, true)) { List <Node> waypointNodes = RetracePath(startNode, endNode); //If the last node is unwalkable (Special feature) if (!waypointNodes[0].isWalkable) { UnityEngine.Debug.Log("Last node is unwalkable!"); List <Node> waypointNodes2 = new List <Node>(); bool delNodes = true; //Node: WAYPOINTS IS BACKWARDS RIGHT NOW foreach (Node node in waypointNodes) { //The first iteration should always be true VVV if (!node.isWalkable && delNodes) { } else { delNodes = false; waypointNodes2.Add(node); } } Node startWaypointNode = waypointNodes2[waypointNodes2.Count - 1]; Node endWaypointNode = waypointNodes2[0]; //AllPoints if (CreatePath(startWaypointNode, endWaypointNode)) { List <Node> waypointNodes3 = RetracePath(startWaypointNode, endWaypointNode); waypoints = ExtractPath(waypointNodes3); } } //If the last node is walkable (Special feature not applyed) else { //Normal PointToPoint if (CreatePath(startNode, endNode)) { List <Node> waypointNodes2 = RetracePath(startNode, endNode); List <Node> waypointSimpilifyed = SimplifyPath(waypointNodes2); waypoints = ExtractPath(waypointSimpilifyed); } } //Node: WAYPOINTS IS BACKWARDS RIGHT NOW for (int i = 0; i < waypointNodes.Count; i++) { Node currentNode = waypointNodes[i]; if (!currentNode.isWalkable && i == 0) { //UnityEngine.Debug.Log("Last node is unwalkable"); } } } } if (waypoints.Length > 0) { pathSuccess = true; } else { pathSuccess = false; } //Method message OnFinishedProcessingPath(new PathResult(nodeWaypoints, waypoints, pathSuccess, callback)); //Method on other page }
private static void RegisterPath(string path, PathType pathType, Action action) { // Check for duplicates bool duplicateFound = false; ActionOnRecursiveMenuItems(Instance.menus, x => { if (x.path == path) { duplicateFound = true; Debug.LogError($"The {pathType} \"{path}\" already exists."); return; } }); if (duplicateFound) { return; } // Get all items in the path var split = path.Split('/'); string menu = split[0]; string item = split[split.Length - 1]; // Determine path type MenuType menuType = pathType == PathType.Action ? MenuType.Action : MenuType.Window; if (split.Length == 1) { if (!Instance.menus.Any(x => x.name == menu)) { Instance.menus.Add(new MenuItem(menu, menuType, action)); } var endMenu = Instance.menus.First(x => x.name == menu); if (endMenu.menuType == MenuType.Window) { Instance.windows.Add(endMenu); } } else { // Find the menu if (!Instance.menus.Any(x => x.name == menu)) { Instance.menus.Add(new MenuItem(menu, MenuType.Menu)); } var rootMenu = Instance.menus.First(x => x.name == menu); // Start at the root and work down adding sub menus MenuItem parent = rootMenu; for (int i = 1; i < split.Length; i++) { // If the submenu doesn't exist, add it if (!parent.menuItems.Any(x => x.name == split[i])) { if (i == split.Length - 1) { parent.menuItems.Add(new MenuItem(split[i], menuType, action, parent)); var endMenu = parent.menuItems.First(x => x.name == split[i]); if (endMenu.menuType == MenuType.Window) { Instance.windows.Add(endMenu); } } else { parent.menuItems.Add(new MenuItem(split[i], MenuType.SubMenu, parent)); } } // Set the new parent parent = parent.menuItems.First(x => x.name == split[i]); } } }
public LuzMovingPlatformPath(BinaryReader reader, uint version, NiString pathName, PathType type) : base(reader, version, pathName, type) { if (Version >= 18) { reader.ReadByte(); } else if (Version >= 13) { MovingPlatformSound = new NiString(reader, true, true); } }
public void calculatePath() { Vector2 currentDir = Utilities.FlattenedDir2D(redirectionManager.currDirReal).normalized; Vector2 currentPos = Utilities.FlattenedPos2D(redirectionManager.currPosReal); float x1 = currentPos.x, y1 = currentPos.y; //(x1, y1) + m*(s1,t1) = (x2,y2)+n*(s2,t2) float x2 = targetPos.x, y2 = targetPos.y; float s1 = currentDir.x, t1 = currentDir.y; //(s1,t1)是当前方向单位向量 float s2 = targetDir.x, t2 = targetDir.y; float D = s1 * (-t2) + s2 * t1; //用cramer法则,用行列式算m,n float D1 = (x2 - x1) * (-t2) + s2 * (y2 - y1); float D2 = s1 * (y2 - y1) - t1 * (x2 - x1); float m = D1 / D; float n = D2 / D; if (Vector2.Dot(currentDir, targetDir) > 0 && m > 0 && n < 0) //a,b情况 { Vector2 targetOrthoDir = new Vector2(-targetDir.y, targetDir.x).normalized; //目标点的法向量,方向可能有两个 targetOrthoDir = Mathf.Sign(Vector2.Dot(targetOrthoDir, currentDir)) * targetOrthoDir; //确定目标点的法向量方向 Vector2 currentOrthoDir = new Vector2(-currentDir.y, currentDir.x).normalized; //当前方向的法向量 currentOrthoDir = Mathf.Sign(Vector2.Dot(currentOrthoDir, targetDir)) * currentOrthoDir; //法向量有两个,选对的那个 float u1 = currentOrthoDir.x, v1 = currentOrthoDir.y; //(u1,v1)为(s1,t1)法向量 float u2 = targetOrthoDir.x, v2 = targetOrthoDir.y; //(u2,v2)为(s2,t2)法向量 //(x2-x1-u1*r,y2-y1-v1*r)·(u2,v2) = r r = ((x2 - x1) * u2 + (y2 - y1) * v2) / (1 + u1 * u2 + v1 * v2); //求出半径 Vector2 tangentPos = currentPos + (currentOrthoDir * (float)r) + r * targetOrthoDir; //为a中大圆弧切点的位置 if ((targetPos - tangentPos).x / targetDir.x > 0) //a情况 { pathType = PathType.a; middlePos = tangentPos; } else//b情况 { pathType = PathType.b; //(x1,y1)+p(s1,t1)+r(u1,v1)+r(u2,v2)=(x2,y2)可解出p,r float d = s1 * (v1 + v2) - t1 * (u1 + u2);//利用cramer法则,算行列式 float d1 = (x2 - x1) * (v1 + v2) - (y2 - y1) * (u1 + u2); float d2 = s1 * (y2 - y1) - t1 * (x2 - x1); float p = d1 / d; r = d2 / d; middlePos = currentPos + p * currentDir; } } else if (m < 0 && n < 0) //c情况 { //假设两个圆弧半径相等 pathType = PathType.c; Vector2 targetOrthoDir = new Vector2(-targetDir.y, targetDir.x).normalized; //目标点的法向量,方向可能有两个 targetOrthoDir = Mathf.Sign(Vector2.Dot(targetOrthoDir, currentDir)) * targetOrthoDir; //确定目标点的法向量方向 Vector2 currentOrthoDir = new Vector2(-currentDir.y, currentDir.x).normalized; //当前方向的法向量 currentOrthoDir = Mathf.Sign(Vector2.Dot(currentOrthoDir, targetDir)) * currentOrthoDir; //法向量有两个,选对的那个 float u1 = currentOrthoDir.x, v1 = currentOrthoDir.y; //(u1,v1)为(s1,t1)法向量 float u2 = targetOrthoDir.x, v2 = targetOrthoDir.y; //(u2,v2)为(s2,t2)法向量 //|(x2+ru2-x1-ru1,y2+rv2-y1-rv1)|=2r 假设两个圆弧半径相等 float a = Mathf.Pow((u2 - u1), 2) + Mathf.Pow(v2 - v1, 2) - 4; float b = 2 * (x2 - x1) * (u2 - u1) + 2 * (y2 - y1) * (v2 - v1); float c = Mathf.Pow((x2 - x1), 2) + Mathf.Pow(y2 - y1, 2); r = solveEquation(a, b, c); middlePos = (currentPos + r * currentOrthoDir + targetPos + targetOrthoDir * r) / 2; } else//d情况 { pathType = PathType.d; Vector2 targetOrthoDir = new Vector2(-targetDir.y, targetDir.x).normalized; //目标点的法单位向量,方向可能有两个 targetOrthoDir = -Mathf.Sign(Vector2.Dot(targetOrthoDir, currentDir)) * targetOrthoDir; //确定目标点的法向量方向 Vector2 currentOrthoDir = new Vector2(-currentDir.y, currentDir.x).normalized; //当前方向的法向量 currentOrthoDir = -Mathf.Sign(Vector2.Dot(currentOrthoDir, targetDir)) * currentOrthoDir; //法向量有两个,选对的那个 float u1 = currentOrthoDir.x, v1 = currentOrthoDir.y; //(u1,v1)为(s1,t1)法向量 float u2 = targetOrthoDir.x, v2 = targetOrthoDir.y; //(u2,v2)为(s2,t2)法向量 //(x1,y1)+p(s1,t1)+r(u1,v1)+r(u2,v2)=(x2,y2)可解出p,r float d = s1 * (v1 + v2) - t1 * (u1 + u2); //利用cramer法则,算行列式 float d1 = (x2 - x1) * (v1 + v2) - (y2 - y1) * (u1 + u2); float d2 = s1 * (y2 - y1) - t1 * (x2 - x1); float p = d1 / d; r = d2 / d; middlePos = currentPos + p * currentDir; } //不考虑e情况,因为可以把e情况当a情况考虑,虽然可能会有圆弧的曲率过大,但是这篇论文算法本身就不能保证所有路径曲率在max范围内 }
/// <summary> /// Initializes a new <see cref="ConfigurationOptionAttribute"/> that represents a path. /// Represents one option in an emulator configuration inside a configuration section. /// Typically configuration options must be a double, bool, integer or an enum value in order to be safe, /// type information may be lost when serializing into a wire format. /// </summary> /// <param name="optionName">The name of the option</param> /// <param name="default">The default value of the option. Note that only strings, enums and primitive types are supported.</param> /// <param name="pathType">The type of the path this points to.</param> public ConfigurationOptionAttribute(string optionName, string @default, PathType pathType) : this(optionName, @default, typeof(string)) { this.PathType = pathType; }
public static void AddPathSprite(PathType type, Sprite[] sprites) { pathSprites.Add(type, sprites); }
/// <summary> /// Constructs a path /// </summary> /// <param name="path"></param> /// <param name="type"></param> public FilesystemDynamicPath(string path, PathType type) { Platform.CheckForEmptyString(path, "path"); _path = path; _type = type; }
static int BezierMove(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (count == 10 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.GameObject), typeof(UnityEngine.Vector3), typeof(float), typeof(InterpType), typeof(RepeatType), typeof(bool), typeof(PathType), typeof(UnityEngine.Vector3[]), typeof(AnimCallBack), typeof(object[]))) { UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.ToObject(L, 1); UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)ToLua.ToObject(L, 2); float arg2 = (float)LuaDLL.lua_tonumber(L, 3); InterpType arg3 = (InterpType)ToLua.ToObject(L, 4); RepeatType arg4 = (RepeatType)ToLua.ToObject(L, 5); bool arg5 = LuaDLL.lua_toboolean(L, 6); PathType arg6 = (PathType)ToLua.ToObject(L, 7); UnityEngine.Vector3[] arg7 = ToLua.CheckObjectArray <UnityEngine.Vector3>(L, 8); AnimCallBack arg8 = null; LuaTypes funcType9 = LuaDLL.lua_type(L, 9); if (funcType9 != LuaTypes.LUA_TFUNCTION) { arg8 = (AnimCallBack)ToLua.ToObject(L, 9); } else { LuaFunction func = ToLua.ToLuaFunction(L, 9); arg8 = DelegateFactory.CreateDelegate(typeof(AnimCallBack), func) as AnimCallBack; } object[] arg9 = ToLua.CheckObjectArray(L, 10); AnimData o = AnimSystem.BezierMove(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); ToLua.PushObject(L, o); return(1); } else if (count == 10 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.GameObject), typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(float), typeof(InterpType), typeof(bool), typeof(PathType), typeof(UnityEngine.Vector3[]), typeof(AnimCallBack), typeof(object[]))) { UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.ToObject(L, 1); UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)ToLua.ToObject(L, 2); UnityEngine.Vector3 arg2 = (UnityEngine.Vector3)ToLua.ToObject(L, 3); float arg3 = (float)LuaDLL.lua_tonumber(L, 4); InterpType arg4 = (InterpType)ToLua.ToObject(L, 5); bool arg5 = LuaDLL.lua_toboolean(L, 6); PathType arg6 = (PathType)ToLua.ToObject(L, 7); UnityEngine.Vector3[] arg7 = ToLua.CheckObjectArray <UnityEngine.Vector3>(L, 8); AnimCallBack arg8 = null; LuaTypes funcType9 = LuaDLL.lua_type(L, 9); if (funcType9 != LuaTypes.LUA_TFUNCTION) { arg8 = (AnimCallBack)ToLua.ToObject(L, 9); } else { LuaFunction func = ToLua.ToLuaFunction(L, 9); arg8 = DelegateFactory.CreateDelegate(typeof(AnimCallBack), func) as AnimCallBack; } object[] arg9 = ToLua.CheckObjectArray(L, 10); AnimData o = AnimSystem.BezierMove(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); ToLua.PushObject(L, o); return(1); } else if (count == 11 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.GameObject), typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(float), typeof(float), typeof(InterpType), typeof(bool), typeof(PathType), typeof(float[]), typeof(AnimCallBack), typeof(object[]))) { UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.ToObject(L, 1); UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)ToLua.ToObject(L, 2); UnityEngine.Vector3 arg2 = (UnityEngine.Vector3)ToLua.ToObject(L, 3); float arg3 = (float)LuaDLL.lua_tonumber(L, 4); float arg4 = (float)LuaDLL.lua_tonumber(L, 5); InterpType arg5 = (InterpType)ToLua.ToObject(L, 6); bool arg6 = LuaDLL.lua_toboolean(L, 7); PathType arg7 = (PathType)ToLua.ToObject(L, 8); float[] arg8 = ToLua.CheckNumberArray <float>(L, 9); AnimCallBack arg9 = null; LuaTypes funcType10 = LuaDLL.lua_type(L, 10); if (funcType10 != LuaTypes.LUA_TFUNCTION) { arg9 = (AnimCallBack)ToLua.ToObject(L, 10); } else { LuaFunction func = ToLua.ToLuaFunction(L, 10); arg9 = DelegateFactory.CreateDelegate(typeof(AnimCallBack), func) as AnimCallBack; } object[] arg10 = ToLua.CheckObjectArray(L, 11); AnimData o = AnimSystem.BezierMove(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); ToLua.PushObject(L, o); return(1); } else if (count == 11 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.GameObject), typeof(UnityEngine.Vector3), typeof(float), typeof(RepeatType), typeof(InterpType), typeof(float), typeof(bool), typeof(PathType), typeof(float[]), typeof(AnimCallBack), typeof(object[]))) { UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.ToObject(L, 1); UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)ToLua.ToObject(L, 2); float arg2 = (float)LuaDLL.lua_tonumber(L, 3); RepeatType arg3 = (RepeatType)ToLua.ToObject(L, 4); InterpType arg4 = (InterpType)ToLua.ToObject(L, 5); float arg5 = (float)LuaDLL.lua_tonumber(L, 6); bool arg6 = LuaDLL.lua_toboolean(L, 7); PathType arg7 = (PathType)ToLua.ToObject(L, 8); float[] arg8 = ToLua.CheckNumberArray <float>(L, 9); AnimCallBack arg9 = null; LuaTypes funcType10 = LuaDLL.lua_type(L, 10); if (funcType10 != LuaTypes.LUA_TFUNCTION) { arg9 = (AnimCallBack)ToLua.ToObject(L, 10); } else { LuaFunction func = ToLua.ToLuaFunction(L, 10); arg9 = DelegateFactory.CreateDelegate(typeof(AnimCallBack), func) as AnimCallBack; } object[] arg10 = ToLua.CheckObjectArray(L, 11); AnimData o = AnimSystem.BezierMove(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); ToLua.PushObject(L, o); return(1); } else if (count == 13 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.GameObject), typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(float), typeof(float), typeof(RepeatType), typeof(int), typeof(InterpType), typeof(bool), typeof(PathType), typeof(UnityEngine.Vector3[]), typeof(AnimCallBack), typeof(object[]))) { UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.ToObject(L, 1); UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)ToLua.ToObject(L, 2); UnityEngine.Vector3 arg2 = (UnityEngine.Vector3)ToLua.ToObject(L, 3); float arg3 = (float)LuaDLL.lua_tonumber(L, 4); float arg4 = (float)LuaDLL.lua_tonumber(L, 5); RepeatType arg5 = (RepeatType)ToLua.ToObject(L, 6); int arg6 = (int)LuaDLL.lua_tonumber(L, 7); InterpType arg7 = (InterpType)ToLua.ToObject(L, 8); bool arg8 = LuaDLL.lua_toboolean(L, 9); PathType arg9 = (PathType)ToLua.ToObject(L, 10); UnityEngine.Vector3[] arg10 = ToLua.CheckObjectArray <UnityEngine.Vector3>(L, 11); AnimCallBack arg11 = null; LuaTypes funcType12 = LuaDLL.lua_type(L, 12); if (funcType12 != LuaTypes.LUA_TFUNCTION) { arg11 = (AnimCallBack)ToLua.ToObject(L, 12); } else { LuaFunction func = ToLua.ToLuaFunction(L, 12); arg11 = DelegateFactory.CreateDelegate(typeof(AnimCallBack), func) as AnimCallBack; } object[] arg12 = ToLua.CheckObjectArray(L, 13); AnimData o = AnimSystem.BezierMove(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); ToLua.PushObject(L, o); return(1); } else if (count == 13 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.GameObject), typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(float), typeof(RepeatType), typeof(int), typeof(float), typeof(InterpType), typeof(bool), typeof(PathType), typeof(float[]), typeof(AnimCallBack), typeof(object[]))) { UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.ToObject(L, 1); UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)ToLua.ToObject(L, 2); UnityEngine.Vector3 arg2 = (UnityEngine.Vector3)ToLua.ToObject(L, 3); float arg3 = (float)LuaDLL.lua_tonumber(L, 4); RepeatType arg4 = (RepeatType)ToLua.ToObject(L, 5); int arg5 = (int)LuaDLL.lua_tonumber(L, 6); float arg6 = (float)LuaDLL.lua_tonumber(L, 7); InterpType arg7 = (InterpType)ToLua.ToObject(L, 8); bool arg8 = LuaDLL.lua_toboolean(L, 9); PathType arg9 = (PathType)ToLua.ToObject(L, 10); float[] arg10 = ToLua.CheckNumberArray <float>(L, 11); AnimCallBack arg11 = null; LuaTypes funcType12 = LuaDLL.lua_type(L, 12); if (funcType12 != LuaTypes.LUA_TFUNCTION) { arg11 = (AnimCallBack)ToLua.ToObject(L, 12); } else { LuaFunction func = ToLua.ToLuaFunction(L, 12); arg11 = DelegateFactory.CreateDelegate(typeof(AnimCallBack), func) as AnimCallBack; } object[] arg12 = ToLua.CheckObjectArray(L, 13); AnimData o = AnimSystem.BezierMove(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); ToLua.PushObject(L, o); return(1); } else { return(LuaDLL.luaL_throw(L, "invalid arguments to method: AnimSystem.BezierMove")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
public DoPathDelete(string path, PathType pathtype) { this.Path = path; this.PathType = pathtype; }