public void HandleAction(IActionContext actionContext)
{
void SetIfNotEmpty(string path)
{
if (!string.IsNullOrEmpty(path))
{
SettingValue = path;
}
}
FileDialogOptions options = new FileDialogOptions(_filter, initialDirectory: SettingValue);
if (IsFolderPicker)
{
string folderPath = _dialogService.ShowSelectFolderDialog(options);
SetIfNotEmpty(folderPath);
return;
}
string filePath = IsSaveFilePicker
? _dialogService.ShowSaveFileDialog(options)
: _dialogService.ShowOpenFileDialog(options);
SetIfNotEmpty(filePath);
}
Optional <FileDialogResult> OpenFileSync(FileDialogOptions options)
{
var ofd = new Microsoft.Win32.OpenFileDialog
{
Title = options.Caption,
Filter = options.Filters.CreateFilterString(),
CheckPathExists = true,
CheckFileExists = true,
};
FilterString.Parse(ofd.Filter).Each(f => Console.WriteLine(f));
if (options.Directory != null)
{
ofd.InitialDirectory = options.Directory.NativePath;
}
var success = _window == null?ofd.ShowDialog() : ofd.ShowDialog(_window);
var filename = ofd.FileName;
var result = new FileDialogResult();
if (success.Value)
{
result.Path = AbsoluteFilePath.Parse(ofd.FileName);
result.Filter = FilterAtIndex(ofd.Filter, ofd.FilterIndex);
}
Focus();
return(success.Value
? Optional.Some(result)
: Optional.None <FileDialogResult>());
}
Optional <FileDialogResult> OpenFileSync(FileDialogOptions options)
{
var dialog = new OpenDialog(options.Filters)
{
Title = options.Caption,
Multiselect = false
};
if (options.Directory != null)
{
dialog.Directory = options.Directory;
}
var success = dialog.Run();
FileDialogResult result = new FileDialogResult();
if (success)
{
result = new FileDialogResult(dialog.FilePath, dialog.CurrentFilter);
}
return(success
? Optional.Some(result)
: Optional.None <FileDialogResult>());
}
public void SelectPath()
{
void SetIfNotEmpty(string path)
{
if (!string.IsNullOrEmpty(path))
{
Path = path;
}
}
FileDialogOptions options = new FileDialogOptions(Filter, Window.GetWindow(this), Path);
if (IsFolderPicker)
{
string folderPath = DialogService.ShowSelectFolderDialog(options);
SetIfNotEmpty(folderPath);
return;
}
string filePath = IsSaveFilePicker
? DialogService.ShowSaveFileDialog(options)
: DialogService.ShowOpenFileDialog(options);
SetIfNotEmpty(filePath);
}
Optional <IEnumerable <FileDialogResult> > OpenFilesSync(FileDialogOptions options)
{
var dialog = new OpenDialog(options.Filters)
{
Title = options.Caption,
Multiselect = true
};
if (options.Directory != null)
{
dialog.Directory = options.Directory;
}
var success = dialog.Run();
IEnumerable <FileDialogResult> result = null;
if (success)
{
result = dialog.FilePaths.Select(f => new FileDialogResult(f, dialog.CurrentFilter));
}
return(success
? Optional.Some(result)
: Optional.None <IEnumerable <FileDialogResult> >());
}
Optional <FileDialogResult> SaveFileSync(FileDialogOptions options)
{
var ofd = new Microsoft.Win32.SaveFileDialog
{
Title = options.Caption,
Filter = options.Filters.CreateFilterString(),
OverwritePrompt = true,
};
if (options.Directory != null)
{
ofd.InitialDirectory = options.Directory.NativePath;
}
var success = _window == null?ofd.ShowDialog() : ofd.ShowDialog(_window);
var filename = ofd.FileName;
var result = new FileDialogResult();
if (success.Value)
{
result.Path = AbsoluteFilePath.Parse(ofd.FileName);
result.Filter = FilterAtIndex(ofd.Filter, ofd.FilterIndex);
}
Focus();
return(success.Value
? Optional.Some(result)
: Optional.None <FileDialogResult>());
}
public DialogResponse FileOpen64(string message, FileDialogOptions options)
{
var ofn = new WindowsInterop.OPENFILENAME_64();
ofn.lstructSize = Marshal.SizeOf(ofn);
if (Directory.Exists(options.Directory))
{
ofn.lpstrInitialDir = options.Directory;
}
ofn.lpstrFilter = options.Filters
.Select(f => $"{f.Name}\0*.{f.Extension}\0")
.Aggregate("", (s1, s2) => s1 + s2)
+ "\0";
ofn.lpstrFile = new string(' ', 4096);
ofn.lMaxFile = ofn.lpstrFile.Length;
ofn.lpstrTitle = options.Title;
ofn.lMaxFileTitle = ofn.lpstrTitle.Length;
ofn.lFlags = WindowsInterop.OFN_EXPLORER;
if (options.MustExist)
{
ofn.lFlags |= WindowsInterop.OFN_PATHMUSTEXIST | WindowsInterop.OFN_FILEMUSTEXIST;
}
var ok = WindowsInterop.GetOpenFileName64(ofn);
return(new DialogResponse {
IsCanceled = !ok, Value = ofn.lpstrFile
});
}
Optional <FileDialogResult> SaveFileSync(FileDialogOptions options)
{
var dialog = new SaveDialog(options.Filters)
{
Title = options.Caption,
};
if (options.Directory != null)
{
dialog.Directory = options.Directory;
}
var success = dialog.Run(_window);
FileDialogResult result = new FileDialogResult();
if (success)
{
result = new FileDialogResult(dialog.FilePath, dialog.CurrentFilter);
}
return(success
? Optional.Some(result)
: Optional.None <FileDialogResult>());
}
public App(LocalNotificationManager manager)
{
this.manager = manager;
formatter = new JsonFormatter();
FileDialogOptions readOptions = new FileDialogOptions
{
StartLocation = PickerLocationId.DocumentsLibrary,
FileExtensions = new[]
{
new FileExtension {
Name = "JSON", FileSuffix = "json"
},
new FileExtension {
Name = "TEXT", FileSuffix = "txt"
}
}
};
FileDialogOptions writeOptions = new FileDialogOptions
{
StartLocation = PickerLocationId.DocumentsLibrary,
DefaultFileName = "formattedJson",
FileExtensions = new[]
{
new FileExtension {
Name = "JSON", FileSuffix = "json"
},
}
};
reader = new FileReader(readOptions);
writer = new FileWriter(writeOptions);
}
public DialogResponse FileOpen(string message, FileDialogOptions options)
{
var widget = IntPtr.Zero;
var response = GtkInterop.ResponseType.GTK_RESPONSE_OK;
var ok = GtkInterop.AllocGtkString("OK");
var cancel = GtkInterop.AllocGtkString("Cancel");
var fileName = "";
try
{
widget = GtkInterop.gtk_file_chooser_dialog_new(options.Title, IntPtr.Zero,
GtkInterop.FileChooserAction.GTK_FILE_CHOOSER_ACTION_OPEN,
ok, (int)GtkInterop.ResponseType.GTK_RESPONSE_OK,
cancel, (int)GtkInterop.ResponseType.GTK_RESPONSE_CANCEL,
IntPtr.Zero);
if (!string.IsNullOrEmpty(options.Directory) && Directory.Exists(options.Directory))
{
GtkInterop.gtk_file_chooser_set_current_folder(widget, options.Directory);
}
if (options.MustExist)
{
Log.Error("FileOpen option MustExist not supported.");
}
foreach (var fileFilter in options.Filters)
{
var filter = GtkInterop.gtk_file_filter_new();
GtkInterop.gtk_file_filter_set_name(filter, fileFilter.Name);
GtkInterop.gtk_file_filter_add_pattern(filter, $"*.{fileFilter.Extension}");
GtkInterop.gtk_file_chooser_add_filter(widget, filter);
}
response = GtkInterop.gtk_dialog_run(widget);
if (response == GtkInterop.ResponseType.GTK_RESPONSE_OK)
{
fileName = Uri.UnescapeDataString(GtkInterop.gtk_file_chooser_get_filename(widget));
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
GtkInterop.gtk_widget_destroy(widget);
GtkInterop.g_free(ok);
GtkInterop.g_free(cancel);
}
return(new DialogResponse
{
IsCanceled = response != GtkInterop.ResponseType.GTK_RESPONSE_OK,
Value = fileName
});
}
public FileReader(FileDialogOptions fileDialogOptions)
{
fileOpen = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = fileDialogOptions.StartLocation
};
foreach (var extension in fileDialogOptions.FileExtensions)
{
fileOpen.FileTypeFilter.Add(extension.FileSuffix);
}
}
private void SaveFile()
{
var options = new FileDialogOptions()
{
Filter = Filter
};
var result = _fileDialogService.ShowSaveFileDialog(options);
if (result != null)
{
FileName = result.FileName;
}
}
public FileWriter(FileDialogOptions fileDialogOptions)
{
fileSave = new FileSavePicker
{
SuggestedStartLocation = fileDialogOptions.StartLocation
};
foreach (var extension in fileDialogOptions.FileExtensions)
{
fileSave.FileTypeChoices.Add(extension.Name, new List <string> {
extension.FileSuffix
});
}
defaultFileName = fileDialogOptions.DefaultFileName;
fileSave.SuggestedFileName = defaultFileName;
}
private DialogResponse SelectFolderInternal(string message, FileDialogOptions options)
{
if (Directory.Exists(options.Directory))
{
_initialPath = options.Directory;
}
var pIdList = IntPtr.Zero;
var sb = new StringBuilder(256);
var bufferAddress = Marshal.AllocHGlobal(256);
var bi = new WindowsInterop.BROWSEINFO
{
hwndOwner = IntPtr.Zero,
pidlRoot = IntPtr.Zero,
pszDisplayName = message,
lpszTitle = options.Title,
ulFlags = WindowsInterop.BIF_NEWDIALOGSTYLE | WindowsInterop.BIF_SHAREABLE,
lpfn = OnBrowseEvent,
lParam = IntPtr.Zero,
iImage = 0
};
try
{
pIdList = WindowsInterop.SHBrowseForFolder(ref bi);
if (pIdList == IntPtr.Zero)
{
return(new DialogResponse {
IsCanceled = true
});
}
if (true != WindowsInterop.SHGetPathFromIDList(pIdList, bufferAddress))
{
return(new DialogResponse {
Value = string.Empty
});
}
sb.Append(Marshal.PtrToStringAuto(bufferAddress));
}
finally
{
// Caller is responsible for freeing this memory.
Marshal.FreeCoTaskMem(pIdList);
}
return(new DialogResponse {
Value = sb.ToString()
});
}
private void Open()
{
var options = new FileDialogOptions()
{
Filter = FileFilter
};
var result = _fileDialogService.ShowOpenFileDialog(options);
if (result != null)
{
var metadata = HostPersistor.LoadFromFile(result.FileName);
Filename = result.FileName;
Program = new ProgramViewModel(metadata.Functions);
}
}
private bool SaveAs()
{
var options = new FileDialogOptions()
{
Filter = FileFilter
};
var result = _fileDialogService.ShowSaveFileDialog(options);
if (result != null)
{
Filename = result.FileName;
SaveInner();
return(true);
}
return(false);
}
private bool SaveAs()
{
var options = new FileDialogOptions()
{
Filter = Filter
};
var result = _fileDialogService.ShowSaveFileDialog(options);
if (result == null)
{
return(false);
}
File.WriteAllText(result.FileName, Text);
Path = result.FileName;
_dirtyService.MarkClean();
return(true);
}
public DialogResponse SelectFolder(string message, FileDialogOptions options)
{
var result = new DialogResponse {
IsCanceled = true
};
var th = new Thread(() =>
{
WindowsInterop.OleInitialize(IntPtr.Zero);
result = SelectFolderInternal(message, options);
})
{
#pragma warning disable 618
ApartmentState = ApartmentState.STA
#pragma warning restore 618
};
th.Start();
th.Join();
return(result);
}
private void Open()
{
if (!SaveIfDirty())
{
return;
}
var options = new FileDialogOptions()
{
Filter = Filter
};
var result = _fileDialogService.ShowOpenFileDialog(options);
if (result != null)
{
Path = result.FileName;
Text = File.ReadAllText(result.FileName);
_dirtyService.MarkClean();
}
}
public DialogResponse SelectFolder(string message, FileDialogOptions options)
{
var widget = IntPtr.Zero;
var response = GtkInterop.ResponseType.GTK_RESPONSE_OK;
var ok = GtkInterop.AllocGtkString("OK");
var cancel = GtkInterop.AllocGtkString("Cancel");
var folder = "";
try
{
widget = GtkInterop.gtk_file_chooser_dialog_new(options.Title, IntPtr.Zero,
GtkInterop.FileChooserAction.GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
ok, (int)GtkInterop.ResponseType.GTK_RESPONSE_OK,
cancel, (int)GtkInterop.ResponseType.GTK_RESPONSE_CANCEL,
IntPtr.Zero);
response = GtkInterop.gtk_dialog_run(widget);
if (response == GtkInterop.ResponseType.GTK_RESPONSE_OK)
{
var uri = new Uri(GtkInterop.gtk_file_chooser_get_uri(widget));
folder = Uri.UnescapeDataString(uri.AbsolutePath);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
GtkInterop.gtk_widget_destroy(widget);
GtkInterop.g_free(ok);
GtkInterop.g_free(cancel);
}
return(new DialogResponse
{
IsCanceled = response != GtkInterop.ResponseType.GTK_RESPONSE_OK,
Value = folder
});
}
Optional <IEnumerable <FileDialogResult> > OpenFilesSync(FileDialogOptions options)
{
var ofd = new Microsoft.Win32.OpenFileDialog
{
Title = options.Caption,
Filter = options.Filters.CreateFilterString(),
CheckPathExists = true,
CheckFileExists = true,
Multiselect = true,
};
Console.WriteLine(FilterString.Parse(ofd.Filter));
if (options.Directory != null)
{
ofd.InitialDirectory = options.Directory.NativePath;
}
var success = _window == null?ofd.ShowDialog() : ofd.ShowDialog(_window);
var filenames = ofd.FileNames;
filenames.Select(AbsoluteFilePath.Parse);
IEnumerable <FileDialogResult> results = null;
if (success.Value)
{
var f = FilterAtIndex(ofd.Filter, ofd.FilterIndex);
results = ofd.FileNames.Select(
p => new FileDialogResult(AbsoluteFilePath.Parse(p), f)
);
}
Focus();
return(success.Value
? Optional.Some(results)
: Optional.None <IEnumerable <FileDialogResult> >());
}
public DialogResponse FileOpen(string message, FileDialogOptions options)
{
return(Environment.Is64BitProcess
? FileOpen64(message, options)
: FileOpen32(message, options));
}
public DialogResponse FileSave(string message, string fileName, FileDialogOptions options)
{
return(Environment.Is64BitProcess
? FileSave64(message, fileName, options)
: FileSave32(message, fileName, options));
}
public Task <Optional <IEnumerable <FileDialogResult> > > OpenFiles(FileDialogOptions options)
{
return(_dispatcher.InvokeAsync(() => OpenFilesSync(options)).Task);
}
/// <summary>
/// ファイルダイアログオプションを設定します。
/// </summary>
/// <param name="fileDialogOptions"></param>
public void SetOptions(FileDialogOptions fileDialogOptions)
{
var options = FILEOPENDIALOGOPTIONS.FOS_NOTESTFILECREATE | (FILEOPENDIALOGOPTIONS)fileDialogOptions;
this.FileDialogNative.SetOptions(options);
}
public Task <Optional <IEnumerable <FileDialogResult> > > OpenFiles(FileDialogOptions options)
{
return(Fusion.Application.MainThread.InvokeAsync(() => OpenFilesSync(options)));
}
public Task <Optional <FileDialogResult> > SaveFile(FileDialogOptions options)
{
return(Fusion.Application.MainThread.InvokeAsync(() => SaveFileSync(options)));
}
public static Task <Optional <FileDialogResult> > OpenFile(FileDialogOptions options, Optional <IControl> windowControl = default(Optional <IControl>))
{
return(Implementation(windowControl).OpenFile(options));
}
public Task <Optional <FileDialogResult> > SaveFile(FileDialogOptions options)
{
return(_dispatcher.InvokeAsync(() => SaveFileSync(options)).Task);
}