dlangui.core.filemanager source code

1 module dlangui.core.filemanager;
2 import dlangui.core.logger;
3 import isfreedesktop;
4 
5 /**
6  * Show and select directory or file in OS file manager.
7  *
8  * On Windows this shows file in File Exporer.
9  *
10  * On macOS it reveals file in Finder.
11  *
12  * On Freedesktop systems this function finds user preferred program that used to open directories.
13  *  If found file manager is known to this function, it uses file manager specific way to select file.
14  *  Otherwise it fallbacks to opening $(D pathName) if it's directory or parent directory of $(D pathName) if it's file.
15  */
16 @trusted bool showInFileManager(string pathName) {
17     import std.process;
18     import std.path;
19     import std.file;
20     Log.i("showInFileManager(", pathName, ")");
21     string normalized = buildNormalizedPath(pathName);
22     if (!normalized.exists) {
23         Log.e("showInFileManager failed - file or directory does not exist");
24         return false;
25     }
26     import std.string;
27     try {
28         version (Windows) {
29             import core.sys.windows.windows;
30             import dlangui.core.files;
31             import std.utf : toUTF16z;
32 
33             string explorerPath = findExecutablePath("explorer.exe");
34             if (!explorerPath.length) {
35                 Log.e("showInFileManager failed - cannot find explorer.exe");
36                 return false;
37             }
38             string arg = "/select,\"" ~ normalized ~ "\"";
39             STARTUPINFO si;
40             si.cb = si.sizeof;
41             PROCESS_INFORMATION pi;
42             Log.d("showInFileManager: ", explorerPath, " ", arg);
43             arg = "\"" ~ explorerPath ~ "\" " ~ arg;
44             auto res = CreateProcessW(null, //explorerPath.toUTF16z,
45                                         cast(wchar*)arg.toUTF16z,
46                                         null, null, false, DETACHED_PROCESS,
47                                         null, null, &si, &pi);
48             if (!res) {
49                 Log.e("showInFileManager failed to run explorer.exe");
50                 return false;
51             }
52             return true;
53         } else version (OSX) {
54             string exe = "/usr/bin/osascript";
55             string[] args;
56             args ~= exe;
57             args ~= "-e";
58             args ~= "tell application \"Finder\" to reveal (POSIX file \"" ~ normalized ~ "\")";
59             Log.d("Executing command: ", args);
60             auto pid = spawnProcess(args);
61             wait(pid);
62             args[2] = "tell application \"Finder\" to activate";
63             Log.d("Executing command: ", args);
64             pid = spawnProcess(args);
65             wait(pid);
66             return true;
67         } else version(Android) {
68             Log.w("showInFileManager is not implemented for current platform");
69         } else static if (isFreedesktop) {
70             import std.stdio : File;
71             import std.algorithm : map, filter, splitter, canFind, equal, findSplit;
72             import std.exception : collectException, assumeUnique;
73             import std.path : buildPath, absolutePath, isAbsolute, dirName, baseName;
74             import std.range;
75             import std.string : toStringz;
76             import std.typecons : Tuple, tuple;
77             static import std.stdio;
78             import inilike.common;
79             import inilike.range;
80             import xdgpaths;
81 
82             string toOpen = pathName;
83 
84             static string unescapeQuotedArgument(string value) nothrow pure
85             {
86                 static immutable Tuple!(char, char)[] pairs = [
87                     tuple('`', '`'),
88                     tuple('$', '$'),
89                     tuple('"', '"'),
90                     tuple('\\', '\\')
91                 ];
92                 return doUnescape(value, pairs);
93             }
94 
95             static auto unquoteExec(string unescapedValue) pure
96             {
97                 auto value = unescapedValue;
98                 string[] result;
99                 size_t i;
100 
101                 static string parseQuotedPart(ref size_t i, char delimeter, string value)
102                 {
103                     size_t start = ++i;
104                     bool inQuotes = true;
105 
106                     while(i < value.length && inQuotes) {
107                         if (value[i] == '\\' && value.length > i+1 && value[i+1] == '\\') {
108                             i+=2;
109                             continue;
110                         }
111 
112                         inQuotes = !(value[i] == delimeter && (value[i-1] != '\\' || (i>=2 && value[i-1] == '\\' && value[i-2] == '\\') ));
113                         if (inQuotes) {
114                             i++;
115                         }
116                     }
117                     if (inQuotes) {
118                         throw new Exception("Missing pair quote");
119                     }
120                     return unescapeQuotedArgument(value[start..i]);
121                 }
122 
123                 char[] append;
124                 bool wasInQuotes;
125                 while(i < value.length) {
126                     if (value[i] == ' ' || value[i] == '\t') {
127                         if (!wasInQuotes && append.length >= 1 && append[$-1] == '\\') {
128                             append[$-1] = value[i];
129                         } else {
130                             if (append !is null) {
131                                 result ~= append.assumeUnique;
132                                 append = null;
133                             }
134                         }
135                         wasInQuotes = false;
136                     } else if (value[i] == '"' || value[i] == '\'') {
137                         append ~= parseQuotedPart(i, value[i], value);
138                         wasInQuotes = true;
139                     } else {
140                         append ~= value[i];
141                         wasInQuotes = false;
142                     }
143                     i++;
144                 }
145 
146                 if (append !is null) {
147                     result ~= append.assumeUnique;
148                 }
149 
150                 return result;
151             }
152 
153             static string urlToFilePath(string url) nothrow pure
154             {
155                 enum protocol = "file://";
156                 if (url.length > protocol.length && url[0..protocol.length] == protocol) {
157                     return url[protocol.length..$];
158                 } else {
159                     return url;
160                 }
161             }
162 
163             static string[] expandExecArgs(in string[] unquotedArgs, in string[] urls = null, string iconName = null, string displayName = null, string fileName = null) pure
164             {
165                 string[] toReturn;
166                 foreach(token; unquotedArgs) {
167                     if (token == "%F") {
168                         toReturn ~= urls.map!(url => urlToFilePath(url)).array;
169                     } else if (token == "%U") {
170                         toReturn ~= urls;
171                     } else if (token == "%i") {
172                         if (iconName.length) {
173                             toReturn ~= "--icon";
174                             toReturn ~= iconName;
175                         }
176                     } else {
177                         static void expand(string token, ref string expanded, ref size_t restPos, ref size_t i, string insert)
178                         {
179                             if (token.length == 2) {
180                                 expanded = insert;
181                             } else {
182                                 expanded ~= token[restPos..i] ~ insert;
183                             }
184                             restPos = i+2;
185                             i++;
186                         }
187 
188                         string expanded;
189                         size_t restPos = 0;
190                         bool ignore;
191                         loop: for(size_t i=0; i<token.length; ++i) {
192                             if (token[i] == '%' && i<token.length-1) {
193                                 switch(token[i+1]) {
194                                     case 'f': case 'u':
195                                     {
196                                         if (urls.length) {
197                                             string arg = urls.front;
198                                             if (token[i+1] == 'f') {
199                                                 arg = urlToFilePath(arg);
200                                             }
201                                             expand(token, expanded, restPos, i, arg);
202                                         } else {
203                                             ignore = true;
204                                             break loop;
205                                         }
206                                     }
207                                     break;
208                                     case 'c':
209                                     {
210                                         expand(token, expanded, restPos, i, displayName);
211                                     }
212                                     break;
213                                     case 'k':
214                                     {
215                                         expand(token, expanded, restPos, i, fileName);
216                                     }
217                                     break;
218                                     case 'd': case 'D': case 'n': case 'N': case 'm': case 'v':
219                                     {
220                                         ignore = true;
221                                         break loop;
222                                     }
223                                     case '%':
224                                     {
225                                         expand(token, expanded, restPos, i, "%");
226                                     }
227                                     break;
228                                     default:
229                                     {
230                                         throw new Exception("Unknown or misplaced field code: " ~ token);
231                                     }
232                                 }
233                             }
234                         }
235 
236                         if (!ignore) {
237                             toReturn ~= expanded ~ token[restPos..$];
238                         }
239                     }
240                 }
241 
242                 return toReturn;
243             }
244 
245             static bool isExecutable(string program) nothrow
246             {
247                 import core.sys.posix.unistd;
248                 return access(program.toStringz, X_OK) == 0;
249             }
250 
251             static string findExecutable(string program, const(string)[] binPaths) nothrow
252             {
253                 if (program.isAbsolute && isExecutable(program)) {
254                     return program;
255                 } else if (program.baseName == program) {
256                     foreach(path; binPaths) {
257                         auto candidate = buildPath(path, program);
258                         if (isExecutable(candidate)) {
259                             return candidate;
260                         }
261                     }
262                 }
263                 return null;
264             }
265 
266             static void parseConfigFile(string fileName, string wantedGroup, bool delegate (string, string) onKeyValue)
267             {
268                 auto r = iniLikeFileReader(fileName);
269                 foreach(group; r.byGroup())
270                 {
271                     if (group.groupName == wantedGroup)
272                     {
273                         foreach(entry; group.byEntry())
274                         {
275                             if (entry.length && !isComment(entry)) {
276                                 auto pair = parseKeyValue(entry);
277                                 if (!isValidKey(pair.key)) {
278                                     return;
279                                 }
280                                 if (!onKeyValue(pair.key, pair.value.unescapeValue)) {
281                                     return;
282                                 }
283                             }
284                         }
285                         return;
286                     }
287                 }
288             }
289 
290             static string[] findFileManagerCommand(string app, const(string)[] appDirs, const(string)[] binPaths) nothrow
291             {
292                 foreach(appDir; appDirs) {
293                     bool fileExists;
294                     auto appPath = buildPath(appDir, app);
295                     collectException(appPath.isFile, fileExists);
296                     if (!fileExists) {
297                         //check if file in subdirectory exist. E.g. kde4-dolphin.desktop refers to kde4/dolphin.desktop
298                         auto appSplitted = findSplit(app, "-");
299                         if (appSplitted[1].length && appSplitted[2].length) {
300                             appPath = buildPath(appDir, appSplitted[0], appSplitted[2]);
301                             collectException(appPath.isFile, fileExists);
302                         }
303                     }
304 
305                     if (fileExists) {
306                         try {
307                             bool canOpenDirectory; //not used for now. Some file managers does not have MimeType in their .desktop file.
308                             string exec, tryExec, icon, displayName;
309 
310                             parseConfigFile(appPath, "Desktop Entry", delegate bool(string key, string value) {
311                                 if (key.equal("MimeType")) {
312                                     canOpenDirectory = value.splitter(';').canFind("inode/directory");
313                                 } else if (key.equal("Exec")) {
314                                     exec = value;
315                                 } else if (key.equal("TryExec")) {
316                                     tryExec = value;
317                                 } else if (key.equal("Icon")) {
318                                     icon = value;
319                                 } else if (key.equal("Name")) {
320                                     displayName = value;
321                                 }
322                                 return true;
323                             });
324 
325                             if (exec.length) {
326                                 if (tryExec.length) {
327                                     auto program = findExecutable(tryExec, binPaths);
328                                     if (!program.length) {
329                                         continue;
330                                     }
331                                 }
332                                 return expandExecArgs(unquoteExec(exec), null, icon, displayName, appPath);
333                             }
334 
335                         } catch(Exception e) {
336 
337                         }
338                     }
339                 }
340 
341                 return null;
342             }
343 
344             static void execShowInFileManager(string[] fileManagerArgs, string toOpen)
345             {
346                 toOpen = toOpen.absolutePath();
347                 switch(fileManagerArgs[0].baseName) {
348                     //nautilus and nemo select item if it's a file
349                     case "nautilus":
350                     case "nemo":
351                         fileManagerArgs ~= toOpen;
352                         break;
353                     //dolphin needs --select option
354                     case "dolphin":
355                     case "konqueror":
356                         fileManagerArgs ~= ["--select", toOpen];
357                         break;
358                     default:
359                     {
360                         bool pathIsDir;
361                         collectException(toOpen.isDir, pathIsDir);
362                         if (!pathIsDir) {
363                             fileManagerArgs ~= toOpen.dirName;
364                         } else {
365                             fileManagerArgs ~= toOpen;
366                         }
367                     }
368                         break;
369                 }
370 
371                 File inFile, outFile, errFile;
372                 try {
373                     inFile = File("/dev/null", "rb");
374                 } catch(Exception) {
375                     inFile = std.stdio.stdin;
376                 }
377                 try {
378                     auto nullFile = File("/dev/null", "wb");
379                     outFile = nullFile;
380                     errFile = nullFile;
381                 } catch(Exception) {
382                     outFile = std.stdio.stdout;
383                     errFile = std.stdio.stderr;
384                 }
385 
386                 auto processConfig = Config.none;
387                 static if (is(typeof(Config.detached)))
388                 {
389                     processConfig |= Config.detached;
390                 }
391                 spawnProcess(fileManagerArgs, inFile, outFile, errFile, null, processConfig);
392             }
393 
394             string configHome = xdgConfigHome();
395             string appHome = xdgDataHome("applications");
396 
397             auto configDirs = xdgConfigDirs();
398             auto appDirs = xdgDataDirs("applications");
399 
400             auto allAppDirs = xdgAllDataDirs("applications");
401             auto binPaths = environment.get("PATH").splitter(':').filter!(p => p.length > 0).array;
402 
403             string[] fileManagerArgs;
404             foreach(mimeappsList; chain(only(configHome), only(appHome), configDirs, appDirs).map!(p => buildPath(p, "mimeapps.list"))) {
405                 try {
406                     parseConfigFile(mimeappsList, "Default Applications", delegate bool(string key, string value) {
407                         if (key.equal("inode/directory") && value.length) {
408                             auto app = value;
409                             fileManagerArgs = findFileManagerCommand(app, allAppDirs, binPaths);
410                             return false;
411                         }
412                         return true;
413                     });
414                 } catch(Exception e) {
415 
416                 }
417 
418                 if (fileManagerArgs.length) {
419                     execShowInFileManager(fileManagerArgs, toOpen);
420                     return true;
421                 }
422             }
423 
424             foreach(mimeinfoCache; allAppDirs.map!(p => buildPath(p, "mimeinfo.cache"))) {
425                 try {
426                     parseConfigFile(mimeinfoCache, "MIME Cache", delegate bool(string key, string value) {
427                         if (key > "inode/directory") { //no need to proceed, since MIME types are sorted in alphabetical order.
428                             return false;
429                         }
430                         if (key.equal("inode/directory") && value.length) {
431                             auto alternatives = value.splitter(';').filter!(p => p.length > 0);
432                             foreach(alternative; alternatives) {
433                                 fileManagerArgs = findFileManagerCommand(alternative, allAppDirs, binPaths);
434                                 if (fileManagerArgs.length) {
435                                     break;
436                                 }
437                             }
438                             return false;
439                         }
440                         return true;
441                     });
442                 } catch(Exception e) {
443 
444                 }
445 
446                 if (fileManagerArgs.length) {
447                     execShowInFileManager(fileManagerArgs, toOpen);
448                     return true;
449                 }
450             }
451 
452             Log.e("showInFileManager -- could not find application to open directory");
453             return false;
454         } else {
455             Log.w("showInFileManager is not implemented for current platform");
456         }
457     } catch (Exception e) {
458         Log.e("showInFileManager -- exception while trying to open file browser");
459     }
460     return false;
461 }