private async void OnItemSelected(object selectedItem) { if (_isSelecting) { return; // still selecting something } try { _isSelecting = true; if (selectedItem is FileItem fileItem) { if (OpenFileCommand?.CanExecute(OpenFileCommandParameter) ?? false) { OpenFileCommand.Execute(OpenFileCommandParameter); } } else { IsBusy = true; await Adapter.OpenItemAsync(selectedItem as FileSystemItemBase); } } catch (Exception ex) { await Adapter.OnErrorAsync(ex); } finally { _isSelecting = false; IsBusy = false; } }
public void OpenCommand_Executed(object sender, RoutedEventArgs e) { OpenFileDialog mOpenFileDialog = new OpenFileDialog(); mOpenFileDialog.Filter = "XML Files (*.xml)|*.xml|All files (*.*)|*.*"; if (mOpenFileDialog.ShowDialog() == true) { string path = mOpenFileDialog.FileName; System.Threading.Tasks.Task.Factory.StartNew(() => { try { OpenFileCommand OpenFileCommand = new OpenFileCommand(this, path); OpenFileCommand.Execute(); Hub.Invoke("ClientRequestTaskList"); } catch (AggregateException error) { MessageBox.Show(error.Message); } }); //MessageBox.Show("Open Completed!", "Open", MessageBoxButton.OK, MessageBoxImage.Information); } }
public void OpenFile(object sender, RoutedEventArgs arguments) { var openCommand = new OpenFileCommand(); openCommand.Execute(arguments); LoadSource(openCommand.MappingsSource); }
private void OpenFile() { Vault.Currency.Entities.FileIteration file = m_model.SelectedContent.FirstOrDefault() as Vault.Currency.Entities.FileIteration; if (file != null) { OpenFileCommand.Execute(file, m_conn); } }
public void Command() { var mockFileByOpen = new MockCommand(); var mockFileByClose = new MockCommand(); ICommand commadOpen = new OpenFileCommand(mockFileByOpen); ICommand commadClose = new CloseFileCommand(mockFileByClose); commadOpen.Execute(); commadClose.Execute(); Assert.IsTrue(mockFileByOpen.InvokedOpen); Assert.IsTrue(mockFileByClose.InvokedClose); Assert.IsFalse(mockFileByOpen.InvokedClose); Assert.IsFalse(mockFileByClose.InvokedOpen); }
private void ToolbarButton_Click(object sender, RoutedEventArgs e) { try { switch ((sender as FrameworkElement).Tag.ToString().Replace("toolbar.", "")) { case "new": NewFileCommand.Execute(null); break; case "open": OpenFileCommand.Execute(null); break; case "save": SaveFileCommand.Execute(null); break; case "cut": CutCommand.Execute(null); break; case "copy": CopyCommand.Execute(null); break; case "paste": PasteCommand.Execute(null); break; case "build": BuildRunCommand.Execute(false); break; case "buildrun": BuildRunCommand.Execute(true); break; case "close": CloseTabCommand.Execute(null); break; } } catch (Exception ex) { Debug.Fail(ex.Message); } }
public void OpenCommand_Executed(object sender, RoutedEventArgs e) { try { OpenFileDialog mOpenFileDialog = new OpenFileDialog(); mOpenFileDialog.Filter = "XML Files (*.xml)|*.xml|All files (*.*)|*.*"; //string folderLocation = FOLDER_LOCATION; //mOpenFileDialog.InitialDirectory = @folderLocation; if (mOpenFileDialog.ShowDialog() == true) { string path = mOpenFileDialog.FileName; OpenFileCommand OpenFileCommand = new OpenFileCommand(this, path); OpenFileCommand.Execute(); this.ViewableTasks.View.Refresh(); } } catch (Exception e2) { MessageBox.Show(e2.Message); } }
private void WCDoAction(object sender, RoutedEventArgs e) { var action = (sender as TextBlock).Tag as string; if (action == null) { return; } switch (action) { default: if (action.StartsWith("recent ")) { action = action.Replace("recent ", ""); OpenCodeFile(action); ChangeViewMode(showEnvironment: true); //actualización de archivos recientes. var recentFiles = VoltaSettings.RecentFiles; recentFiles.Remove(action); recentFiles.Insert(0, action); VoltaSettings.RecentFiles = recentFiles; } break; case "openFile": OpenFileCommand.Execute(null); break; case "newFile": NewFileCommand.Execute(null); break; case "about": SLDlgShow(nameof(DlgAbout)); break; } }
/// <summary> /// Starts resizing the image operation /// </summary> /// <param name="action">Determine whether the image files should be saved as, or updated or resize image is used from sharing</param> /// <param name="processedImageAction">Action method which retrievs the resized image. Can be used for sharing.</param> /// <returns>Task which indicates if the current resize operation was successfull</returns> public async Task <bool> ResizeImages(ImageAction action, Action <ImageFile, String> processedImageAction = null) { IProgressBarDialogService progressBarDialog = !IsShareTarget?_progressBarDialogService.ProgressBarDialogFactory() : null; try { Resizing = true; //if no file is selected open file picker if (ImageFiles == null || ImageFiles.Count == 0) { await OpenFilePicker(); } #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed progressBarDialog?.StartAsync(ImageFiles.Count); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed String suggestedFileName = String.Empty; String targetStorageFolder = Settings.DefaultSaveAsTargetFolder; Exception lastException = null; if (ImageFiles != null) { foreach (ImageFile currentImage in ImageFiles) { try { SelectedFile = currentImage; suggestedFileName = _imageFileService.GenerateResizedFileName(currentImage, currentImage.NewWidth, currentImage.NewHeight); if (progressBarDialog != null) { progressBarDialog.CurrentItem = suggestedFileName; } //if the stream is disposed CanSeek and CanRead is false if (currentImage.Stream == null || !currentImage.Stream.CanSeek && !currentImage.Stream.CanRead) { var imageFile = (await _imageFileService.LoadImageFileAsync(currentImage.Path)); if (imageFile?.Stream != null) { currentImage.Stream = imageFile.Stream; } else { _loggerService.LogEvent("Could not load stream.", new Dictionary <string, string>() { { nameof(currentImage.Path), currentImage.Path } }); continue; } } TaskCompletionSource <MemoryStream> taskMemoryStreamCompletionSource = new TaskCompletionSource <MemoryStream>(); if (!IsShareTarget) { //do the resizing in a seperate thread using Task.Run try { var ms = await Task.Run(() => _resizeService.ResizeAsync(currentImage.Stream, currentImage.NewWidth, currentImage.NewHeight, suggestedFileName, _localSettings.Settings.ImageQuality)); taskMemoryStreamCompletionSource.SetResult(ms); } catch (Exception e) { taskMemoryStreamCompletionSource.SetException(e); } } else { //do the resizing on the main thread in share target to avoid issues see #53 var ms = await _resizeService.ResizeAsync(currentImage.Stream, currentImage.NewWidth, currentImage.NewHeight, suggestedFileName, _localSettings.Settings.ImageQuality); taskMemoryStreamCompletionSource.SetResult(ms); } using (MemoryStream resizedImageFileStream = await taskMemoryStreamCompletionSource.Task) { //log image size _loggerService?.LogEvent(nameof(IResizeService.ResizeAsync), new Dictionary <String, String>() { { $"{nameof(ImageFile)}{nameof(Width)}", $"{currentImage?.Width}" }, { $"{nameof(ImageFile)}{nameof(Height)}", $"{currentImage?.Height}" }, { nameof(Width), $"{currentImage?.NewHeight }" }, { nameof(Height), $"{currentImage?.NewHeight}" }, { nameof(ImageAction), $"{action}" } }); //overwrite current ImageStoreage if (action.Equals(ImageAction.Save)) { try { await _imageFileService.WriteBytesAsync(currentImage, resizedImageFileStream.ToArray()); LastFile = currentImage; } catch (Contract.Exceptions.UnauthorizedAccessException) { //log the UnauthorizedAccessException _loggerService?.LogEvent(nameof(ResizeImages), new Dictionary <String, String>() { { nameof(Contract.Exceptions.UnauthorizedAccessException), $"{true}" }, }); //we can't override the current file try for the next files saveAs action = ImageAction.SaveAs; await ShowPermissionDeniedDialog(progressBarDialog); ImageFile File = await _imageFileService.PickSaveFileAsync(currentImage.Path, suggestedFileName); if (null != File) { //try to apply the new storagefolder (if the user selected a new location) targetStorageFolder = Path.GetDirectoryName(File.Path); await _imageFileService.WriteBytesAsync(File, resizedImageFileStream.ToArray()); LastFile = File; } } } //create new ImageStoreage else if (action.Equals(ImageAction.SaveAs)) { ImageFile imageFile = null; try { //if the user enabled the option "save images to same folder" if (Settings.SaveFilesForSaveAsInSameFolder && !AppStartType.AppIsShareTarget.Equals(_appStartType)) { targetStorageFolder = Path.GetDirectoryName(currentImage.Path); } if (String.IsNullOrEmpty(targetStorageFolder)) { if (SingleFile) { //get default path imageFile = await _imageFileService.PickSaveFileAsync(currentImage.Path, suggestedFileName); } else { imageFile = await _imageFileService.PickSaveFolderAsync(currentImage.Path, suggestedFileName); } if (imageFile == null) { //if user canceled dialog try again imageFile = await _imageFileService.PickSaveFileAsync(currentImage.Path, suggestedFileName); } //File can be null when user aborted picksavefile dialog if (imageFile != null) { targetStorageFolder = Path.GetDirectoryName(imageFile.Path); await _imageFileService.WriteBytesAsync(imageFile, resizedImageFileStream.ToArray()); LastFile = imageFile; } } else { await _imageFileService.WriteBytesAsync(targetStorageFolder, suggestedFileName, resizedImageFileStream.ToArray()); } } catch (FileNotFoundException) { //happens if the targetStorageFolder from the settings was removed (or renamed) meanwhile _loggerService?.LogEvent(nameof(ResizeImages), new Dictionary <String, String>() { { nameof(FileNotFoundException), true.ToString() }, }); //happens if the targetStorageFolder was removed meanwhile Settings.DefaultSaveAsTargetFolder = String.Empty; //tell the user to save the file in an other location imageFile = await _imageFileService.PickSaveFileAsync(currentImage.Path, suggestedFileName); //try to apply the new storagefolder (if the user selected a new location) if (imageFile != null && Path.GetDirectoryName(targetStorageFolder) != Path.GetDirectoryName(imageFile.Path)) { targetStorageFolder = Path.GetDirectoryName(imageFile.Path); await _imageFileService.WriteBytesAsync(imageFile, resizedImageFileStream.ToArray()); } } catch (Contract.Exceptions.UnauthorizedAccessException) { //log the UnauthorizedAccessException _loggerService?.LogEvent(nameof(ResizeImages), new Dictionary <String, String>() { { nameof(Contract.Exceptions.UnauthorizedAccessException), true.ToString() }, }); //tell the user to save the file in an other location imageFile = await _imageFileService.PickSaveFileAsync(currentImage.Path, suggestedFileName); //try to apply the new storagefolder (if the user selected a new location) if (imageFile != null && Path.GetDirectoryName(targetStorageFolder) != Path.GetDirectoryName(imageFile.Path)) { targetStorageFolder = Path.GetDirectoryName(imageFile.Path); await _imageFileService.WriteBytesAsync(imageFile, resizedImageFileStream.ToArray()); } await ShowPermissionDeniedDialog(progressBarDialog); } if (null != imageFile) { LastFile = imageFile; } _loggerService?.LogEvent(nameof(ResizeImages), new Dictionary <String, String>() { { nameof(currentImage.Path), $"{currentImage.Path}" } }); } else if (action.Equals(ImageAction.Process)) { String TempFolder = _applicationService.GetTemporaryFolderPath(); ImageFile temp = await _imageFileService.WriteBytesAsync(TempFolder, suggestedFileName, resizedImageFileStream.ToArray()); processedImageAction?.Invoke(temp, $"{suggestedFileName}"); } //open resized image depending whether only one image is resized and the user enabled this option if (SingleFile && LastFile != null && action != ImageAction.Process && _localSettings.Settings.EnabledOpenSingleFileAfterResize) { OpenFileCommand.Execute(LastFile); } } currentImage?.Stream?.Dispose(); } catch (NotSupportedException e) { _loggerService?.LogException($"{nameof(ResizeImages)}{nameof(ImageFiles)}", e, new Dictionary <string, string>() { { nameof(suggestedFileName), suggestedFileName } }); await _pageDialogService?.ShowAsync(_resourceLoader.GetString("ImageTypNotSupported")); } catch (InvalidOperationException e) { //for example when enterted width and height is zero. 'Target width 0 and height 0 must be greater than zero.' lastException = e; } catch (FileLoadException e) { //for example The process cannot access the file because it is being used by another process. lastException = e; } catch (UnknownImageFormatException e) { lastException = e; } catch (Exception e) { lastException = e; _loggerService?.LogException($"{nameof(ResizeImages)}{nameof(ImageFiles)}", e); } if (progressBarDialog != null) { progressBarDialog.ProcessedItems++; if (progressBarDialog.AbortedClicked()) { _loggerService?.LogEvent(nameof(IResizeService.ResizeAsync), new Dictionary <String, String>() { { nameof(progressBarDialog.AbortedClicked), Boolean.TrueString } }); return(false); } } } if (_localSettings != null && _localSettings.Settings.ShowSuccessMessage && LastFile != null) { await _pageDialogService?.ShowAsync(GenerateSuccess(LastFile)); } if (IsShareTarget) { _shareService.EndShareTargetOperation(); } Resizing = false; if (lastException != null) { if (lastException is InvalidOperationException || lastException is FileLoadException) { await _pageDialogService.ShowAsync(lastException.Message); } if (lastException is UnknownImageFormatException) { String message = _resourceLoader.GetString("UnknownImageFormatException"); if (!String.IsNullOrEmpty(message)) { message = String.Format(message, string.Join(", ", _imageFileService.FileTypeFilter)); await _pageDialogService.ShowAsync(message); } } } } } catch (Exception e) { _loggerService?.LogException(nameof(ResizeImages), e); _loggerService?.LogEvent(nameof(IResizeService.ResizeAsync), new Dictionary <String, String>() { { "ResizeFinished", "false" } }); return(false); } finally { progressBarDialog?.Stop(); Resizing = false; } //log image size _loggerService?.LogEvent(nameof(IResizeService.ResizeAsync), new Dictionary <String, String>() { { "ResizeFinished", "true" } }); return(true); }