private void Edit_SubmenuOpening(object sender, RoutedEventArgs e) { this.FilePlayer_Stop(); // In case the FilePlayer is going // Enable / disable various edit menu items depending on whether we are looking at the single image view or overview bool state = this.IsDisplayingSingleImage(); this.MenuItemCopyPreviousValues.IsEnabled = state; // Enable the FindMissingImage menu only if the current image is missing ImageRow currentImage = this.DataHandler?.ImageCache?.Current; this.MenuItemFindMissingImage.IsEnabled = this.DataHandler?.ImageCache?.Current != null && false == File.Exists(FilesFolders.GetFullPath(this.DataHandler.FileDatabase, currentImage)); if (this.MarkableCanvas.ThumbnailGrid.IsVisible == false && this.MarkableCanvas.ThumbnailGrid.IsGridActive == false) { this.MenuItemRestoreDefaults.Header = "Restore default values for this file"; this.MenuItemRestoreDefaults.ToolTip = "For the currently displayed file, revert all fields to its default values (excepting file paths and dates/times)"; } else { this.MenuItemRestoreDefaults.Header = "Restore default values for the checkmarked files"; this.MenuItemRestoreDefaults.ToolTip = "For all checkmarked files, revert their fields to their default values (excepting file paths and dates/times)"; } }
private static Result CreateFileResult(string filePath, Query query) { var result = new Result { Title = Path.GetFileName(filePath), SubTitle = filePath, IcoPath = filePath, TitleHighlightData = StringMatcher.FuzzySearch(query.Search, Path.GetFileName(filePath)).MatchData, Action = c => { try { FilesFolders.OpenPath(filePath); } catch (Exception ex) { MessageBox.Show(ex.Message, "Could not start " + filePath); } return(true); }, ContextData = new SearchResult { Type = ResultType.File, FullPath = filePath } }; return(result); }
private static Result CreateOpenCurrentFolderResult(string incompleteName, string search) { var firstResult = "Open current directory"; if (incompleteName.Length > 0) { firstResult = "Open " + search; } var folderName = search.TrimEnd('\\').Split(new[] { Path.DirectorySeparatorChar }, StringSplitOptions.None).Last(); return(new Result { Title = firstResult, SubTitle = $"Use > to search files and subfolders within {folderName}, " + $"* to search for file extensions in {folderName} or both >* to combine the search", IcoPath = search, Score = 500, Action = c => { FilesFolders.OpenPath(search); return true; } }); }
private Result CreateOpenContainingFolderResult(SearchResult record) { return(new Result { Title = Context.API.GetTranslation("plugin_explorer_opencontainingfolder"), SubTitle = Context.API.GetTranslation("plugin_explorer_opencontainingfolder_subtitle"), Action = _ => { try { FilesFolders.OpenContainingFolder(record.FullPath); } catch (Exception e) { var message = $"Fail to open file at {record.FullPath}"; LogException(message, e); Context.API.ShowMsg(message); return false; } return true; }, IcoPath = Constants.FolderImagePath }); }
private Result CreateFolderResult(string title, string subtitle, string path, Query query) { return(new Result { Title = title, IcoPath = path, SubTitle = subtitle, TitleHighlightData = StringMatcher.FuzzySearch(query.Search, title).MatchData, Action = c => { if (c.SpecialKeyState.CtrlPressed) { try { FilesFolders.OpenPath(path); return true; } catch (Exception ex) { MessageBox.Show(ex.Message, "Could not start " + path); return false; } } string changeTo = path.EndsWith("\\") ? path : path + "\\"; _context.API.ChangeQuery(string.IsNullOrEmpty(query.ActionKeyword) ? changeTo : query.ActionKeyword + " " + changeTo); return false; }, ContextData = new SearchResult { Type = ResultType.Folder, FullPath = path } }); }
///<summary> ///This method should be run at first before all methods during start up and should be run before determining which data location ///will be used for Flow Launcher. ///</summary> public void PreStartCleanUpAfterPortabilityUpdate() { // Specify here so this method does not rely on other environment variables to initialise var portableDataDir = Path.Combine(Directory.GetParent(Assembly.GetExecutingAssembly().Location.NonNull()).ToString(), "UserData"); var roamingDataDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "FlowLauncher"); // Get full path to the .dead files for each case var portableDataDeleteFilePath = Path.Combine(portableDataDir, DataLocation.DeletionIndicatorFile); var roamingDataDeleteFilePath = Path.Combine(roamingDataDir, DataLocation.DeletionIndicatorFile); // If the data folder in %appdata% is marked for deletion, // delete it and prompt the user to pick the portable data location if (File.Exists(roamingDataDeleteFilePath)) { FilesFolders.RemoveFolderIfExists(roamingDataDir); if (MessageBox.Show("Flow Launcher has detected you enabled portable mode, " + "would you like to move it to a different location?", string.Empty, MessageBoxButton.YesNo) == MessageBoxResult.Yes) { FilesFolders.OpenPath(Constant.RootDirectory); Environment.Exit(0); } } // Otherwise, if the portable data folder is marked for deletion, // delete it and notify the user about it. else if (File.Exists(portableDataDeleteFilePath)) { FilesFolders.RemoveFolderIfExists(portableDataDir); MessageBox.Show("Flow Launcher has detected you disabled portable mode, " + "the relevant shortcuts and uninstaller entry have been created"); } }
private void OnPluginDirecotyClick(object sender, MouseButtonEventArgs e) { if (e.ChangedButton == MouseButton.Left) { var directory = viewModel.SelectedPlugin.PluginPair.Metadata.PluginDirectory; if (!string.IsNullOrEmpty(directory)) FilesFolders.OpenPath(directory); } }
internal List <Result> Search(Query query) { var results = new List <Result>(); var querySearch = query.Search; var quickFolderLinks = quickFolderAccess.FolderList(query, settings.QuickFolderAccessLinks, context); if (quickFolderLinks.Count > 0) { return(quickFolderLinks); } if (string.IsNullOrEmpty(querySearch)) { return(results); } var isEnvironmentVariable = EnvironmentVariables.IsEnvironmentVariableSearch(querySearch); if (isEnvironmentVariable) { return(EnvironmentVariables.GetEnvironmentStringPathSuggestions(querySearch, query, context)); } // Query is a location path with a full environment variable, eg. %appdata%\somefolder\ var isEnvironmentVariablePath = querySearch.Substring(1).Contains("%\\"); if (!FilesFolders.IsLocationPathString(querySearch) && !isEnvironmentVariablePath) { return(WindowsIndexFilesAndFoldersSearch(query, querySearch)); } var locationPath = querySearch; if (isEnvironmentVariablePath) { locationPath = EnvironmentVariables.TranslateEnvironmentVariablePath(locationPath); } if (!FilesFolders.LocationExists(FilesFolders.ReturnPreviousDirectoryIfIncompleteString(locationPath))) { return(results); } var useIndexSearch = UseWindowsIndexForDirectorySearch(locationPath); results.Add(resultManager.CreateOpenCurrentFolderResult(locationPath, useIndexSearch)); results.AddRange(TopLevelDirectorySearchBehaviour(WindowsIndexTopLevelFolderSearch, DirectoryInfoClassSearch, useIndexSearch, query, locationPath)); return(results); }
public void WhenGivenQuerySearchString_ThenShouldIndicateIfIsLocationPathString(string querySearchString, bool expectedResult) { // When, Given var result = FilesFolders.IsLocationPathString(querySearchString); //Then Assert.IsTrue(result == expectedResult, $"Expected query search string check result is: {expectedResult} {Environment.NewLine} " + $"Actual check result is {result} {Environment.NewLine}"); }
public void WhenGivenAPath_ThenShouldReturnThePreviousDirectoryPathIfIncompleteOrOriginalString( string path, string expectedString) { var returnedPath = FilesFolders.ReturnPreviousDirectoryIfIncompleteString(path); //Then Assert.IsTrue(returnedPath == expectedString, $"Expected path string: {expectedString} {Environment.NewLine} " + $"Actual path string is {returnedPath} {Environment.NewLine}"); }
internal static Result CreateOpenCurrentFolderResult(string path, bool windowsIndexed = false) { var retrievedDirectoryPath = FilesFolders.ReturnPreviousDirectoryIfIncompleteString(path); var folderName = retrievedDirectoryPath.TrimEnd(Constants.DirectorySeperator).Split(new[] { Path.DirectorySeparatorChar }, StringSplitOptions.None).Last(); if (retrievedDirectoryPath.EndsWith(":\\")) { var driveLetter = path.Substring(0, 1).ToUpper(); folderName = driveLetter + " drive"; } var title = "Open current directory"; if (retrievedDirectoryPath != path) { title = "Open " + folderName; } var subtitleFolderName = folderName; // ie. max characters can be displayed without subtitle cutting off: "Program Files (x86)" if (folderName.Length > 19) { subtitleFolderName = "the directory"; } return(new Result { Title = title, SubTitle = $"Use > to search within {subtitleFolderName}, " + $"* to search for file extensions or >* to combine both searches.", AutoCompleteText = GetPathWithActionKeyword(retrievedDirectoryPath, ResultType.Folder), IcoPath = retrievedDirectoryPath, Score = 500, Action = c => { Context.API.OpenDirectory(retrievedDirectoryPath); return true; }, TitleToolTip = retrievedDirectoryPath, SubTitleToolTip = retrievedDirectoryPath, ContextData = new SearchResult { Type = ResultType.Folder, FullPath = retrievedDirectoryPath, ShowIndexState = true, WindowsIndexed = windowsIndexed } }); }
private List <Result> DirectorySearch(SearchOption searchOption, Query query, string search, string searchCriteria) { var results = new List <Result>(); var path = FilesFolders.ReturnPreviousDirectoryIfIncompleteString(search); var folderList = new List <Result>(); var fileList = new List <Result>(); try { var directoryInfo = new System.IO.DirectoryInfo(path); var fileSystemInfos = directoryInfo.GetFileSystemInfos(searchCriteria, searchOption); foreach (var fileSystemInfo in fileSystemInfos) { if ((fileSystemInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden) { continue; } if (fileSystemInfo is System.IO.DirectoryInfo) { folderList.Add(resultManager.CreateFolderResult(fileSystemInfo.Name, fileSystemInfo.FullName, fileSystemInfo.FullName, query, true, false)); } else { fileList.Add(resultManager.CreateFileResult(fileSystemInfo.FullName, query, true, false)); } } } catch (Exception e) { if (e is UnauthorizedAccessException || e is ArgumentException) { results.Add(new Result { Title = e.Message, Score = 501 }); return(results); } #if DEBUG // Please investigate and handle error from DirectoryInfo search throw e; #else Log.Exception($"|Flow.Launcher.Plugin.Explorer.DirectoryInfoSearch|Error from performing DirectoryInfoSearch", e); #endif } // Intial ordering, this order can be updated later by UpdateResultView.MainViewModel based on history of user selection. return(results.Concat(folderList.OrderBy(x => x.Title)).Concat(fileList.OrderBy(x => x.Title)).ToList()); }
private static List <Result> DirectorySearch(EnumerationOptions enumerationOption, Query query, string search, string searchCriteria, CancellationToken token) { var results = new List <Result>(); var path = FilesFolders.ReturnPreviousDirectoryIfIncompleteString(search); var folderList = new List <Result>(); var fileList = new List <Result>(); try { var directoryInfo = new System.IO.DirectoryInfo(path); foreach (var fileSystemInfo in directoryInfo.EnumerateFileSystemInfos(searchCriteria, enumerationOption)) { if (fileSystemInfo is System.IO.DirectoryInfo) { folderList.Add(ResultManager.CreateFolderResult(fileSystemInfo.Name, fileSystemInfo.FullName, fileSystemInfo.FullName, query, true, false)); } else { fileList.Add(ResultManager.CreateFileResult(fileSystemInfo.FullName, query, true, false)); } token.ThrowIfCancellationRequested(); } } catch (Exception e) { if (!(e is ArgumentException)) { throw e; } results.Add(new Result { Title = e.Message, Score = 501 }); return(results); #if DEBUG // Please investigate and handle error from DirectoryInfo search #else Log.Exception($"|Flow.Launcher.Plugin.Explorer.DirectoryInfoSearch|Error from performing DirectoryInfoSearch", e); #endif } // Initial ordering, this order can be updated later by UpdateResultView.MainViewModel based on history of user selection. return(results.Concat(folderList.OrderBy(x => x.Title)).Concat(fileList.OrderBy(x => x.Title)).ToList()); }
private bool UseWindowsIndexForDirectorySearch(string locationPath) { if (!settings.UseWindowsIndexForDirectorySearch) { return(false); } if (settings.IndexSearchExcludedSubdirectoryPaths .Any(x => FilesFolders.ReturnPreviousDirectoryIfIncompleteString(locationPath) .StartsWith(x.Path, StringComparison.OrdinalIgnoreCase))) { return(false); } return(indexSearch.PathIsIndexed(locationPath)); }
private void Install(UserPlugin plugin, string downloadedFilePath) { if (!File.Exists(downloadedFilePath)) { return; } var tempFolderPath = Path.Combine(Path.GetTempPath(), "flowlauncher"); var tempFolderPluginPath = Path.Combine(tempFolderPath, "plugin"); if (Directory.Exists(tempFolderPath)) { Directory.Delete(tempFolderPath, true); } Directory.CreateDirectory(tempFolderPath); var zipFilePath = Path.Combine(tempFolderPath, Path.GetFileName(downloadedFilePath)); File.Copy(downloadedFilePath, zipFilePath); File.Delete(downloadedFilePath); Utilities.UnZip(zipFilePath, tempFolderPluginPath, true); var pluginFolderPath = Utilities.GetContainingFolderPathAfterUnzip(tempFolderPluginPath); var metadataJsonFilePath = string.Empty; if (File.Exists(Path.Combine(pluginFolderPath, Constant.PluginMetadataFileName))) { metadataJsonFilePath = Path.Combine(pluginFolderPath, Constant.PluginMetadataFileName); } if (string.IsNullOrEmpty(metadataJsonFilePath) || string.IsNullOrEmpty(pluginFolderPath)) { MessageBox.Show(Context.API.GetTranslation("plugin_pluginsmanager_install_errormetadatafile")); return; } string newPluginPath = Path.Combine(DataLocation.PluginsDirectory, $"{plugin.Name}-{plugin.Version}"); FilesFolders.CopyAll(pluginFolderPath, newPluginPath); Directory.Delete(pluginFolderPath, true); }
///<summary> ///This method should be run at first before all methods during start up and should be run before determining which data location ///will be used for Flow Launcher. ///</summary> public void PreStartCleanUpAfterPortabilityUpdate() { // Specify here so this method does not rely on other environment variables to initialise var portableDataPath = Path.Combine(Directory.GetParent(Assembly.GetExecutingAssembly().Location.NonNull()).ToString(), "UserData"); var roamingDataPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "FlowLauncher"); bool DataLocationPortableDeleteRequired = false; bool DataLocationRoamingDeleteRequired = false; if ((roamingDataPath + "\\" + DataLocation.DeletionIndicatorFile).FileExits()) { DataLocationRoamingDeleteRequired = true; } if ((portableDataPath + "\\" + DataLocation.DeletionIndicatorFile).FileExits()) { DataLocationPortableDeleteRequired = true; } if (DataLocationRoamingDeleteRequired) { FilesFolders.RemoveFolderIfExists(roamingDataPath); if (MessageBox.Show("Flow Launcher has detected you enabled portable mode, " + "would you like to move it to a different location?", string.Empty, MessageBoxButton.YesNo) == MessageBoxResult.Yes) { FilesFolders.OpenPath(Constant.RootDirectory); Environment.Exit(0); } return; } if (DataLocationPortableDeleteRequired) { FilesFolders.RemoveFolderIfExists(portableDataPath); MessageBox.Show("Flow Launcher has detected you disabled portable mode, " + "the relevant shortcuts and uninstaller entry have been created"); return; } }
private async void MenuItemMergeDatabases_Click(object sender, RoutedEventArgs e) { if (this.State.SuppressMergeDatabasesPrompt == false) { if (Dialogs.MenuFileMergeDatabasesExplainedDialog(this) == false) { return; } } // Get the location of the template, which also determines the root folder if (this.TryGetTemplatePath(out string templateDatabasePath) == false) { return; } // Set up progress indicators Mouse.OverrideCursor = Cursors.Wait; this.StatusBar.SetMessage("Creating a merged database, please wait..."); IProgress <ProgressBarArguments> progress = progressHandler; this.BusyCancelIndicator.EnableForMerging(true); // Find all the .DDB files located in subfolders under the root folder (excluding backup folders) string startFolder = Path.GetDirectoryName(templateDatabasePath); List <string> allDDBFiles = new List <string>(); FilesFolders.GetAllFilesInFoldersAndSubfoldersMatchingPattern(startFolder, "*" + Constant.File.FileDatabaseFileExtension, true, true, allDDBFiles); // Merge the found databases into a new (or replaced) TimelapseData_merged.ddb file located in the same folder as the template. // Note: .ddb files found in a Backup folder will be ignored ErrorsAndWarnings errorMessages = await MergeDatabases.TryMergeDatabasesAsync(templateDatabasePath, allDDBFiles, progress).ConfigureAwait(true); // Turn off progress indicators this.BusyCancelIndicator.EnableForSelection(false); Mouse.OverrideCursor = null; if (errorMessages.Errors.Count != 0 || errorMessages.Warnings.Count != 0) { // Merge databases: Show errors and/or warnings, if any. Dialogs.MenuFileMergeDatabasesErrorsAndWarningsDialog(this, errorMessages); } this.StatusBar.SetMessage(errorMessages.Errors.Count == 0 ? "Merged database created" : "Aborted creation of merged database"); }
public void GivenAPartialPath_WhenPreviousLevelDirectoryExists_ThenShouldReturnThePreviousDirectoryPathString( string path, bool previousDirectoryExists, string expectedString) { // When Func <string, bool> previousLocationExists = null; if (previousDirectoryExists) { previousLocationExists = PreviousLocationExistsReturnsTrue; } else { previousLocationExists = PreviousLocationNotExistReturnsFalse; } // Given var previousDirectoryPath = FilesFolders.GetPreviousExistingDirectory(previousLocationExists, path); //Then Assert.IsTrue(previousDirectoryPath == expectedString, $"Expected path string: {expectedString} {Environment.NewLine} " + $"Actual path string is {previousDirectoryPath} {Environment.NewLine}"); }
internal Result CreateFileResult(string filePath, Query query, bool showIndexState = false, bool windowsIndexed = false) { var result = new Result { Title = Path.GetFileName(filePath), SubTitle = filePath, IcoPath = filePath, TitleHighlightData = StringMatcher.FuzzySearch(query.Search, Path.GetFileName(filePath)).MatchData, Action = c => { try { if (c.SpecialKeyState.CtrlPressed) { FilesFolders.OpenContainingFolder(filePath); } else { FilesFolders.OpenPath(filePath); } } catch (Exception ex) { MessageBox.Show(ex.Message, "Could not start " + filePath); } return(true); }, TitleToolTip = Constants.ToolTipOpenContainingFolder, SubTitleToolTip = Constants.ToolTipOpenContainingFolder, ContextData = new SearchResult { Type = ResultType.File, FullPath = filePath, ShowIndexState = showIndexState, WindowsIndexed = windowsIndexed } }; return(result); }
internal Result CreateFolderResult(string title, string subtitle, string path, Query query, bool showIndexState = false, bool windowsIndexed = false) { return(new Result { Title = title, IcoPath = path, SubTitle = subtitle, TitleHighlightData = StringMatcher.FuzzySearch(query.Search, title).MatchData, Action = c => { if (c.SpecialKeyState.CtrlPressed) { try { FilesFolders.OpenPath(path); return true; } catch (Exception ex) { MessageBox.Show(ex.Message, "Could not start " + path); return false; } } string changeTo = path.EndsWith(Constants.DirectorySeperator) ? path : path + Constants.DirectorySeperator; context.API.ChangeQuery(string.IsNullOrEmpty(query.ActionKeyword) ? changeTo : query.ActionKeyword + " " + changeTo); return false; }, TitleToolTip = Constants.ToolTipOpenDirectory, SubTitleToolTip = Constants.ToolTipOpenDirectory, ContextData = new SearchResult { Type = ResultType.Folder, FullPath = path, ShowIndexState = showIndexState, WindowsIndexed = windowsIndexed } }); }
// Load template, images, and video files... private async void MenuItemLoadImages_Click(object sender, RoutedEventArgs e) { if (this.TryGetTemplatePath(out string templateDatabasePath)) { // We don't allow templates in root drive letters (e.g., D:) or in System or Hidden folders if (FilesFolders.IsFolderPathADriveLetter(Path.GetDirectoryName(templateDatabasePath))) { Dialog.Dialogs.TemplateInDisallowedFolder(this, true, Path.GetDirectoryName(templateDatabasePath)); return; } if (FilesFolders.IsFolderSystemOrHidden(Path.GetDirectoryName(templateDatabasePath))) { Dialog.Dialogs.TemplateInDisallowedFolder(this, false, Path.GetDirectoryName(templateDatabasePath)); return; } Mouse.OverrideCursor = Cursors.Wait; this.StatusBar.SetMessage("Loading images, please wait..."); await this.TryOpenTemplateAndBeginLoadFoldersAsync(templateDatabasePath).ConfigureAwait(true); this.StatusBar.SetMessage("Image set is now loaded."); Mouse.OverrideCursor = null; } }
public void MoveUserDataFolder(string fromLocation, string toLocation) { FilesFolders.Copy(fromLocation, toLocation); VerifyUserDataAfterMove(fromLocation, toLocation); }
private void OpenPluginFolder(object sender, RoutedEventArgs e) { FilesFolders.OpenPath(Path.Combine(DataLocation.DataDirectory(), Constant.Themes)); }
public async Task UpdateApp(IPublicAPI api, bool silentUpdate = true) { try { UpdateInfo newUpdateInfo; if (!silentUpdate) { api.ShowMsg(api.GetTranslation("pleaseWait"), api.GetTranslation("update_flowlauncher_update_check")); } using var updateManager = await GitHubUpdateManager(GitHubRepository).ConfigureAwait(false); // UpdateApp CheckForUpdate will return value only if the app is squirrel installed newUpdateInfo = await updateManager.CheckForUpdate().NonNull().ConfigureAwait(false); var newReleaseVersion = Version.Parse(newUpdateInfo.FutureReleaseEntry.Version.ToString()); var currentVersion = Version.Parse(Constant.Version); Log.Info($"|Updater.UpdateApp|Future Release <{newUpdateInfo.FutureReleaseEntry.Formatted()}>"); if (newReleaseVersion <= currentVersion) { if (!silentUpdate) { MessageBox.Show(api.GetTranslation("update_flowlauncher_already_on_latest")); } return; } if (!silentUpdate) { api.ShowMsg(api.GetTranslation("update_flowlauncher_update_found"), api.GetTranslation("update_flowlauncher_updating")); } await updateManager.DownloadReleases(newUpdateInfo.ReleasesToApply).ConfigureAwait(false); await updateManager.ApplyReleases(newUpdateInfo).ConfigureAwait(false); if (DataLocation.PortableDataLocationInUse()) { var targetDestination = updateManager.RootAppDirectory + $"\\app-{newReleaseVersion.ToString()}\\{DataLocation.PortableFolderName}"; FilesFolders.CopyAll(DataLocation.PortableDataPath, targetDestination); if (!FilesFolders.VerifyBothFolderFilesEqual(DataLocation.PortableDataPath, targetDestination)) { MessageBox.Show(string.Format(api.GetTranslation("update_flowlauncher_fail_moving_portable_user_profile_data"), DataLocation.PortableDataPath, targetDestination)); } } else { await updateManager.CreateUninstallerRegistryEntry().ConfigureAwait(false); } var newVersionTips = NewVersinoTips(newReleaseVersion.ToString()); Log.Info($"|Updater.UpdateApp|Update success:{newVersionTips}"); if (MessageBox.Show(newVersionTips, api.GetTranslation("update_flowlauncher_new_update"), MessageBoxButton.YesNo) == MessageBoxResult.Yes) { UpdateManager.RestartApp(Constant.ApplicationFileName); } } catch (Exception e) when(e is HttpRequestException || e is WebException || e is SocketException || e is TaskCanceledException) { Log.Exception($"|Updater.UpdateApp|Check your connection and proxy settings to github-cloud.s3.amazonaws.com.", e); api.ShowMsg(api.GetTranslation("update_flowlauncher_fail"), api.GetTranslation("update_flowlauncher_check_connection")); return; } }
/// <summary> /// looks what in the given folder, and makes a recursive call to itself, with the folders that is in the given folder. /// To ensure that it doesn't make a endless recursive call, it check the foldername, to see that it is not the same as the last /// uses the extentionVerifier to ensure, that only musiknumbers are added to the List MusicList /// </summary> /// <param name="folderpath">The folder that are to be indexed.</param> private void SubFoldersLookup(string folderpath) { if (folderpath == null) throw new ArgumentNullException("folderpath"); if (folderpath == testsubfolder) throw new Exception("Recursive subfolder call"); testsubfolder = folderpath; FilesFolders subContainer = new FilesFolders(folderpath); foreach (IOitem ioitem in subContainer.IndexContainer) { if (extentionVerifier.TestExtention(ioitem.Extention)) { MusikList.Add(ioitem); //Console.WriteLine("subfolder added " + ioitem.FullName); } if (ioitem.Tag == "folder") { //Console.WriteLine(ioitem.FullName); SubFoldersLookup(ioitem.FullName); } } }
/// <summary> /// Look's up what in the given folder, and calls a subFoldersLookup with the folders in the first folder /// uses the extentionVerifier to ensure, that only musiknumbers are added to the List MusicList /// </summary> private void foldersVers_One() { Container = new FilesFolders(Folderpath); foreach (IOitem ioitem in Container.IndexContainer) { if (extentionVerifier.TestExtention(ioitem.Extention)) { MusikList.Add(ioitem); //Console.WriteLine("added " + ioitem.FullName); } if (ioitem.Tag == "folder") { //Console.WriteLine(ioitem.FullName); SubFoldersLookup(ioitem.FullName); } } testsubfolder = null; }
/// <summary> /// Sets the folderpath, and starts the runner /// </summary> /// <param name="folderpath">The folder that are to indexed</param> public void SetIndexPath(string folderpath) { Folderpath = folderpath; _folder = new FilesFolders(Folderpath); Runner(); }
public List <Result> Query(Query query) { if (FilesFolders.IsLocationPathString(query.Search)) { return(new List <Result>()); } var searchSourceList = new List <SearchSource>(); var results = new List <Result>(); _updateSource?.Cancel(); _updateSource = new CancellationTokenSource(); _updateToken = _updateSource.Token; _settings.SearchSources.Where(o => (o.ActionKeyword == query.ActionKeyword || o.ActionKeyword == SearchSourceGlobalPluginWildCardSign) && o.Enabled) .ToList() .ForEach(x => searchSourceList.Add(x)); if (searchSourceList.Any()) { foreach (SearchSource searchSource in searchSourceList) { string keyword = string.Empty; keyword = searchSource.ActionKeyword == SearchSourceGlobalPluginWildCardSign?query.ToString() : query.Search; var title = keyword; string subtitle = _context.API.GetTranslation("flowlauncher_plugin_websearch_search") + " " + searchSource.Title; if (string.IsNullOrEmpty(keyword)) { var result = new Result { Title = subtitle, SubTitle = string.Empty, IcoPath = searchSource.IconPath }; results.Add(result); } else { var result = new Result { Title = title, SubTitle = subtitle, Score = 6, IcoPath = searchSource.IconPath, ActionKeywordAssigned = searchSource.ActionKeyword == SearchSourceGlobalPluginWildCardSign ? string.Empty : searchSource.ActionKeyword, Action = c => { if (_settings.OpenInNewBrowser) { searchSource.Url.Replace("{q}", Uri.EscapeDataString(keyword)).NewBrowserWindow(_settings.BrowserPath); } else { searchSource.Url.Replace("{q}", Uri.EscapeDataString(keyword)).NewTabInBrowser(_settings.BrowserPath); } return(true); } }; results.Add(result); ResultsUpdated?.Invoke(this, new ResultUpdatedEventArgs { Results = results, Query = query }); UpdateResultsFromSuggestion(results, keyword, subtitle, searchSource, query); } } } return(results); }
//Try to find a missing image private async void MenuItemEditFindMissingImage_Click(object sender, RoutedEventArgs e) { // Don't do anything if the image actually exists. This should not fire, as this menu item is only enabled // if there is a current image that doesn't exist. But just in case... if (null == this.DataHandler?.ImageCache?.Current || File.Exists(FilesFolders.GetFullPath(this.DataHandler.FileDatabase.FolderPath, this.DataHandler?.ImageCache?.Current))) { return; } string folderPath = this.DataHandler.FileDatabase.FolderPath; ImageRow currentImage = this.DataHandler?.ImageCache?.Current; // Search for - and return as list of relative path / filename tuples - all folders under the root folder for files with the same name as the fileName. List <Tuple <string, string> > matchingRelativePathFileNameList = Util.FilesFolders.SearchForFoldersContainingFileName(folderPath, currentImage.File); // Remove any of the tuples that are spoken for i.e., that are already associated with a row in the database for (int i = matchingRelativePathFileNameList.Count - 1; i >= 0; i--) { if (this.DataHandler.FileDatabase.ExistsRelativePathAndFileInDataTable(matchingRelativePathFileNameList[i].Item1, matchingRelativePathFileNameList[i].Item2)) { // We only want matching files that are not already assigned to another datafield in the database matchingRelativePathFileNameList.RemoveAt(i); } } // If there are no remaining tuples, it means no potential matches were found. // Display a message saying so and abort. if (matchingRelativePathFileNameList.Count == 0) { Dialogs.MissingFileSearchNoMatchesFoundDialog(this, currentImage.File); return; } // Now retrieve a list of all filenames located in the same folder (i.e., that have the same relative path) as the missing file. List <string> otherMissingFiles = this.DataHandler.FileDatabase.SelectFileNamesWithRelativePathFromDatabase(currentImage.RelativePath); // Remove the current missing file from the list, as well as any file that exists i.e., that is not missing. for (int i = otherMissingFiles.Count - 1; i >= 0; i--) { if (String.Equals(otherMissingFiles[i], currentImage.File) || File.Exists(Path.Combine(folderPath, currentImage.RelativePath, otherMissingFiles[i]))) { otherMissingFiles.RemoveAt(i); } } // For those that are left (if any), see if other files in the returned locations are in each path. Get their count, save them, and pass the count as a parameter e.g., a Dict with matching files, etc. // Or perhapse even better, a list of file names for each path Dict<string, List<string>> // As we did above, go through the other missing files and remove those that are spoken for i.e., that are already associated with a row in the database. // What remains will be a list of root paths, each with a list of missing (unassociated) files that could be candidates for locating Dictionary <string, List <string> > otherMissingFileCandidates = new Dictionary <string, List <string> >(); foreach (Tuple <string, string> matchingPath in matchingRelativePathFileNameList) { List <string> orphanMissingFiles = new List <string>(); foreach (string otherMissingFile in otherMissingFiles) { // Its a potential candidate if its not already referenced but it exists in that relative path folder if (false == this.DataHandler.FileDatabase.ExistsRelativePathAndFileInDataTable(matchingPath.Item1, otherMissingFile) && File.Exists(FilesFolders.GetFullPath(FolderPath, matchingPath.Item1, otherMissingFile))) { orphanMissingFiles.Add(otherMissingFile); } } otherMissingFileCandidates.Add(matchingPath.Item1, orphanMissingFiles); } Dialog.MissingImageLocateRelativePaths dialog = new Dialog.MissingImageLocateRelativePaths(this, this.DataHandler.FileDatabase, currentImage.RelativePath, currentImage.File, otherMissingFileCandidates); bool?result = dialog.ShowDialog(); if (result == true) { Tuple <string, string> locatedMissingFile = dialog.LocatedMissingFile; if (String.IsNullOrEmpty(locatedMissingFile.Item2)) { return; } // Update the original missing file List <ColumnTuplesWithWhere> columnTuplesWithWhereList = new List <ColumnTuplesWithWhere>(); ColumnTuplesWithWhere columnTuplesWithWhere = new ColumnTuplesWithWhere(); columnTuplesWithWhere.Columns.Add(new ColumnTuple(Constant.DatabaseColumn.RelativePath, locatedMissingFile.Item1)); // The new relative path columnTuplesWithWhere.SetWhere(currentImage.RelativePath, currentImage.File); // Where the original relative path/file terms are met columnTuplesWithWhereList.Add(columnTuplesWithWhere); // Update the other missing files in the database, if any foreach (string otherMissingFileName in otherMissingFileCandidates[locatedMissingFile.Item1]) { columnTuplesWithWhere = new ColumnTuplesWithWhere(); columnTuplesWithWhere.Columns.Add(new ColumnTuple(Constant.DatabaseColumn.RelativePath, locatedMissingFile.Item1)); // The new value columnTuplesWithWhere.SetWhere(currentImage.RelativePath, otherMissingFileName); // Where the original relative path/file terms are met columnTuplesWithWhereList.Add(columnTuplesWithWhere); } // Now update the database this.DataHandler.FileDatabase.UpdateFiles(columnTuplesWithWhereList); await this.FilesSelectAndShowAsync().ConfigureAwait(true); } }
public void Init(PluginInitContext context) { _context = context; _settings = context.API.LoadSettingJsonStorage <Settings>(); SortOptionTranlationHelper.API = context.API; if (_settings.MaxSearchCount <= 0) { _settings.MaxSearchCount = Settings.DefaultMaxSearchCount; } if (!_settings.EverythingInstalledPath.FileExists()) { var installedLocation = Utilities.GetInstalledPath(); if (string.IsNullOrEmpty(installedLocation) && System.Windows.Forms.MessageBox.Show( string.Format(context.API.GetTranslation("flowlauncher_plugin_everything_installing_select"), Environment.NewLine), context.API.GetTranslation("flowlauncher_plugin_everything_installing_title"), System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes) { // Solves single thread apartment (STA) mode requirement error when using OpenFileDialog Thread t = new Thread(() => { var dlg = new System.Windows.Forms.OpenFileDialog { InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles) }; var result = dlg.ShowDialog(); if (result == System.Windows.Forms.DialogResult.OK && !string.IsNullOrEmpty(dlg.FileName)) { installedLocation = dlg.FileName; } }); // Run your code from a thread that joins the STA Thread t.SetApartmentState(ApartmentState.STA); t.Start(); t.Join(); } if (string.IsNullOrEmpty(installedLocation)) { Task.Run(async delegate { context.API.ShowMsg(context.API.GetTranslation("flowlauncher_plugin_everything_installing_title"), context.API.GetTranslation("flowlauncher_plugin_everything_installing_subtitle"), "", useMainWindowAsOwner: false); await DroplexPackage.Drop(App.Everything1_4_1_1009).ConfigureAwait(false); context.API.ShowMsg(context.API.GetTranslation("flowlauncher_plugin_everything_installing_title"), context.API.GetTranslation("flowlauncher_plugin_everything_installationsuccess_subtitle"), "", useMainWindowAsOwner: false); _settings.EverythingInstalledPath = "C:\\Program Files\\Everything\\Everything.exe"; FilesFolders.OpenPath(_settings.EverythingInstalledPath); }).ContinueWith(t => { _context.API.LogException("Everything.Main", $"Failed to install Everything service", t.Exception.InnerException, "DroplexPackage.Drop"); MessageBox.Show(context.API.GetTranslation("flowlauncher_plugin_everything_installationfailed_subtitle"), context.API.GetTranslation("flowlauncher_plugin_everything_installing_title")); }, TaskContinuationOptions.OnlyOnFaulted); } else { _settings.EverythingInstalledPath = installedLocation; } } var pluginDirectory = context.CurrentPluginMetadata.PluginDirectory; const string sdk = "EverythingSDK"; var bundledSdkDirectory = Path.Combine(pluginDirectory, sdk, CpuType()); var sdkPath = Path.Combine(bundledSdkDirectory, DLL); _api.Load(sdkPath); }
public void VerifyUserDataAfterMove(string fromLocation, string toLocation) { FilesFolders.VerifyBothFolderFilesEqual(fromLocation, toLocation); }
public List <Result> Query(Query query) { _cancellationTokenSource?.Cancel(); // cancel if already exist var cts = _cancellationTokenSource = new CancellationTokenSource(); var results = new List <Result>(); if (!string.IsNullOrEmpty(query.Search)) { var keyword = query.Search; try { var searchList = _api.Search(keyword, cts.Token, _settings.SortOption, maxCount: _settings.MaxSearchCount); if (searchList == null) { return(results); } foreach (var searchResult in searchList) { var r = CreateResult(keyword, searchResult); results.Add(r); } } catch (IPCErrorException) { results.Add(new Result { Title = _context.API.GetTranslation("flowlauncher_plugin_everything_is_not_running"), SubTitle = _context.API.GetTranslation("flowlauncher_plugin_everything_run_service"), IcoPath = "Images\\warning.png", Action = _ => { if (FilesFolders.FileExists(_settings.EverythingInstalledPath)) { FilesFolders.OpenPath(_settings.EverythingInstalledPath); } return(true); } }); } catch (Exception e) { _context.API.LogException("EverythingPlugin", "Query Error", e); results.Add(new Result { Title = _context.API.GetTranslation("flowlauncher_plugin_everything_query_error"), SubTitle = e.Message, Action = _ => { Clipboard.SetText(e.Message + "\r\n" + e.StackTrace); _context.API.ShowMsg(_context.API.GetTranslation("flowlauncher_plugin_everything_copied"), null, string.Empty); return(false); }, IcoPath = "Images\\error.png" }); } } return(results); }
public async Task UpdateApp(bool silentIfLatestVersion = true, bool updateToPrereleases = false) { try { using (UpdateManager updateManager = await GitHubUpdateManager(GitHubRepository, updateToPrereleases)) { UpdateInfo newUpdateInfo; try { // UpdateApp CheckForUpdate will return value only if the app is squirrel installed newUpdateInfo = await updateManager.CheckForUpdate().NonNull(); } catch (Exception e) when(e is HttpRequestException || e is WebException || e is SocketException) { Logger.WoxError($"Check your connection and proxy settings to api.github.com.", e); updateManager.Dispose(); return; } var newReleaseVersion = Version.Parse(newUpdateInfo.FutureReleaseEntry.Version.ToString()); var currentVersion = Version.Parse(Constant.Version); Logger.WoxInfo($"Future Release <{newUpdateInfo.FutureReleaseEntry.Formatted()}>"); if (newReleaseVersion <= currentVersion) { if (!silentIfLatestVersion) { MessageBox.Show("You already have the latest Wox version"); } updateManager.Dispose(); return; } try { await updateManager.DownloadReleases(newUpdateInfo.ReleasesToApply); } catch (Exception e) when(e is HttpRequestException || e is WebException || e is SocketException) { Logger.WoxError($"Check your connection and proxy settings to github-cloud.s3.amazonaws.com.", e); updateManager.Dispose(); return; } await updateManager.ApplyReleases(newUpdateInfo); if (DataLocation.PortableDataLocationInUse()) { var targetDestination = updateManager.RootAppDirectory + $"\\app-{newReleaseVersion.ToString()}\\{DataLocation.PortableFolderName}"; FilesFolders.Copy(DataLocation.PortableDataPath, targetDestination); if (!FilesFolders.VerifyBothFolderFilesEqual(DataLocation.PortableDataPath, targetDestination)) { MessageBox.Show(string.Format("Wox was not able to move your user profile data to the new update version. Please manually" + "move your profile data folder from {0} to {1}", DataLocation.PortableDataPath, targetDestination)); } } else { await updateManager.CreateUninstallerRegistryEntry(); } var newVersionTips = NewVersinoTips(newReleaseVersion.ToString()); MessageBox.Show(newVersionTips); Logger.WoxInfo($"Update success:{newVersionTips}"); } } catch (Exception e) when(e is HttpRequestException || e is WebException || e is SocketException) { Logger.WoxError($"Please check your connection and proxy settings to api.github.com.", e); } }