zenity/file_windows.go

452 lines
11 KiB
Go
Raw Permalink Normal View History

2019-12-29 20:00:50 -05:00
package zenity
2019-12-13 08:45:23 -05:00
import (
"path/filepath"
2019-12-28 10:34:38 -05:00
"reflect"
2020-01-02 20:44:23 -05:00
"runtime"
2019-12-13 08:45:23 -05:00
"syscall"
"unicode/utf16"
"unsafe"
)
2019-12-13 20:07:25 -05:00
var (
2019-12-28 10:34:38 -05:00
getOpenFileName = comdlg32.NewProc("GetOpenFileNameW")
getSaveFileName = comdlg32.NewProc("GetSaveFileNameW")
shBrowseForFolder = shell32.NewProc("SHBrowseForFolderW")
shGetPathFromIDListEx = shell32.NewProc("SHGetPathFromIDListEx")
shCreateItemFromParsingName = shell32.NewProc("SHCreateItemFromParsingName")
2019-12-13 20:07:25 -05:00
)
2019-12-13 08:45:23 -05:00
2020-01-26 11:04:49 -05:00
func selectFile(options []Option) (string, error) {
2020-01-24 07:52:45 -05:00
opts := applyOptions(options)
2020-01-09 20:46:53 -05:00
if opts.directory {
res, _, err := pickFolders(opts, false)
return res, err
}
2019-12-13 08:45:23 -05:00
var args _OPENFILENAME
args.StructSize = uint32(unsafe.Sizeof(args))
args.Flags = 0x81008 // OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_EXPLORER
2019-12-13 08:45:23 -05:00
2020-01-02 20:44:23 -05:00
if opts.title != "" {
args.Title = syscall.StringToUTF16Ptr(opts.title)
2019-12-13 08:45:23 -05:00
}
2020-01-24 07:52:45 -05:00
if opts.showHidden {
args.Flags |= 0x10000000 // OFN_FORCESHOWHIDDEN
}
2020-01-24 07:52:45 -05:00
if opts.fileFilters != nil {
args.Filter = &initFilters(opts.fileFilters)[0]
2020-01-08 19:54:34 -05:00
}
2019-12-13 08:45:23 -05:00
2019-12-28 10:34:38 -05:00
res := [32768]uint16{}
2019-12-13 08:45:23 -05:00
args.File = &res[0]
args.MaxFile = uint32(len(res))
args.InitialDir, args.DefExt = initDirNameExt(opts.filename, res[:])
2019-12-13 08:45:23 -05:00
2020-01-02 20:44:23 -05:00
runtime.LockOSThread()
defer runtime.UnlockOSThread()
2019-12-28 10:34:38 -05:00
n, _, _ := getOpenFileName.Call(uintptr(unsafe.Pointer(&args)))
if n == 0 {
2020-01-02 20:44:23 -05:00
return "", commDlgError()
2019-12-28 10:34:38 -05:00
}
2019-12-13 08:45:23 -05:00
return syscall.UTF16ToString(res[:]), nil
}
2020-01-26 11:04:49 -05:00
func selectFileMutiple(options []Option) ([]string, error) {
2020-01-24 07:52:45 -05:00
opts := applyOptions(options)
2020-01-09 20:46:53 -05:00
if opts.directory {
_, res, err := pickFolders(opts, true)
return res, err
}
2019-12-13 08:45:23 -05:00
var args _OPENFILENAME
args.StructSize = uint32(unsafe.Sizeof(args))
args.Flags = 0x81208 // OFN_NOCHANGEDIR|OFN_ALLOWMULTISELECT|OFN_FILEMUSTEXIST|OFN_EXPLORER
2019-12-13 08:45:23 -05:00
2020-01-02 20:44:23 -05:00
if opts.title != "" {
args.Title = syscall.StringToUTF16Ptr(opts.title)
2019-12-13 08:45:23 -05:00
}
2020-01-24 07:52:45 -05:00
if opts.showHidden {
args.Flags |= 0x10000000 // OFN_FORCESHOWHIDDEN
}
2020-01-24 07:52:45 -05:00
if opts.fileFilters != nil {
args.Filter = &initFilters(opts.fileFilters)[0]
2020-01-08 19:54:34 -05:00
}
2019-12-13 08:45:23 -05:00
2019-12-28 10:34:38 -05:00
res := [32768 + 1024*256]uint16{}
2019-12-13 08:45:23 -05:00
args.File = &res[0]
args.MaxFile = uint32(len(res))
args.InitialDir, args.DefExt = initDirNameExt(opts.filename, res[:])
2019-12-13 08:45:23 -05:00
2020-01-02 20:44:23 -05:00
runtime.LockOSThread()
defer runtime.UnlockOSThread()
2019-12-28 10:34:38 -05:00
n, _, _ := getOpenFileName.Call(uintptr(unsafe.Pointer(&args)))
if n == 0 {
2020-01-02 20:44:23 -05:00
return nil, commDlgError()
2019-12-28 10:34:38 -05:00
}
2019-12-13 08:45:23 -05:00
var i int
var nul bool
var split []string
for j, p := range res {
if p == 0 {
if nul {
break
}
if i < j {
split = append(split, string(utf16.Decode(res[i:j])))
}
i = j + 1
nul = true
} else {
nul = false
}
}
if len := len(split) - 1; len > 0 {
base := split[0]
for i := 0; i < len; i++ {
split[i] = filepath.Join(base, string(split[i+1]))
}
split = split[:len]
}
return split, nil
}
2020-01-26 11:04:49 -05:00
func selectFileSave(options []Option) (string, error) {
2020-01-24 07:52:45 -05:00
opts := applyOptions(options)
if opts.directory {
res, _, err := pickFolders(opts, false)
return res, err
}
2020-01-09 20:46:53 -05:00
2019-12-13 08:45:23 -05:00
var args _OPENFILENAME
args.StructSize = uint32(unsafe.Sizeof(args))
args.Flags = 0x88808 // OFN_NOCHANGEDIR|OFN_PATHMUSTEXIST|OFN_NOREADONLYRETURN|OFN_EXPLORER
2019-12-13 08:45:23 -05:00
2020-01-02 20:44:23 -05:00
if opts.title != "" {
args.Title = syscall.StringToUTF16Ptr(opts.title)
2019-12-13 08:45:23 -05:00
}
2020-01-24 07:52:45 -05:00
if opts.confirmOverwrite {
2019-12-28 10:34:38 -05:00
args.Flags |= 0x2 // OFN_OVERWRITEPROMPT
2019-12-13 08:45:23 -05:00
}
2020-01-24 07:52:45 -05:00
if opts.confirmCreate {
args.Flags |= 0x2000 // OFN_CREATEPROMPT
}
2020-01-24 07:52:45 -05:00
if opts.showHidden {
args.Flags |= 0x10000000 // OFN_FORCESHOWHIDDEN
}
2020-01-24 07:52:45 -05:00
if opts.fileFilters != nil {
args.Filter = &initFilters(opts.fileFilters)[0]
2020-01-08 19:54:34 -05:00
}
2019-12-13 08:45:23 -05:00
2019-12-28 10:34:38 -05:00
res := [32768]uint16{}
2019-12-13 08:45:23 -05:00
args.File = &res[0]
args.MaxFile = uint32(len(res))
args.InitialDir, args.DefExt = initDirNameExt(opts.filename, res[:])
2019-12-13 08:45:23 -05:00
2020-01-02 20:44:23 -05:00
runtime.LockOSThread()
defer runtime.UnlockOSThread()
2019-12-28 10:34:38 -05:00
n, _, _ := getSaveFileName.Call(uintptr(unsafe.Pointer(&args)))
if n == 0 {
2020-01-02 20:44:23 -05:00
return "", commDlgError()
2019-12-28 10:34:38 -05:00
}
2019-12-13 08:45:23 -05:00
return syscall.UTF16ToString(res[:]), nil
}
2020-01-09 20:46:53 -05:00
func pickFolders(opts options, multi bool) (str string, lst []string, err error) {
2020-01-02 20:44:23 -05:00
runtime.LockOSThread()
defer runtime.UnlockOSThread()
2019-12-28 10:34:38 -05:00
hr, _, _ := coInitializeEx.Call(0, 0x6) // COINIT_APARTMENTTHREADED|COINIT_DISABLE_OLE1DDE
2020-01-02 20:44:23 -05:00
if hr != 0x80010106 { // RPC_E_CHANGED_MODE
if int32(hr) < 0 {
2020-01-09 20:46:53 -05:00
return "", nil, syscall.Errno(hr)
2020-01-02 20:44:23 -05:00
}
defer coUninitialize.Call()
2019-12-28 10:34:38 -05:00
}
2020-01-02 20:44:23 -05:00
2019-12-28 10:34:38 -05:00
var dialog *_IFileOpenDialog
hr, _, _ = coCreateInstance.Call(
_CLSID_FileOpenDialog, 0, 0x17, // CLSCTX_ALL
_IID_IFileOpenDialog, uintptr(unsafe.Pointer(&dialog)))
2020-01-02 20:44:23 -05:00
if int32(hr) < 0 {
return browseForFolder(opts)
2019-12-28 10:34:38 -05:00
}
defer dialog.Call(dialog.vtbl.Release)
2020-01-02 20:44:23 -05:00
var flgs int
hr, _, _ = dialog.Call(dialog.vtbl.GetOptions, uintptr(unsafe.Pointer(&flgs)))
if int32(hr) < 0 {
2020-01-09 20:46:53 -05:00
return "", nil, syscall.Errno(hr)
}
if multi {
flgs |= 0x200 // FOS_ALLOWMULTISELECT
2019-12-28 10:34:38 -05:00
}
2020-01-24 07:52:45 -05:00
if opts.showHidden {
flgs |= 0x10000000 // FOS_FORCESHOWHIDDEN
}
2020-01-02 20:44:23 -05:00
hr, _, _ = dialog.Call(dialog.vtbl.SetOptions, uintptr(flgs|0x68)) // FOS_NOCHANGEDIR|FOS_PICKFOLDERS|FOS_FORCEFILESYSTEM
if int32(hr) < 0 {
2020-01-09 20:46:53 -05:00
return "", nil, syscall.Errno(hr)
2019-12-28 10:34:38 -05:00
}
2020-01-02 20:44:23 -05:00
if opts.title != "" {
ptr := syscall.StringToUTF16Ptr(opts.title)
2019-12-28 10:34:38 -05:00
dialog.Call(dialog.vtbl.SetTitle, uintptr(unsafe.Pointer(ptr)))
}
2020-01-02 20:44:23 -05:00
if opts.filename != "" {
2019-12-28 10:34:38 -05:00
var item *_IShellItem
2020-01-02 20:44:23 -05:00
ptr := syscall.StringToUTF16Ptr(opts.filename)
2019-12-28 10:34:38 -05:00
hr, _, _ = shCreateItemFromParsingName.Call(
uintptr(unsafe.Pointer(ptr)), 0,
_IID_IShellItem,
uintptr(unsafe.Pointer(&item)))
if hr >= 0 && item != nil {
dialog.Call(dialog.vtbl.SetDefaultFolder, uintptr(unsafe.Pointer(item)))
item.Call(item.vtbl.Release)
}
}
hr, _, _ = dialog.Call(dialog.vtbl.Show, 0)
2020-01-02 20:44:23 -05:00
if hr == 0x800704c7 { // ERROR_CANCELLED
2020-01-09 20:46:53 -05:00
return "", nil, nil
2020-01-02 20:44:23 -05:00
}
if int32(hr) < 0 {
2020-01-09 20:46:53 -05:00
return "", nil, syscall.Errno(hr)
2019-12-28 10:34:38 -05:00
}
2020-01-09 20:46:53 -05:00
shellItemPath := func(obj *_COMObject, trap uintptr, a ...uintptr) error {
var item *_IShellItem
hr, _, _ := obj.Call(trap, append(a, uintptr(unsafe.Pointer(&item)))...)
if int32(hr) < 0 {
return syscall.Errno(hr)
}
defer item.Call(item.vtbl.Release)
2019-12-28 10:34:38 -05:00
2020-01-09 20:46:53 -05:00
var ptr uintptr
hr, _, _ = item.Call(item.vtbl.GetDisplayName,
0x80058000, // SIGDN_FILESYSPATH
uintptr(unsafe.Pointer(&ptr)))
if int32(hr) < 0 {
return syscall.Errno(hr)
}
defer coTaskMemFree.Call(ptr)
res := reflect.SliceHeader{Data: ptr, Len: 32768, Cap: 32768}
str = syscall.UTF16ToString(*(*[]uint16)(unsafe.Pointer(&res)))
lst = append(lst, str)
return nil
2019-12-28 10:34:38 -05:00
}
2020-01-09 20:46:53 -05:00
if multi {
var items *_IShellItemArray
hr, _, _ = dialog.Call(dialog.vtbl.GetResults, uintptr(unsafe.Pointer(&items)))
if int32(hr) < 0 {
return "", nil, syscall.Errno(hr)
}
defer items.Call(items.vtbl.Release)
var count uint32
hr, _, _ = items.Call(items.vtbl.GetCount, uintptr(unsafe.Pointer(&count)))
if int32(hr) < 0 {
return "", nil, syscall.Errno(hr)
}
for i := uintptr(0); i < uintptr(count) && err == nil; i++ {
2020-01-09 20:46:53 -05:00
err = shellItemPath(&items._COMObject, items.vtbl.GetItemAt, i)
}
} else {
err = shellItemPath(&dialog._COMObject, dialog.vtbl.GetResult)
}
return
2019-12-28 10:34:38 -05:00
}
func browseForFolder(opts options) (string, []string, error) {
2019-12-13 20:07:25 -05:00
var args _BROWSEINFO
2019-12-28 10:34:38 -05:00
args.Flags = 0x1 // BIF_RETURNONLYFSDIRS
2019-12-13 20:07:25 -05:00
if opts.title != "" {
args.Title = syscall.StringToUTF16Ptr(opts.title)
}
if opts.filename != "" {
ptr := syscall.StringToUTF16Ptr(opts.filename)
args.LParam = uintptr(unsafe.Pointer(ptr))
2020-01-17 07:28:44 -05:00
args.CallbackFunc = syscall.NewCallback(func(wnd uintptr, msg uint32, lparam, data uintptr) uintptr {
if msg == 1 { // BFFM_INITIALIZED
2020-01-17 07:28:44 -05:00
sendMessage.Call(wnd, 1024+103 /* BFFM_SETSELECTIONW */, 1 /* TRUE */, data)
}
return 0
})
2019-12-13 20:07:25 -05:00
}
2019-12-28 10:34:38 -05:00
ptr, _, _ := shBrowseForFolder.Call(uintptr(unsafe.Pointer(&args)))
2019-12-13 20:07:25 -05:00
if ptr == 0 {
2020-01-09 20:46:53 -05:00
return "", nil, nil
2019-12-13 20:07:25 -05:00
}
2019-12-28 10:34:38 -05:00
defer coTaskMemFree.Call(ptr)
2019-12-13 20:07:25 -05:00
2019-12-28 10:34:38 -05:00
res := [32768]uint16{}
shGetPathFromIDListEx.Call(ptr, uintptr(unsafe.Pointer(&res[0])), uintptr(len(res)), 0)
2019-12-13 20:07:25 -05:00
2020-01-09 20:46:53 -05:00
str := syscall.UTF16ToString(res[:])
return str, []string{str}, nil
2019-12-13 08:45:23 -05:00
}
func initDirNameExt(filename string, name []uint16) (dir *uint16, ext *uint16) {
2020-01-09 12:05:43 -05:00
if filename != "" {
d, n := splitDirAndName(filename)
e := filepath.Ext(n)
2020-01-09 12:05:43 -05:00
if n != "" {
copy(name, syscall.StringToUTF16(n))
}
if d != "" {
dir = syscall.StringToUTF16Ptr(d)
}
if e != "" {
ext = syscall.StringToUTF16Ptr(e[1:])
2020-01-09 12:05:43 -05:00
}
}
return
2020-01-09 12:05:43 -05:00
}
2020-01-12 18:09:11 -05:00
func initFilters(filters []FileFilter) []uint16 {
2019-12-13 08:45:23 -05:00
var res []uint16
for _, f := range filters {
res = append(res, utf16.Encode([]rune(f.Name))...)
res = append(res, 0)
2020-01-08 19:54:34 -05:00
for _, p := range f.Patterns {
res = append(res, utf16.Encode([]rune(p))...)
2019-12-13 08:45:23 -05:00
res = append(res, uint16(';'))
}
res = append(res, 0)
}
if res != nil {
res = append(res, 0)
}
return res
}
type _OPENFILENAME struct {
StructSize uint32
Owner uintptr
Instance uintptr
Filter *uint16
CustomFilter *uint16
MaxCustomFilter uint32
FilterIndex uint32
File *uint16
MaxFile uint32
FileTitle *uint16
MaxFileTitle uint32
InitialDir *uint16
Title *uint16
Flags uint32
FileOffset uint16
FileExtension uint16
DefExt *uint16
CustData uintptr
FnHook uintptr
TemplateName *uint16
2019-12-13 20:07:25 -05:00
PvReserved uintptr
2019-12-13 08:45:23 -05:00
DwReserved uint32
FlagsEx uint32
}
2019-12-13 20:07:25 -05:00
type _BROWSEINFO struct {
Owner uintptr
2019-12-28 10:34:38 -05:00
Root uintptr
2019-12-13 20:07:25 -05:00
DisplayName *uint16
Title *uint16
Flags uint32
CallbackFunc uintptr
LParam uintptr
Image int32
}
2019-12-28 10:34:38 -05:00
func uuid(s string) uintptr {
return (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
}
var (
_IID_IShellItem = uuid("\x1e\x6d\x82\x43\x18\xe7\xee\x42\xbc\x55\xa1\xe2\x61\xc3\x7b\xfe")
_IID_IFileOpenDialog = uuid("\x88\x72\x7c\xd5\xad\xd4\x68\x47\xbe\x02\x9d\x96\x95\x32\xd9\x60")
_CLSID_FileOpenDialog = uuid("\x9c\x5a\x1c\xdc\x8a\xe8\xde\x4d\xa5\xa1\x60\xf8\x2a\x20\xae\xf7")
)
type _IFileOpenDialog struct {
_COMObject
vtbl *_IFileOpenDialogVtbl
}
type _IShellItem struct {
_COMObject
vtbl *_IShellItemVtbl
}
2020-01-09 20:46:53 -05:00
type _IShellItemArray struct {
_COMObject
vtbl *_IShellItemArrayVtbl
}
2019-12-28 10:34:38 -05:00
type _IFileOpenDialogVtbl struct {
_IFileDialogVtbl
GetResults uintptr
GetSelectedItems uintptr
}
type _IFileDialogVtbl struct {
_IModalWindowVtbl
SetFileTypes uintptr
SetFileTypeIndex uintptr
GetFileTypeIndex uintptr
Advise uintptr
Unadvise uintptr
SetOptions uintptr
GetOptions uintptr
SetDefaultFolder uintptr
SetFolder uintptr
GetFolder uintptr
GetCurrentSelection uintptr
SetFileName uintptr
GetFileName uintptr
SetTitle uintptr
SetOkButtonLabel uintptr
SetFileNameLabel uintptr
GetResult uintptr
AddPlace uintptr
SetDefaultExtension uintptr
Close uintptr
SetClientGuid uintptr
ClearClientData uintptr
SetFilter uintptr
}
type _IModalWindowVtbl struct {
_IUnknownVtbl
Show uintptr
}
type _IShellItemVtbl struct {
_IUnknownVtbl
BindToHandler uintptr
GetParent uintptr
GetDisplayName uintptr
GetAttributes uintptr
Compare uintptr
}
2020-01-09 20:46:53 -05:00
type _IShellItemArrayVtbl struct {
_IUnknownVtbl
BindToHandler uintptr
GetPropertyStore uintptr
GetPropertyDescriptionList uintptr
GetAttributes uintptr
GetCount uintptr
GetItemAt uintptr
EnumItems uintptr
}