82a7abd1c2f55aa05233e6f6fee509cbc7a6275f
[ede] / libede / src / FileSystemBox.ec
1 public import "ecere"
2 import "FileSystemCache"
3
4 #ifdef __WIN32__
5 static char * rootName = "Entire Computer";
6 static char * msNetwork = "Microsoft Windows Network";
7 #else
8 static char * rootName = "File System";
9 #endif
10
11 private:
12 define guiApp = (GuiApplication)((__thisModule).application);
13 define selectionColor = guiApp.currentSkin.selectionColor; //Color { 10, 36, 106 };
14
15 void MessageBoxTodo(char * message)
16 {
17    PrintLn("MessageBoxTodo(char * message) -- ", message);
18    MessageBox { type = ok, text = "MessageBoxTodo(char * message)", contents = message }.Modal();
19 }
20
21 static char * fileIconNames[] =
22 {
23    "<:ecere>mimeTypes/file.png",         /* none */
24
25    "<:ecere>mimeTypes/file.png",         /* normalFile */
26    "<:ecere>mimeTypes/textEcereWorkspace.png",          /* ewsFile */
27    "<:ecere>mimeTypes/textEcereProject.png",      /* epjFile */
28    "<:ecere>mimeTypes/textEcereSource.png",         /* ecFile */
29    "<:ecere>mimeTypes/textEcereHeader.png",         /* ehFile */
30    "<:ecere>mimeTypes/textCSource.png",          /* cFile */
31    "<:ecere>mimeTypes/textCHeader.png",          /* hFile */
32    "<:ecere>mimeTypes/textC++Source.png",        /* cppFile */
33    "<:ecere>mimeTypes/textC++Header.png",        /* hppFile */
34    "<:ecere>mimeTypes/text.png",         /* textFile */
35    "<:ecere>mimeTypes/textHyperTextMarkup.png",              /* webFile */
36    "<:ecere>mimeTypes/image.png",        /* pictureFile */
37    "<:ecere>status/audioVolumeHigh.png",         /* soundFile */
38    "<:ecere>mimeTypes/package.png",      /* archiveFile */
39    "<:ecere>mimeTypes/packageSoftware.png",     /* packageFile */
40    "<:ecere>mimeTypes/packageOpticalDisc.png", /* opticalMediaImageFile */
41
42    "<:ecere>places/folder.png",                    /* folder */
43    "<:ecere>status/folderOpen.png",               /* folderOpen */
44    "<:ecere>devices/computer.png",                 /* computer */
45    "<:ecere>devices/driveHardDisk.png",           /* drive */
46    "<:ecere>places/driveRemote.png",              /* netDrive */
47    "<:ecere>devices/mediaOptical.png",            /* cdrom */
48    "<:ecere>devices/driveRemovableMedia.png",    /* removable */
49    "<:ecere>devices/mediaFloppy.png",             /* floppy */
50    "<:ecere>places/networkWorkgroup.png",         /* network */
51    "<:ecere>places/networkServer.png",            /* server */
52    "<:ecere>places/folderRemote.png",             /* share */
53
54    "<:ecere>mimeTypes/package.png",      /* treeLoader */
55    "<:ecere>places/startHere.png",                /* lineNumbers */
56
57    ""
58 };
59
60 define countOfCompIconNames = 6;
61 static char * compIconNames[] =
62 {
63 /*
64    "<:ede>a.png",
65    "<:ede>b.png",
66    "<:ede>c.png",
67    "<:ede>d.png",
68    "<:ede>not.png",
69 */
70    "<:ede>devices/media-optical.png",
71    "<:ede>devices/media-flash.png",
72    "<:ede>places/network-server.png",
73    "<:ede>places/folder-saved-search.png",
74    "<:ede>places/user-home.png",
75    "<:ede>emblem-not.png",
76    ""
77 };
78
79 public enum _FileType
80 {
81    none,
82
83    normalFile, ewsFile, epjFile, ecFile, ehFile, cFile, hFile, cppFile, hppFile,
84    textFile, webFile, pictureFile, soundFile,
85    archiveFile, packageFile, opticalMediaImageFile, /* these (all previous) are sort equal */
86
87    folder, folderOpen, computer,
88    drive, netDrive, cdrom, removable, floppy, network, server, share, // these are sort equal
89
90    // utilities
91    treeLoader,
92    lineNumbers;
93
94    /*property char *
95    {
96       set
97       {
98          this = SelectByExtension(value);
99       }
100    }*/
101
102    public property bool isFolder
103    {
104       get { return this >= folder && this <= share; }
105    }
106
107    public property bool isFile
108    {
109       get { return this >= normalFile && this <= opticalMediaImageFile; }
110    }
111
112    _FileType ::SelectByExtension(char * extension)
113    {
114       if(!strcmpi(extension, "ews"))
115          return ewsFile;
116       else if(!strcmpi(extension, "epj"))
117          return epjFile;
118       else if(!strcmpi(extension, "ec"))
119          return ecFile;
120       else if(!strcmpi(extension, "eh"))
121          return ehFile;
122       else if(!strcmpi(extension, "cpp") ||
123             !strcmpi(extension, "cc") || !strcmpi(extension, "cxx"))
124          return cppFile;
125       else if(!strcmpi(extension, "hpp") ||
126             !strcmpi(extension, "hh") || !strcmpi(extension, "hxx"))
127          return hppFile;
128       else if(!strcmpi(extension, "c"))
129          return cFile;
130       else if(!strcmpi(extension, "h"))
131          return hFile;
132       else if(!strcmpi(extension, "txt") || !strcmpi(extension, "text") ||
133             !strcmpi(extension, "nfo") || !strcmpi(extension, "info"))
134          return textFile;
135       else if(!strcmpi(extension, "htm") || !strcmpi(extension, "html") ||
136             !strcmpi(extension, "css") || !strcmpi(extension, "php") ||
137             !strcmpi(extension, "js"))
138          return webFile;
139       else if(!strcmpi(extension, "bmp") || !strcmpi(extension, "pcx") ||
140             !strcmpi(extension, "jpg") || !strcmpi(extension, "jpeg") ||
141             !strcmpi(extension, "gif") || !strcmpi(extension, "png") ||
142             !strcmpi(extension, "ico"))
143          return pictureFile;
144       else if(!strcmpi(extension, "wav") || !strcmpi(extension, "mp3") ||
145             !strcmpi(extension, "ogg") || !strcmpi(extension, "snd"))
146          return soundFile;
147       else if(!strcmpi(extension, "ear") || !strcmpi(extension, "7z") ||
148             !strcmpi(extension, "rar") || !strcmpi(extension, "zip") ||
149             !strcmpi(extension, "gz") || !strcmpi(extension, "bz2") ||
150             !strcmpi(extension, "tar") || !strcmpi(extension, "arj") ||
151             !strcmpi(extension, "lza") || !strcmpi(extension, "lzh") ||
152             !strcmpi(extension, "cpio") || !strcmpi(extension, "z"))
153          return archiveFile;
154       else if(!strcmpi(extension, "cab") || !strcmpi(extension, "deb") ||
155             !strcmpi(extension, "rpm"))
156          return packageFile;
157       else if(!strcmpi(extension, "iso") || !strcmpi(extension, "mds") ||
158             !strcmpi(extension, "cue") || !strcmpi(extension, "bin") ||
159             !strcmpi(extension, "ccd") || !strcmpi(extension, "bwt") ||
160             !strcmpi(extension, "cdi") || !strcmpi(extension, "nrg"))
161          return opticalMediaImageFile;
162       return normalFile;
163    }
164 };
165
166 public enum FileSystemBoxMode { directory, list };
167
168 class FileSystemBoxBits
169 {
170    bool foldersOnly:1, filesOnly:1, details:1, pathColumn:1, treeBranches:1, previewPictures:1, navigateFolders:1, autoLoad:1;
171    bool preview:1;
172    bool columnsCompareStyle:1;
173    //bool header:1, freeSelect:1, fullRowSelect:1, multiSelect:1, autoScroll:1, alwaysHL : 1, moveRows:1, resizable:1;
174    //bool moveFields:1, clearHeader:1, alwaysEdit:1, collapse:1, treeBranch:1, rootCollapse:1, heightSet:1;
175    //bool sortable:1, noDragging:1, fillLastField:1, expandOnAdd:1;
176    bool textFileLinesStyle:1;
177
178    FileSystemBoxMode mode:2;
179 }
180
181 public class FileSystemBox : Window // should we not derive from ListBox instead?
182                                     // I say we should, but we can't right now...
183                                     // because ListBox (inside ecere library) is
184                                     // not exposing enough internal machinery...
185                                     // could we not have a different private and
186                                     // public mechanism when deriving a class than
187                                     // we do when simply instanciating a class?
188 /*
189    this stuff from the listbox would be nicely exposed...
190       fullRowSelect = false;
191       treeBranches = true;
192       collapseControl = true;
193       rootCollapseButton = true;
194       sortable = true;
195 */
196 {
197    borderStyle = deep;
198    hasHorzScroll = false;
199    hasVertScroll = false;
200
201    menu = Menu { };
202
203 public:
204    FileSystemNode root;
205    FileSystemBoxSelection selection { };
206
207    subclass(InterfaceFileSystemIterator) iteratorClass;
208    FileSystemCache cache;
209
210    virtual bool Window::NotifyNodeSelect(FileSystemBox box, FileSystemBoxSelection selection);
211    //virtual bool Window::NotifyNodeNavigate(FileSystemBox box, FileSystemNode node);
212    virtual bool Window::NotifyNodeOpen(FileSystemBox box, FileSystemBoxSelection selection);
213    virtual bool Window::NotifyNodeMenu(FileSystemBox box, Menu menu, FileSystemBoxSelection selection);
214    virtual bool Window::NotifyIteratorInit(FileSystemBox box, FileSystemIterator fileSystemIterator);
215
216    property char * path
217    {
218       set
219       {
220          delete path;
221          if(value && value[0])
222             path = CopyString(value);
223          if(locationBox)
224             locationBox.path = value;
225          if(created)
226             Load();
227       }
228       get { return path; }
229       //isset { return path && path[0]; }
230    }
231
232    property Array<String> comparedPaths
233    {
234       set
235       {
236          delete comparedPaths;
237          if(value && value.count)
238             comparedPaths = value;
239          if(locationBox)
240             locationBox.path = value[0];
241          if(created)
242             Load();
243       }
244       get { return comparedPaths; }
245       //isset { return comparedPaths && comparedPaths.count; }
246    }
247
248    property FileSystemBoxMode mode { set { bits.mode = value; } get { return bits.mode; } };
249    property bool foldersOnly { set { bits.foldersOnly = value; bits.filesOnly = !value; } get { return bits.foldersOnly; } };
250    property bool filesOnly { set { bits.filesOnly = value; bits.foldersOnly = !value; } get { return bits.filesOnly; } };
251    property bool previewPictures { set { bits.previewPictures = value; } get { return bits.previewPictures; } };
252    property char * extensions { set { delete extensions; if(value && value[0]) extensions = CopyString(value); } get { return extensions; } }
253    property bool details { set { bits.details = value; ChangeViewType(); } get { return bits.details; } };
254    property bool pathColumn { set { bits.pathColumn = value; ChangeViewType(); } get { return bits.pathColumn; } };
255    property bool treeBranches
256    {
257       set
258       {
259          bits.treeBranches = value;
260          list.treeBranches = value;
261          list.collapseControl = value;
262          list.rootCollapseButton = value;
263       }
264       get { return bits.treeBranches; }
265    };
266    property Color selectionColor { set { list.selectionColor = value; } get { return list.selectionColor; }/* isset { return selectionColor ? true : false; }*/ };
267    property Color selectionText  { set { list.selectionText = value; } get { return list.selectionText; }/* isset { return selectionText ? true : false; }*/ };
268    property bool navigateFolders { set { bits.navigateFolders = value; bits.filesOnly = !value; } get { return bits.navigateFolders; } };
269    property bool multiSelect { set { list.multiSelect = value; } get { return list.multiSelect; } };
270    property bool autoLoad { set { bits.autoLoad = value; } get { return bits.autoLoad; } };
271    property bool hasHeader { set { list.hasHeader = value; } get { return list.hasHeader; } };
272    property bool preview
273    {
274       set
275       {
276          bits.preview = value;
277          split.leftPane = value ? list : null;
278          split.visible = value;
279          show.visible = value;
280       }
281       get { return bits.preview; }
282    };
283    property bool columnsCompareStyle { set { bits.columnsCompareStyle = value; } get { return bits.columnsCompareStyle; } };
284    property bool textFileLinesStyle { set { bits.textFileLinesStyle = value; } get { return bits.textFileLinesStyle; } };
285
286    property FileSystemNode node
287    {
288       get
289       {
290          if(!list)
291             return null;
292          if(!list.currentRow)
293             return null;
294          if(!list.currentRow.tag)
295             return null;
296          return (FileSystemNode)list.currentRow.tag;
297       }
298    }
299
300    PathBox locationBox;
301
302    void Select(FileSystemNode node)
303    {
304       if(node.row)
305       {
306          node.EnsureVisible(false);
307          list.SelectRow(node.row);
308       }
309    }
310
311    void SelectMultipleByPath(Array<String> paths)
312    {
313       DataRow row;
314       bool firstRow = false;
315       Map<String, bool> map { };
316       for(path : paths)
317          map[path] = true;
318       for(row = list.firstRow; row; row = row.next)
319       {
320          FileSystemNode node = (FileSystemNode)row.tag;
321          if(map[node.path])
322          {
323             if(!firstRow)
324             {
325                list.SelectRow(row);
326                firstRow = true;
327             }
328             else
329                row.selected = true;
330          }
331          else
332             row.selected = false;
333       }
334       delete map;
335    }
336
337    FileSystemNode SelectLocation(char * location)
338    {
339       int c;
340       char * temp;
341       char step[MAX_LOCATION];
342
343       //StringArray steps { growingFactor = 4 };
344       Array<String> steps { };
345       FileSystemNode result = null;
346       FileSystemNode node = null;
347
348       temp = CopyString(location);
349       while(temp[0])
350       {
351          GetLastDirectory(temp, step);
352          StripLastDirectory(temp, temp);
353          steps.Add(CopyString(step));
354       }
355
356       for(c = steps.count - 1; c >= 0; c--)
357       {
358          char * t = steps[c];
359          node = Find(steps[c], node);
360          if(!node)
361             break;
362          //Select(node);
363       }
364       if(node)
365       {
366          result = node;
367          Select(result);
368       }
369
370       steps.Free();
371       delete temp;
372       delete steps;
373
374       return result;
375    }
376
377    FileSystemNode Find(const char * name, FileSystemNode parent)
378    {
379       FileSystemNode node = null;
380       FileSystemNode result = null;
381       if(!parent/* && !strcmp(name, "/")*/)
382       {
383          DataRow row;
384          for(row = list.firstRow; row; row = row.next)
385          {
386             node = (FileSystemNode)row.tag;
387             if(node.name && !fstrcmp(node.name, name))
388                break;
389          }
390          if(node)
391             result = node;
392          //result = root;
393       }
394       else
395       {
396          FileSystemNode start = parent ? parent : root;
397          if(!start.bits.loaded || !start.bits.childrenLoaded)
398             LoadTreeNode(start);
399          for(node = start.children.first; node; node = node.next)
400             if(node.name && !fstrcmp(node.name, name))
401                break;
402          if(node)
403             result = node;
404       }
405       return result;
406    }
407
408    void Clear()
409    {
410       list.Clear();
411    }
412
413    void Refresh()
414    {
415       Load();
416    }
417
418    bool MenuOpen(MenuItem selection, Modifiers mods)
419    {
420       OpenNode();
421    }
422
423    bool MenuReplaceListItemByContainingDir(MenuItem selection, Modifiers mods)
424    {
425       bool result = true;
426       //FileSystemBoxSelection selection = this.selection.Copy(); // TOFIX compiler bug -- FileSystemBox.c -- ../libede/src/FileSystemBox.ec:420:49: error: ‘selection’ redeclared as different kind of symbol        
427       FileSystemBoxSelection sel = this.selection.Copy();
428       FileSystemNode node = sel.node;
429       char newPath[MAX_LOCATION];
430       StripLastDirectory(node.path, newPath);
431       //node.path = newPath;
432       //node.
433       //if(node && node.type.isFolder && bits.navigateFolders)
434       //   property::path = node.path;
435       delete sel;
436       return result;
437    }
438
439    bool MenuReplaceListItemByChild(MenuItem selection, Modifiers mods)
440    {
441       bool result = true;
442       //FileSystemBoxSelection selection = this.selection.Copy(); // TOFIX compiler bug -- FileSystemBox.c -- ../libede/src/FileSystemBox.ec:420:49: error: ‘selection’ redeclared as different kind of symbol        
443       FileSystemBoxSelection sel = this.selection.Copy();
444       FileSystemNode node = sel.node;
445       char newPath[MAX_LOCATION];
446       StripLastDirectory(node.path, newPath);
447       //node.path = newPath;
448       //node.
449       //if(node && node.type.isFolder && bits.navigateFolders)
450       //   property::path = node.path;
451       delete sel;
452       return result;
453    }
454
455 private:
456    FileSystemBoxBits bits;
457
458    char * path;
459    char * extensions;
460    Array<String> comparedPaths;
461
462    BitmapResource fileIcons[_FileType];
463    BitmapResource compIcons[countOfCompIconNames]; // todo: fix this limitation
464
465    Bitmap bitmap;
466    //BitmapArray bitmaps { growingFactor = 16 };
467
468    FileSystemBox()
469    {
470       char wd[MAX_LOCATION];
471       GetWorkingDir(wd, sizeof(wd));
472       property::path = wd;
473
474       InitFileIcons();
475       InitCompIcons(); // todo: these icons should not be initialize, they should be set
476                        //       or at least initalized when the comparison listing is requested
477                        //       and we know how many paths are being compared.
478       list.AddField(nameField);
479       bits.autoLoad = true;
480       //iteratorClass = class(FileSystemIterator);
481    }
482
483    ~FileSystemBox()
484    {
485       delete extensions;
486       delete path;
487    }
488
489    watch(background)
490    {
491       list.background = background;
492    };
493
494    void InitFileIcons()
495    {
496       _FileType c;
497       for(c = 0; c < _FileType::enumSize; c++)
498       {
499          fileIcons[c] = BitmapResource { fileIconNames[c], alphaBlend = true };
500          AddResource(fileIcons[c]);
501       }
502    }
503
504    void InitCompIcons()
505    {
506       _FileType c;
507       for(c = 0; c < countOfCompIconNames; c++)
508       {
509          compIcons[c] = BitmapResource { compIconNames[c], alphaBlend = true };
510          AddResource(compIcons[c]);
511       }
512    }
513
514    DataField nameField { header = "Name", dataType = "FileSystemNode", width = 240, userData = this, freeData = false/*, editable = true*/; };
515    DataField pathField { header = "Location", dataType = /*"String"*/ "char *", width = 300, freeData = true };
516    DataField typeField { header = "Type", dataType = /*"String"*/ "char *", width = 40, freeData = false };
517    DataField sizeField { header = "Size", dataType = "FileSize", width = 96, alignment = right, freeData = false };
518    DataField modifiedField { header = "Modified", dataType = "SecSince1970", width = 96, alignment = right, freeData = false };
519
520    bool OnPostCreate()
521    {
522       if(bits.autoLoad)
523       {
524          if(!path)
525          {
526             char wd[MAX_LOCATION];
527             GetWorkingDir(wd, sizeof(wd));
528             property::path = wd;
529          }
530          Load();
531       }
532       return true;
533    }
534
535    ListBox list
536    {
537       this;
538
539       borderStyle = none;
540       hasHorzScroll = true;
541       hasVertScroll = true;
542       fullRowSelect = false;
543       sortable = true;
544       alwaysHighLight = true;
545
546       anchor = Anchor { left = 0, top = 0, right = 0, bottom = 0 };
547
548       // WHY is this not working ?
549       /*void OnResize(int width, int height)
550       {
551          if(vertScroll.visible)
552             nameField.width = width - vertScroll.size.w;
553          else
554             nameField.width = width;
555       }*/
556
557       bool NotifyCollapse(ListBox listBox, DataRow row, bool collapsed)
558       {
559          if(row)
560          {
561             FileSystemNode node = (FileSystemNode)row.tag;
562             FileSystemNode child;
563             if(collapsed)
564             {
565                /*
566                for(child = node.children.last; child; child = node.children.last)
567                {
568                   listBox.DeleteRow(child.row);
569                   child.Free();
570                   delete child;
571                }
572                node.childrenLoaded = false;
573                */
574             }
575             else
576             {
577                if(!node.bits.loaded || !node.bits.childrenLoaded)
578                {
579                   LoadTreeNode(node);
580                   //list.Sort(nameField, 1);
581                   //node.
582                }
583                for(child = node.children.first; child && child.next; child = child.next);
584                if(child)
585                   child.EnsureVisible(false);
586             }
587          }
588          return true;
589       }
590
591       bool NotifyRightClick(ListBox listBox, int x, int y, Modifiers mods)
592       {
593          DataRow row = listBox.currentRow;
594          if(row)
595          {
596             FileSystemNode node = (FileSystemNode)row.tag;
597             if(node)
598             {
599                PopupMenu popup;
600                Menu menu { };
601
602                if(NotifyNodeMenu)
603                   NotifyNodeMenu(master, this, menu, selection);
604                else
605                {
606                   char * text;
607
608                   text = PrintString("Open ", node.name);
609                   MenuItem { menu, text, o, NotifySelect = MenuOpen, disabled = false }; //delete text;
610
611                   if(node.bits.isListItem/* && TODO: unless node is at root location*/)
612                   {
613                      MenuDivider { menu };
614                      MenuItem { menu, "Replace by Parent\tCtrl+R", r, NotifySelect = MenuReplaceListItemByContainingDir, disabled = false };
615                   }
616                   else if(bits.mode == list)
617                   {
618                      MenuDivider { menu };
619                      MenuItem { menu, "Replace List Item\tCtrl+R", r, NotifySelect = MenuReplaceListItemByChild, disabled = false };
620                   }
621                   MenuDivider { menu };
622                   MenuItem { menu, "Cut\tCtrl+X", t, NotifySelect = null, disabled = false };
623                   MenuItem { menu, "Copy\tCtrl+C", c, NotifySelect = null, disabled = false };
624                   MenuItem { menu, "Paste\tCtrl+V", p, NotifySelect = null, disabled = false /*!clipboard*/ };
625                   MenuItem { menu, "Delete\tDel", d, NotifySelect = null, disabled = false };
626                   //MenuDivider { menu };
627                }
628
629                popup = PopupMenu
630                   {
631                      master = this, menu = menu,
632                      position = {
633                         x + clientStart.x + absPosition.x - guiApp.desktop.position.x,
634                         y + clientStart.y + absPosition.y - guiApp.desktop.position.y }
635                   };
636                popup.Create();
637             }
638          }
639          return true;
640       }
641
642       bool NotifySelect(ListBox listBox, DataRow row, Modifiers mods)
643       {
644          OldList rows;
645          OldLink item;
646
647          selection.nodes.Free();
648          list.GetMultiSelection(rows);
649          for(item = rows.first; item; item = item.next)
650          {
651             DataRow row = item.data;
652             FileSystemNode node = (FileSystemNode)row.tag;
653             selection.nodes.Add(node);
654             incref node;
655          }
656          rows.Free(null);
657          if(row)
658             selection.node = (FileSystemNode)row.tag;
659          else
660             selection.node = null;
661
662          if(selection.node && bits.preview)
663          {
664             //int pos;
665             FileSystemNode node = selection.node;
666             /*if(bitmap)
667                bitmap.Free();*/
668             delete bitmap;
669             if(node && node.type == pictureFile)
670             {
671                bitmap = Bitmap { };
672                bitmap.Load(node.path, null, displaySystem);
673             }
674
675             /*bitmaps.Clear();
676             bitmaps = BitmapArray { };
677             for(pos = 0; pos < selectedItems.count; pos++)
678             {
679                Bitmap bitmap { };
680                selItem = (ExplorerFileItem)selectedItems._[pos];
681                bitmap.Load(selItem.path, null, displaySystem);
682                //bitmaps.Add(bitmap);
683             }
684             if(node && node.type == pictureFile)
685             {
686                bitmap = Bitmap { };
687                bitmap.Load(node.path, null, displaySystem);
688             }*/
689
690             show.Update(null);
691             //NotifyItemSelect(master, view, item, selectedItems);
692          }
693
694          NotifyNodeSelect(listBox.parent.master, this, selection);
695          return true;
696       }
697
698       bool NotifyEditing(ListBox listBox, DataRow row)
699       {
700          if(row)
701          {
702             FileSystemNode node = (FileSystemNode)row.tag;
703          }
704          return true;
705       }
706
707       bool NotifyEdited(ListBox listBox, DataRow row)
708       {
709          if(row)
710          {
711             FileSystemNode node = (FileSystemNode)row.tag;
712          }
713          return true;
714       }
715
716       bool NotifyEditDone(ListBox listBox, DataRow row)
717       {
718          if(row)
719          {
720             FileSystemNode node = (FileSystemNode)row.tag;
721          }
722          return true;
723       }
724
725       bool NotifyDoubleClick(ListBox listBox, int x, int y, Modifiers mods)
726       {
727          bool result = !(selection.node && selection.node.type.isFolder && bits.navigateFolders);
728          OpenNode();
729          return result;
730       }
731
732       bool NotifyKeyDown(ListBox listBox, DataRow row, Key key, unichar ch)
733       {
734          bool result;
735          if((SmartKey)key == enter)
736             result = OpenNode();
737          #if 0
738          else if((SmartKey)key == f2)
739             result = RenameNode();
740          #endif
741          else if((SmartKey)key == f2)
742          {
743             FileSystemNode node = selection.node;
744             node.row.Edit(nameField);
745          }
746          else
747             result = true;
748          return true;
749       }
750    };
751
752    PaneSplitter split
753    {
754       this;
755       //leftPane = list;
756       rightPane = show;
757       //split = 200;
758       scaleSplit = 0.5f;
759       tabCycle = true;
760       visible = false;
761    };
762
763    Window show
764    {
765       this;
766       visible = false;
767       borderStyle = none;
768       anchor = Anchor { top = 0, right = 0, bottom = 0 };
769
770       void OnRedraw(Surface surface)
771       {
772          FileSystemBox fsb = (FileSystemBox)parent;
773          if(fsb.bitmap)
774          {
775             int wBmp = fsb.bitmap.width;
776             int hBmp = fsb.bitmap.height;
777             int wWnd = fsb.show.clientSize.w;
778             int hWnd = fsb.show.clientSize.h;
779
780             int wList = 0;//fsb.list.size.w + fsb.split.size.w;
781
782             float scale = Min((float)(wWnd - 10) / wBmp, (float)(hWnd - 10) / hBmp);
783
784             int wDraw = (int)(wBmp * scale);
785             int hDraw = (int)(hBmp * scale);
786
787       #ifndef __linux__
788             surface.Filter(fsb.bitmap, (wWnd - wDraw) / 2, (hWnd - hDraw) / 2, 0, 0, wDraw, hDraw, wBmp, hBmp);
789       #else
790             // Until Filter / Stretch works with X
791             surface.Blit(fsb.bitmap, (wWnd - wBmp) / 2, (hWnd - hBmp) / 2, 0, 0, wBmp, hBmp);
792       #endif
793          }
794          else
795          {
796             surface.SetForeground(white);
797             surface.Area(0, 0, fsb.clientSize.w - 1, fsb.clientSize.h - 1);
798          }
799       }
800    }
801
802    bool OpenNode()
803    {
804       bool result = false;
805       FileSystemBoxSelection sel = this.selection.Copy();
806       //FileSystemNode node = selection.node;
807       for(node : sel.nodes)
808       {
809          sel.node = node;
810          if(node && node.type.isFolder && bits.navigateFolders)
811             property::path = node.path;
812          if(NotifyNodeOpen(this.master, this, sel) && !result)
813             result = true;
814       }
815       delete sel;
816       return result;
817    }
818
819    #if 0
820    bool RenameNode()
821    {
822       bool result;
823       //FileSystemBoxSelection selection = this.selection.Copy();
824       FileSystemNode node = selection.node;
825       //if(node && node.type.isFolder && bits.navigateFolders)
826       //   property::path = node.path;
827       // ------------------------------------------- working here ---------------------------
828       //node.row.Edit();
829       /*result = NotifyNodeRename(this.master, this, node);
830       if(result)
831       {
832          if(RenameFile(oldn, newn))
833          {
834             node.name = newn;
835          }
836       }*/
837       return result;
838    }
839    #endif
840
841    // Edit Menu
842    Menu editMenu { menu, "Edit", e };
843    MenuItem itemEditCut
844    {
845       editMenu, "Cut\tCtrl+X", t, disabled = true;
846
847       bool NotifySelect(MenuItem selection, Modifiers mods)
848       {
849          //EditCut();
850          return true;
851       }
852    };
853    MenuItem itemEditCopy
854    {
855       editMenu, "Copy\tCtrl+C", c, disabled = true;
856
857       bool NotifySelect(MenuItem selection, Modifiers mods)
858       {
859          //EditCopy();
860          return true;
861       }
862    };
863    MenuItem itemEditPaste
864    {
865       editMenu, "Paste\tCtrl+V", p;
866
867       bool NotifySelect(MenuItem selection, Modifiers mods)
868       {
869          //EditPaste();
870          return true;
871       }
872    };
873    MenuItem itemEditDelete
874    {
875       editMenu, "Delete\tDel", d, disabled = true;
876
877       bool NotifySelect(MenuItem selection, Modifiers mods)
878       {
879          //EditDelete();
880          return true;
881       }
882    };
883
884    // WHY is this crashing ?
885    /*void OnResize(int width, int height)
886    {
887       if(this && nameField)
888          nameField.width = width - 80;
889    }*/
890
891    void ChangeViewType()
892    {
893       list.Clear();
894       list.ClearFields();
895       list.resizable = bits.details || bits.pathColumn;
896       list.moveFields = bits.details || bits.pathColumn;
897       list.hasHeader = bits.details || bits.pathColumn;
898       list.AddField(nameField);
899       if(bits.pathColumn)
900          list.AddField(pathField);
901       if(bits.details)
902       {
903          list.AddField(typeField);
904          list.AddField(sizeField);
905          list.AddField(modifiedField);
906       }
907    }
908
909    void Load()
910    {
911       // TODO: fix this!
912       // this is crashing in for designer when details = true // can't save the file, always yields a crash
913       /*if(list && created)
914       {
915          list.ClearFields();
916          list.AddField(nameField);
917          if(bits.details)
918          {
919             list.AddField(typeField);
920             list.AddField(sizeField);
921          }
922       }*/
923       list.Clear();
924       if(comparedPaths && !bits.treeBranches)
925          LoadComparedList();
926       else
927       {
928          FileAttribs pathAttribs = FileExists(path);
929          if(pathAttribs)
930          {
931             if(pathAttribs.isDirectory)
932             {
933                if(bits.treeBranches)
934                   LoadTreeDirectory();
935                else
936                {
937                   if(iteratorClass)
938                      LoadListIterator();
939                   else
940                      LoadListDirectory();
941                }
942             }
943             else if(pathAttribs.isFile) // we assume this is a file list
944             {
945                File f = FileOpen(path, read);
946                if(f)
947                {
948                   if(bits.treeBranches)
949                      LoadTreeFileList(f);
950                   else
951                      LoadListFileList(f);
952                   delete f;
953                }
954                else
955                   MessageBoxTodo($"unable to open file list");
956             }
957             else
958                MessageBoxTodo($"path is not a directory nor is it a file");
959          }
960          else
961             MessageBoxTodo($"path does not exist");
962       }
963       list.Sort(nameField, 1);
964    }
965
966    void LoadTreeDirectory()
967    {
968       bool isRoot = !strcmp(path, "/");
969       char name[MAX_LOCATION];
970       FileSystemNode parent;
971       FileSystemNode node;
972       FileListing listing { path, extensions = extensions };
973
974       if(!isRoot)
975          GetLastDirectory(path, name);
976       else
977          name[0] = '\0';
978
979       /*if(!path)
980          GetWorkingDir(startPath, sizeof(startPath));
981       else
982          strcpy(path, startPath);*/
983       bits.mode = directory;
984
985       list.Clear();
986
987       delete root;
988 #ifdef __WIN32__
989       if(isRoot)
990       {
991          root = FileSystemNode { bits.loaded = true, bits.childrenLoaded = true };
992          AddTreeNode(root, true, false, false, null);
993          while(listing.Find())
994          {
995             int len = strlen(listing.name);
996             char info[MAX_LOCATION];
997             char name[MAX_LOCATION];
998             if(listing.stats.attribs.isDrive &&
999                   len > 3 && !strncmp(&listing.name[1], ": [", 3))
1000             {
1001                strncpy(name, listing.name, 2);
1002                name[2] = 0;
1003                strncpy(info, &listing.name[4], len - 5);
1004                info[len - 5] = 0;
1005             }
1006             else
1007             {
1008                strcpy(name, listing.name);
1009                info[0] = 0;
1010             }
1011
1012             parent =
1013                   MakeFileSystemNode(
1014                         listing.stats,
1015                         name,
1016                         listing.path,
1017                         false, bits.previewPictures, false,
1018                         displaySystem);
1019             if(info[0])
1020                parent.info = info; //CopyString(info);
1021             parent.bits.loaded = true;
1022             AddTreeNode(
1023                   parent,
1024                   !listing.stats.attribs.isDirectory,
1025                   false,
1026                   listing.stats.attribs.isDirectory,
1027                   root);
1028             if(!listing.stats.attribs.isDirectory)
1029                parent.bits.childrenLoaded = true;
1030          }
1031
1032          node = FileSystemNode { name = msNetwork, type = network };
1033          AddTreeNode(node, false, false, true, null);
1034          node.row.collapsed = true;
1035       }
1036       else
1037 #endif
1038       {
1039          FileStats stats;
1040          FileGetStats(path, stats);
1041          root = MakeFileSystemNode(stats, name, path, false, bits.previewPictures, false, displaySystem);
1042          AddTreeNode(root, false, false, true, null);
1043          LoadTreeNode(root);
1044       }
1045
1046       if(isRoot)
1047       {
1048          root.type = computer;
1049          root.label = rootName;
1050       }
1051
1052       list.Sort(nameField, 1);
1053       list.SelectRow(root.row);
1054    }
1055
1056    void LoadListDirectory()
1057    {
1058       FileListing listing { path, extensions = extensions };
1059
1060       bits.mode = directory;
1061       while(listing.Find())
1062          ProcessListItem(listing.name, listing.path, listing.stats, false);
1063    }
1064
1065    void LoadListFileList(File f)
1066    {
1067       char line[65536];
1068       bits.mode = list;
1069       while(f.GetLine(line, 65536))
1070       {
1071          FileStats stats {};
1072          char name[MAX_FILENAME];
1073          FileGetStats(line, stats);
1074          GetLastDirectory(line, name);
1075          ProcessListItem(name, line, stats, true);
1076       }
1077    }
1078
1079    void LoadTreeFileList(File f)
1080    {
1081       char line[65536];
1082       bits.mode = list;
1083       while(f.GetLine(line, 65536))
1084       {
1085          FileStats stats {};
1086          char name[MAX_FILENAME];
1087          FileSystemNode node;
1088          FileGetStats(line, stats);
1089          GetLastDirectory(line, name);
1090          node = ProcessTreeItem(name, line, stats, node);
1091       }
1092    }
1093
1094    void LoadListIterator()
1095    {
1096       FileSystemIterator iterator = eInstance_New(iteratorClass);
1097       if(iterator)
1098       {
1099          iterator.owner = this;
1100          iterator.OnObject = ListIterator_OnObject;
1101          //iterator.OnLeavingDirectory = ListIterator_OnLeavingDirectory;
1102          NotifyIteratorInit(master, this, iterator);
1103          iterator.Iterate(path, true);
1104          delete iterator;
1105       }
1106    }
1107
1108    bool ListIterator_OnObject(char * name, char * path, FileStats stats, bool isRootObject)
1109    {
1110       ProcessListItem(name, path, stats, false);
1111       return false;
1112    }
1113
1114    //void ListIterator_OnLeavingDirectory(char * path) { }
1115
1116    void ProcessListItem(char * name, char * path, FileStats stats, bool isListItem)
1117    {
1118       if((!bits.foldersOnly && !bits.filesOnly) || (bits.foldersOnly && stats.attribs.isDirectory) || (bits.filesOnly && stats.attribs.isFile))
1119       {
1120          FileSystemNode node = MakeFileSystemNode(stats, name, path, false, bits.previewPictures, isListItem, displaySystem);
1121          AddNode(node);
1122       }
1123    }
1124
1125    FileSystemNode ProcessTreeItem(char * name, char * path, FileStats stats, FileSystemNode parent)
1126    {
1127       FileSystemNode node = MakeFileSystemNode(stats, name, path, false, bits.previewPictures, true, displaySystem);
1128       AddTreeNode(parent, false, false, true, null);
1129       //LoadTreeNode(node);
1130       return node;
1131    }
1132
1133    void LoadTreeNode(FileSystemNode node)
1134    {
1135       if(!node.bits.loaded)
1136       {
1137          char path[MAX_LOCATION];
1138          node.GetPath(path);
1139          {
1140             FileListing listing { path, extensions = extensions };
1141             if(node.children.count == 1)
1142                DeleteNode(node.children.first);
1143
1144             while(listing.Find())
1145             {
1146                char * test;
1147                FileSystemNode child = null;
1148                if(!listing.stats.attribs.isRemovable && ((!bits.foldersOnly && !bits.filesOnly) ||
1149                   (bits.foldersOnly && listing.stats.attribs.isDirectory) ||
1150                   (bits.filesOnly && listing.stats.attribs.isFile)))
1151                   child = MakeAndAddToTreeFileSystemNodeFromFileListing(listing, node);
1152                if(child)
1153                   NodeChildLoad(child, node);
1154                test = child.name;
1155                if(!test)
1156                   PrintLn("error");
1157             }
1158          }
1159          node.bits.childrenLoaded = true;
1160          node.bits.loaded = true;
1161          node.row.SortSubRows(false);
1162       }
1163       else if(!node.bits.childrenLoaded)
1164       {
1165          FileSystemNode child;
1166          if(node.children.first)
1167          {
1168             for(child = node.children.first; child; child = child.next)
1169             {
1170                if(!child.bits.loaded)
1171                   LoadTreeNode(child);
1172                else if(!child.bits.childrenLoaded)
1173                   NodeChildLoad(child, node);
1174             }
1175             node.bits.childrenLoaded = true;
1176             node.row.SortSubRows(false);
1177          }
1178       }
1179    }
1180
1181    void NodeChildLoad(FileSystemNode parent, FileSystemNode node)
1182    {
1183       char path[MAX_LOCATION];
1184       parent.GetPath(path);
1185       if(bits.textFileLinesStyle && FileExists(path).isFile)
1186       {
1187          PrintLn("Test");
1188       }
1189       else
1190       {
1191          bool added = false;
1192          FileListing listing { path, extensions = extensions };
1193          while(listing.Find())
1194          {
1195             char * test;
1196             FileSystemNode child = null;
1197             if((!bits.foldersOnly && !bits.filesOnly) ||
1198                (bits.foldersOnly && listing.stats.attribs.isDirectory) ||
1199                (bits.filesOnly && listing.stats.attribs.isFile))
1200                child = MakeAndAddToTreeFileSystemNodeFromFileListing(listing, parent);
1201             if(child)
1202                added = true;
1203             test = child.name;
1204             if(!test)
1205                PrintLn("error");
1206          }
1207          if(!added)
1208             added = true;
1209       }
1210       parent.bits.childrenLoaded = true;
1211    }
1212
1213    void LoadComparedList()
1214    {
1215       int c, cmp/*, smallest*/, icon;//, equalCount;
1216       int count = comparedPaths ? comparedPaths.count : 0;
1217       //bool allDone = false;
1218       bool not;
1219       FileStats stats;
1220       char path[MAX_LOCATION];
1221       //Array<ComparisonState> states { };
1222       //Array<FileListing> listings { };
1223       //Array<int> equals { };
1224       //Array<MapNode<String, int>> mapNodes { };
1225
1226       //Array<Map<String, int>> lists { };
1227       //Map<int, bool> equals{ };
1228
1229
1230       MapNode<String, /*Map<int, */Array<int>> na;
1231       //MapNode<int, int> nb;
1232       Map<String, /*Map<int, */Array<int>> names { };
1233       //Map<String, Array<bool>> names { };
1234       //Map<String, bool[16]> names { }; // does not seem to be working
1235       //Map<String, BoolArrayInt> names { };
1236       {
1237          for(c = 0; c < comparedPaths.count; c++)
1238          {
1239             FileListing listing { comparedPaths[c], extensions = extensions };
1240             while(listing.Find())
1241             {
1242                /*Map<int, int>*/Array<int> m = names[listing.name];
1243                if(!m)
1244                   m = { };
1245                names[listing.name] = m;
1246                /*/m[c] = */m.Add(c);
1247             }
1248          }
1249          /* // compiles and should work but better solution?
1250          for(c = 0; c < comparedPaths.count; c++)
1251          {
1252             FileListing listing { comparedPaths[c], extensions = extensions };
1253             while(listing.Find())
1254             {
1255                Array<bool> a = names[listing.name];
1256                if(!a)
1257                   a = { };
1258                names[listing.name] = a;
1259                a[c] = true;
1260             }
1261          }
1262          */
1263          /* // does not seem to be working
1264          for(c = 0; c < comparedPaths.count; c++)
1265          {
1266             FileListing listing { comparedPaths[c], extensions = extensions };
1267             while(listing.Find())
1268             {
1269                names[listing.name][c] = true;
1270             }
1271          }
1272          */
1273          /*
1274          if(comparedPaths.count > 0)
1275          {
1276             FileListing listing { comparedPaths[0], extensions = extensions };
1277             while(listing.Find())
1278             {
1279                // should be able to just do names[listing.name]._0 = true;
1280                BoolArrayInt bai = names[listing.name];
1281                bai._0 = true;
1282                names[listing.name] = bai;
1283             }
1284          }
1285          if(comparedPaths.count > 1)
1286          {
1287             FileListing listing { comparedPaths[1], extensions = extensions };
1288             while(listing.Find())
1289             {
1290                // should be able to just do names[listing.name]._1 = true;
1291                BoolArrayInt bai = names[listing.name];
1292                bai._1 = true;
1293                names[listing.name] = bai;
1294             }
1295          }
1296          */
1297          // and so on....
1298       }
1299
1300       /*
1301       for(dirPath : comparedPaths)
1302       {
1303          char * p = dirPath;
1304          if(FileExists(dirPath).isDirectory)
1305          {
1306             FileListing listing { dirPath, extensions = extensions };
1307             //MapNode<String, int> mn;
1308             Map<String, int> list { };
1309             //states.Add(listing.Find() == true ? matching : endOfListing);
1310             while(listing.Find())
1311                list[listing.name] = 0;
1312             //for(mn = ; mn; mn = mn.next)
1313             //mn = list.root.minimum;
1314             mapNodes.Add(/-*mn*-/list.root.minimum);
1315             lists.Add(list);
1316             //PrintLn(dirPath, " -- .Find() -- ", states[states.count-1] == matching ? listing.name : "endOfListing*");
1317             //listings.Add(listing);
1318
1319             {
1320                MapNode<String, int> mn;
1321                PrintLn("------------- DIR LISTING FOR ", dirPath);
1322                for(mn = list.root.minimum; mn; mn = mn.next)
1323                {
1324                   PrintLn(mn.key);
1325                }
1326             }
1327          }
1328       }
1329       */
1330
1331       for(na = names.root.minimum; na; na = na.next)
1332       {
1333          /*Map<int, */Array<int> equals = na.value;
1334          //MapNode<int, int> nb;
1335       /*
1336       while(!allDone)
1337       {
1338          smallest = 0;
1339          equals.Add(0);
1340          for(c = 1; c < count; c++)
1341          {
1342             //if(states[c] == endOfListing) continue;
1343             if(!mapNodes[c]) continue;
1344             // todo: use better comparison method
1345             //       it should compare file type (dir/file) before
1346             //       comparing file name.
1347             //       should also provide alternative methods
1348             //       of comparison including ones that consider
1349             //       date changes as differences of some kind.
1350             //       pethaps a OnCompare(a, b) to allow implementation
1351             //       of custom methods of comparison.
1352             // note: this (or these) method(s) depend on files
1353             //       being listed in sorted order by FileListing.
1354             //       different comparison methods should have
1355             //       appropriatly different sorting in FileListing.
1356             //
1357             //cmp = strcmp(listings[smallest].name, listings[c].name);
1358             cmp = fstrcmp(mapNodes[smallest].key, mapNodes[c].key);
1359             PrintLn("COMPARING - ", mapNodes[smallest].key, " and ", mapNodes[c].key);
1360             if(cmp == 0)
1361                equals.Add(c);
1362                //equals[c] = true;
1363             else if(cmp > 0)
1364             {
1365                smallest = c;
1366                equals.size = 0;
1367                equals.Add(c);
1368             }
1369          }
1370
1371       */
1372          if(equals.count == count) // all are equal, no diff icon
1373          {
1374             icon = 0;
1375             not = false;
1376          }
1377          else if(equals.count == count-1) // all are equal but one, not-sign icon for singled out missing
1378          {
1379             int i;
1380             /*
1381             for(nb = equals.root.minimum, i = 0; nb; nb = nb.next, i++)
1382             {
1383                if(i != nb.key)
1384                */
1385             for(i = 0; i < equals.count; i++)
1386             {
1387                if(i != equals[i])
1388                {
1389                   icon = i+1;
1390                   break;
1391                }
1392             }
1393             //if(!nb)
1394             if(i == equals.count)
1395                icon = count;
1396             not = true;
1397          }
1398          else if(equals.count == 1) // only one is present, all others missing, present-sign for singled out present
1399          {
1400             //icon = equals.root.minimum.key+1;
1401             icon = equals[0]+1;
1402             not = false;
1403          }
1404          else // mixed
1405          {
1406             icon = 0; // todo
1407             not = true;
1408          }
1409 #if 0
1410          // or
1411          if(equals.count == count) // all are equal, no diff icon
1412             ;
1413          else if(count/2 - equals.count < 0) // more than half are equal, use not-sign icons for all missing
1414             ;
1415          else // less than half are equal, use present-sign icons for all present
1416             ;
1417 #endif
1418
1419          /*if((!bits.foldersOnly && !bits.filesOnly) ||
1420             (bits.foldersOnly && listings[smallest].stats.attribs.isDirectory) ||
1421             (bits.filesOnly && listings[smallest].stats.attribs.isFile))*/
1422          strcpy(path, comparedPaths[/*smallest*/equals[0]]);
1423          PathCat(path, /*mapNodes[smallest].key*/na.key);
1424          FileGetStats(path, stats);
1425          if((!bits.foldersOnly && !bits.filesOnly) ||
1426             (bits.foldersOnly && stats.attribs.isDirectory) ||
1427             (bits.filesOnly && stats.attribs.isFile))
1428          {
1429             FileSystemNode node =
1430                   MakeComparedFileSystemNode(
1431                         stats,
1432                         /*mapNodes[smallest].key*/na.key,
1433                         path,
1434                         false, bits.previewPictures,
1435                         icon, not, equals,
1436                         displaySystem);
1437             AddNode(node);
1438          }
1439       /*
1440          for(equal : equals)
1441          {
1442             mapNodes[equal] = mapNodes[equal].next;
1443             //states[equal] = listings[equal].Find() == true ? matching : endOfListing;
1444             //PrintLn(comparedPaths[equal], " -- .Find() -- ", states[equal] == matching ? listings[equal].name : "endOfListing*");
1445          }
1446          equals.size = 0;
1447          //for(c = 0; c < count && states[c] == endOfListing; c++);
1448          for(c = 0; c < count && !mapNodes[c]; c++);
1449          if(c == count)
1450             allDone = true;
1451       */
1452       }
1453       list.Sort(nameField, 1);
1454    }
1455
1456    void AddNode(FileSystemNode node)
1457    {
1458       DataRow row = list.AddRow();
1459       row.tag = (int)node;
1460       node.row = row;
1461       incref node;
1462       row.SetData(nameField, node);
1463       if(bits.pathColumn)
1464       {
1465          char path[MAX_LOCATION];
1466          StripLastDirectory(node.path, path);
1467          row.SetData(pathField, CopyString(path));
1468       }
1469       if(bits.details)
1470       {
1471          if(node.type.isFile)
1472          {
1473             row.SetData(typeField, node.extension);
1474             row.SetData(sizeField, /*(void *)*/node.stats.size);
1475          }
1476          row.SetData(modifiedField, node.stats.modified);
1477       }
1478    }
1479
1480    FileSystemNode MakeAndAddToTreeFileSystemNodeFromFileListing(FileListing listing, FileSystemNode parent)
1481    {
1482       FileSystemNode result = null;
1483       /*if((!bits.foldersOnly && !bits.filesOnly) ||
1484          (bits.foldersOnly && listing.stats.attribs.isDirectory) ||
1485          (bits.filesOnly && listing.stats.attribs.isFile))*/
1486       /*if(!listing.stats.attribs.isRemovable && ((!bits.foldersOnly && !bits.filesOnly) ||
1487          (bits.foldersOnly && listing.stats.attribs.isDirectory) ||
1488          (bits.filesOnly && listing.stats.attribs.isFile)))*/
1489       {
1490          bool textFileLinesStyle = false;
1491          char * test = listing.name;
1492          if(!test)
1493             PrintLn("error");
1494          result = MakeFileSystemNode(listing.stats, listing.name, listing.path, false, bits.previewPictures, false, displaySystem);
1495          test = result.name;
1496          if(!test)
1497             PrintLn("error");
1498          if(bits.textFileLinesStyle)
1499          {
1500             char ext[MAX_LOCATION];
1501             GetExtension(listing.name, ext);
1502             if(!strcmpi(ext, "txt") || !strcmpi(ext, "text"))
1503                textFileLinesStyle = true;
1504          }
1505          //AddTreeNode(result, true, false, textFileLinesStyle, parent);
1506          AddTreeNode(result, !textFileLinesStyle && listing.stats.attribs.isFile, false, !listing.stats.attribs.isFile || textFileLinesStyle, parent);
1507          test = result.name;
1508          if(!test)
1509             PrintLn("error");
1510       }
1511       return result;
1512    }
1513
1514    void AddTreeNode(
1515       FileSystemNode node,
1516       bool loaded,
1517       bool childrenLoaded,
1518       bool addLoader,
1519       FileSystemNode addTo)
1520    {
1521       DataRow row = (addTo && addTo.row) ? addTo.row.AddRow() : list.AddRow();
1522       if(addTo)
1523       {
1524          node.parent = addTo;
1525          node.indent = addTo.indent + 1;
1526          addTo.children.Add(node);
1527       }
1528       row.tag = (int)node;
1529       node.row = row;
1530       row.SetData(null, node);
1531       if(bits.pathColumn)
1532       {
1533          char path[MAX_LOCATION];
1534          StripLastDirectory(node.path, path);
1535          row.SetData(pathField, CopyString(path));
1536       }
1537       if(bits.details)
1538       {
1539          if(node.type.isFile)
1540          {
1541             row.SetData(typeField, node.extension);
1542             row.SetData(sizeField, /*(void *)*/node.stats.size);
1543          }
1544          row.SetData(modifiedField, node.stats.modified);
1545       }
1546
1547       node.bits.loaded = loaded;
1548       node.bits.childrenLoaded = childrenLoaded;
1549       if(addLoader)
1550          //AddTreeNode(FileSystemNode { }, false, false, node); // why would this create a compile error?
1551          AddTreeNode(FileSystemNode { type = none, name = "Loader" }, false, false, false, node);
1552
1553       if(node.indent > 0 || bits.mode == list)
1554          row.collapsed = true;
1555       else if(node.type == folder)
1556          node.type = folderOpen;
1557    }
1558
1559    void DeleteNode(FileSystemNode node)
1560    {
1561       FileSystemNode child;
1562       if(treeBranches)
1563       {
1564          for(; (child = node.children.first); )
1565             DeleteNode(child);
1566       }
1567       list.DeleteRow(node.row);
1568       node.Delete();
1569       //delete node;
1570       //Update(null);
1571    }
1572 }
1573
1574 enum ComparisonState { endOfListing, matching };
1575
1576 /*
1577 #if 0
1578 class ExplorerView : FileSystemBox
1579 {
1580    borderStyle = none;
1581    hasHorzScroll = false;
1582    hasVertScroll = false;
1583
1584    virtual void Load(FileSystemNode parent);
1585    virtual void Refresh();
1586
1587    virtual void LaunchNotifyItemSelect(Window master, ExplorerView view, ExplorerFileItem item, ExplorerFileItemArray selectedItems)
1588    {
1589       view.NotifyItemSelect(master, view, item, selectedItems);
1590    }
1591
1592    virtual bool Window::NotifyItemSelect(ExplorerView view, ExplorerFileItem item, ExplorerFileItemArray selectedItems);
1593    virtual bool Window::NotifyItemOpen(ExplorerView view, ExplorerFileItem item);
1594
1595    ListBox list
1596    {
1597       master = master, parent = this;
1598       //this, master;
1599       borderStyle = none;
1600       hasHorzScroll = true;
1601       hasVertScroll = true;
1602       resizable = true;
1603       sortable = true;
1604       fullRowSelect = false;
1605       multiSelect = true;
1606
1607       anchor = Anchor { left = 0, top = 0, right = 0, bottom = 0 };
1608
1609       bool NotifySelect(ListBox listBox, DataRow row, Modifiers mods)
1610       {
1611          ExplorerView view = (ExplorerView)listBox.parent;
1612          if(listBox.currentRow)
1613          {
1614             DataRow listRow;
1615             ExplorerFileItemArray selectedItems { growingFactor = 16 };
1616             for(listRow = listBox.firstRow; listRow; listRow = listRow.next)
1617                if(listRow.selected)
1618                   selectedItems.Add((ExplorerFileItem)listRow.tag);
1619             //view.NotifyItemSelect(listBox.parent.master, view, (ExplorerFileItem)listBox.currentRow.tag);
1620             view.LaunchNotifyItemSelect(listBox.parent.master, view, (ExplorerFileItem)listBox.currentRow.tag, selectedItems);
1621          }
1622          return true;
1623       }
1624
1625       bool NotifyDoubleClick(ListBox listBox, int x, int y, Modifiers mods)
1626       {
1627          ExplorerView view = (ExplorerView)listBox.parent;
1628          view.NotifyItemOpen(listBox.parent.master, view, (ExplorerFileItem)listBox.currentRow.tag);
1629          return false;
1630       }
1631
1632       bool NotifyKeyDown(ListBox listBox, DataRow row, Key key, unichar ch)
1633       {
1634          if((SmartKey)key == enter)
1635          {
1636             ExplorerView view = (ExplorerView)listBox.parent;
1637             view.NotifyItemOpen(listBox.parent.master, view, (ExplorerFileItem)listBox.currentRow.tag);
1638          }
1639          return true;
1640       }
1641    };
1642
1643    ExplorerView()
1644    {
1645    }
1646 }
1647 #endif
1648
1649 #if 0
1650 class ExplorerViewList : ExplorerView
1651 {
1652
1653    FileSystemNode location;
1654
1655 public:
1656
1657    DataField nameField { header = "Name", dataType = "ExplorerFileItem", width = 304, editable = true, userData = this };
1658
1659    ExplorerViewDetails()
1660    {
1661       list.AddField(nameField);
1662    }
1663
1664    void Refresh()
1665    {
1666       Load(location);
1667    }
1668
1669    void Load(FileSystemNode location)
1670    {
1671       char path[MAX_LOCATION];
1672       this.location = location;
1673       location.GetPath(path);
1674       {
1675          FileListing listing { path };
1676
1677          ExplorerFileItem item;
1678          DataRow row;
1679
1680          list.Clear();
1681
1682          while(listing.Find())
1683          {
1684             item = MakeFileItem(listing.stats.attribs, listing.name, listing.path, previewPictures, displaySystem);
1685
1686             row = list.AddRow();
1687             row.tag = (int)item;
1688             row.SetData(nameField, item);
1689          }
1690          list.Sort(nameField, 1);
1691       }
1692    }
1693 }
1694 #endif
1695
1696 #if 0
1697 class ExplorerViewDetails : ExplorerView
1698 {
1699    list.hasHeader = true;
1700    list.moveFields = true;
1701    list.resizable = true;
1702    list.sortable = true;
1703
1704    FileSystemNode location;
1705
1706 public:
1707
1708    DataField nameField { header = "Name", dataType = "ExplorerFileItem", width = 304, editable = true, userData = this };
1709    DataField typeField { header = "Type", dataType = /-*"String"*-/ "char *", width = 40 };
1710    DataField sizeField { header = "Size", dataType = "FileSize", width = 96, alignment = right };
1711
1712    ExplorerViewDetails()
1713    {
1714       list.AddField(nameField);
1715       list.AddField(typeField);
1716       list.AddField(sizeField);
1717    }
1718
1719    void Refresh()
1720    {
1721       Load(location);
1722    }
1723
1724    void Load(FileSystemNode location)
1725    {
1726       char path[MAX_LOCATION];
1727       this.location = location;
1728       location.GetPath(path);
1729       {
1730          FileListing listing { path };
1731
1732          ExplorerFileItem item;
1733          DataRow row;
1734
1735          list.Clear();
1736
1737          while(listing.Find())
1738          {
1739             item = MakeFileItem(listing.stats.attribs, listing.name, listing.path, previewPictures, displaySystem);
1740
1741             row = list.AddRow();
1742             row.tag = (int)item;
1743             row.SetData(nameField, item);
1744             row.SetData(typeField, CopyString(item.extension));
1745             row.SetData(sizeField, (uint)listing.stats.size);
1746          }
1747          list.Sort(nameField, 1);
1748       }
1749    }
1750 }
1751 #endif
1752
1753 #if 0
1754 class ExplorerViewIcons : ExplorerView
1755 {
1756
1757    FileSystemNode location;
1758
1759 public:
1760
1761    DataField nameField { header = "Name", dataType = "ExplorerFileItem", width = 304, editable = true, userData = this };
1762
1763    ExplorerViewDetails()
1764    {
1765       list.AddField(nameField);
1766    }
1767
1768    void Refresh()
1769    {
1770       Load(location);
1771    }
1772
1773    void Load(FileSystemNode location)
1774    {
1775       char path[MAX_LOCATION];
1776       this.location = location;
1777       location.GetPath(path);
1778       {
1779          FileListing listing { path };
1780
1781          ExplorerFileItem item;
1782          DataRow row;
1783
1784          list.Clear();
1785
1786          while(listing.Find())
1787          {
1788             item = MakeFileItem(listing.stats.attribs, listing.name, listing.path, previewPictures, displaySystem);
1789
1790             row = list.AddRow();
1791             row.tag = (int)item;
1792             row.SetData(nameField, item);
1793          }
1794          list.Sort(nameField, 1);
1795       }
1796    }
1797 }
1798 #endif
1799
1800 #if 0
1801 class ExplorerViewCards : ExplorerView
1802 {
1803
1804    FileSystemNode location;
1805
1806 public:
1807
1808    DataField nameField { header = "Name", dataType = "ExplorerFileItem", width = 304, editable = true, userData = this };
1809
1810    ExplorerViewDetails()
1811    {
1812       list.AddField(nameField);
1813    }
1814
1815    void Refresh()
1816    {
1817       Load(location);
1818    }
1819
1820    void Load(FileSystemNode location)
1821    {
1822       char path[MAX_LOCATION];
1823       this.location = location;
1824       location.GetPath(path);
1825       {
1826          FileListing listing { path };
1827
1828          ExplorerFileItem item;
1829          DataRow row;
1830
1831          list.Clear();
1832
1833          while(listing.Find())
1834          {
1835             item = MakeFileItem(listing.stats.attribs, listing.name, listing.path, previewPictures, displaySystem);
1836
1837             row = list.AddRow();
1838             row.tag = (int)item;
1839             row.SetData(nameField, item);
1840          }
1841          list.Sort(nameField, 1);
1842       }
1843    }
1844 }
1845 #endif
1846
1847 #if 0
1848 public class BitmapArray : RedjArray
1849 {
1850    type = class(Bitmap);
1851 public:
1852    Bitmap * const _;
1853    Bitmap * Add(Bitmap bitmap)
1854    {
1855       uint pos = _count;
1856       Append(1);
1857       _[pos] = bitmap;
1858       return &_[pos];
1859    }
1860    Bitmap * AddBefore(uint position, Bitmap bitmap)
1861    {
1862       Insert(position, 1);
1863       _[position] = bitmap;
1864       return &_[position];
1865    }
1866    void Clear()
1867    {
1868       int c;
1869       for(c = 0; c < _count; c++)
1870       {
1871          _[c].Free();
1872          delete _[c];
1873       }
1874       count = 0;
1875       size = 0;
1876    }
1877 }
1878 #endif
1879
1880 #if 0
1881 class ExplorerViewShowcase : ExplorerView
1882 {
1883    list.anchor = Anchor { left = 0, top = 0, bottom = 0 };
1884    list.size = Size { w = 200 };
1885
1886    FileSystemNode location;
1887
1888 public:
1889
1890    DataField nameField { header = "Name", dataType = "ExplorerFileItem", width = 180, editable = true, userData = this };
1891
1892    Bitmap bitmap;
1893    BitmapArray bitmaps { growingFactor = 16 };
1894
1895    Window show
1896    {
1897       this;
1898       borderStyle = none;
1899       anchor = Anchor { top = 0, right = 0, bottom = 0 };
1900
1901       void OnRedraw(Surface surface)
1902       {
1903          ExplorerViewShowcase view = (ExplorerViewShowcase)parent;
1904          if(view.bitmap)
1905          {
1906             int wBmp = view.bitmap.width;
1907             int hBmp = view.bitmap.height;
1908             int wWnd = clientSize.w;
1909             int hWnd = clientSize.h;
1910
1911             int wList = view.list.size.w + view.split.size.w;
1912
1913             float scale = Min((float)(wWnd - 10) / wBmp, (float)(hWnd - 10) / hBmp);
1914
1915             int wDraw = (int)(wBmp * scale);
1916             int hDraw = (int)(hBmp * scale);
1917
1918       #ifndef __linux__
1919             surface.Filter(view.bitmap, (wWnd - wDraw) / 2, (hWnd - hDraw) / 2, 0, 0, wDraw, hDraw, wBmp, hBmp);
1920       #else
1921             // Until Filter / Stretch works with X
1922             surface.Blit(view.bitmap, (wWnd - wDraw) / 2, (hWnd - hDraw) / 2, 0, 0, wDraw, hDraw);
1923       #endif
1924          }
1925          else
1926          {
1927             surface.SetForeground(white);
1928             surface.Area(0, 0, view.clientSize.w - 1, view.clientSize.h - 1);
1929          }
1930       }
1931    }
1932
1933    SplitWindow split
1934    {
1935       this;
1936       leftPane = list;
1937       rightPane = show;
1938       split = 200;
1939       tabCycle = true;
1940    };
1941
1942    ExplorerViewDetails()
1943    {
1944       list.AddField(nameField);
1945    }
1946
1947    void LaunchNotifyItemSelect(Window master, ExplorerViewShowcase view, ExplorerFileItem item, ExplorerFileItemArray selectedItems)
1948    {
1949       int pos;
1950       ExplorerFileItem selItem;
1951       if(view.bitmap)
1952          view.bitmap.Free();
1953       delete view.bitmap;
1954       if(item && item.type == pictureFile)
1955       {
1956          view.bitmap = Bitmap { };
1957          view.bitmap.Load(item.path, null, displaySystem);
1958       }
1959
1960       view.bitmaps.Clear();
1961       view.bitmaps = BitmapArray { };
1962       for(pos = 0; pos < selectedItems.count; pos++)
1963       {
1964          Bitmap bitmap { };
1965          selItem = (ExplorerFileItem)selectedItems._[pos];
1966          bitmap.Load(selItem.path, null, displaySystem);
1967          //view.bitmaps.Add(bitmap);
1968       }
1969       if(item && item.type == pictureFile)
1970       {
1971          view.bitmap = Bitmap { };
1972          view.bitmap.Load(item.path, null, displaySystem);
1973       }
1974
1975       view.show.Update(null);
1976       view.NotifyItemSelect(master, view, item, selectedItems);
1977    }
1978
1979    void Refresh()
1980    {
1981       Load(location);
1982    }
1983
1984    void Load(FileSystemNode location)
1985    {
1986       char path[MAX_LOCATION];
1987       this.location = location;
1988       location.GetPath(path);
1989       {
1990          FileListing listing { path };
1991
1992          ExplorerFileItem item;
1993          DataRow row;
1994
1995          list.Clear();
1996
1997          while(listing.Find())
1998          {
1999             item = MakeFileItem(listing.stats.attribs, listing.name, listing.path, previewPictures, displaySystem);
2000
2001             row = list.AddRow();
2002             row.tag = (int)item;
2003             row.SetData(nameField, item);
2004          }
2005          list.Sort(nameField, 1);
2006       }
2007    }
2008 }
2009 #endif
2010
2011 #if 0
2012 class ExplorerTree : FileSystemBox
2013 {
2014    hasHorzScroll = false;
2015    hasVertScroll = false;
2016
2017    menu = Menu { };
2018
2019 public:
2020
2021    DataField nameField { dataType = "FileSystemNode", width = 240, userData = this };
2022
2023    FileSystemNode root;
2024    FileSystemNode selection;
2025
2026    virtual bool Window::NotifyNodeSelect(ExplorerTree tree, FileSystemNode node);
2027
2028    property FileSystemNode node
2029    {
2030       get
2031       {
2032          if(!tree)
2033             return null;
2034          if(!tree.currentRow)
2035             return null;
2036          if(!tree.currentRow.tag)
2037             return null;
2038          return (FileSystemNode)tree.currentRow.tag;
2039       }
2040    }
2041
2042    void Select(FileSystemNode node)
2043    {
2044       if(node.row)
2045       {
2046          node.EnsureVisible(false);
2047          tree.SelectRow(node.row);
2048       }
2049    }
2050
2051    FileSystemNode Find(const char * name, FileSystemNode parent)
2052    {
2053       FileSystemNode node;
2054       FileSystemNode start = parent ? parent : root;
2055       if(!start.loaded || !start.childrenLoaded)
2056          LoadTreeNode(start, tree);
2057       for(node = start.children.first; node; node = node.next)
2058          if(node.name && !strcmpi(node.name, name))
2059             return node;
2060       return null;
2061    }
2062
2063    ListBox tree
2064    {
2065       master = master, parent = this;
2066       //this, master;
2067       borderStyle = none;
2068       hasHorzScroll = true;
2069       hasVertScroll = true;
2070       fullRowSelect = false;
2071       treeNodees = true;
2072       collapseControl = true;
2073       rootCollapseButton = true;
2074
2075       anchor = Anchor { left = 0, top = 0, right = 0, bottom = 0 };
2076
2077       // WHY is this not working ?
2078       /-*void OnResize(int width, int height)
2079       {
2080          if(vertScroll.visible)
2081             nameField.width = width - vertScroll.size.w;
2082          else
2083             nameField.width = width;
2084       }*-/
2085
2086       bool NotifyCollapse(ListBox listBox, DataRow row, bool collapsed)
2087       {
2088          if(row)
2089          {
2090             FileSystemNode node = (FileSystemNode)row.tag;
2091             FileSystemNode child;
2092             if(collapsed)
2093             {
2094                /-*
2095                for(child = node.children.last; child; child = node.children.last)
2096                {
2097                   listBox.DeleteRow(child.row);
2098                   child.Free();
2099                   delete child;
2100                }
2101                node.childrenLoaded = false;
2102                *-/
2103             }
2104             else
2105             {
2106                if(!node.loaded || !node.childrenLoaded)
2107                   LoadTreeNode(node, tree);
2108                for(child = node.children.first; child && child.next; child = child.next);
2109                if(child)
2110                   child.EnsureVisible(false);
2111             }
2112          }
2113          return true;
2114       }
2115
2116       bool NotifyRightClick(ListBox listBox, int x, int y, Modifiers mods)
2117       {
2118          DataRow row = listBox.currentRow;
2119          if(row)
2120          {
2121             FileSystemNode node = (FileSystemNode)row.tag;
2122             if(node)
2123             {
2124                PopupMenu popup;
2125                Menu menu { };
2126
2127                MenuItem { menu, "Cut\tCtrl+X", t, NotifySelect = null, disabled = false };
2128                MenuItem { menu, "Copy\tCtrl+C", c, NotifySelect = null, disabled = false };
2129                MenuItem { menu, "Paste\tCtrl+V", p, NotifySelect = null, disabled = false /-*!clipboard*-/ };
2130                MenuItem { menu, "Delete\tDel", d, NotifySelect = null, disabled = false };
2131                //MenuDivider { menu };
2132
2133                popup = PopupMenu
2134                   {
2135                      master = this, menu = menu,
2136                      position = {
2137                         x + clientStart.x + absPosition.x - guiApp.desktop.position.x,
2138                         y + clientStart.y + absPosition.y - guiApp.desktop.position.y }
2139                   };
2140                popup.Create();
2141             }
2142          }
2143          return true;
2144       }
2145
2146       bool NotifySelect(ListBox listBox, DataRow row, Modifiers mods)
2147       {
2148          if(row)
2149          {
2150             FileSystemNode node = (FileSystemNode)row.tag;
2151             NotifyNodeSelect(listBox.parent.master, this, node);
2152             selection = node;
2153          }
2154          return true;
2155       }
2156
2157       bool NotifyEditing(ListBox listBox, DataRow row)
2158       {
2159          if(row)
2160          {
2161             FileSystemNode node = (FileSystemNode)row.tag;
2162          }
2163          return true;
2164       }
2165
2166       bool NotifyEdited(ListBox listBox, DataRow row)
2167       {
2168          if(row)
2169          {
2170             FileSystemNode node = (FileSystemNode)row.tag;
2171          }
2172          return true;
2173       }
2174
2175       bool NotifyEditDone(ListBox listBox, DataRow row)
2176       {
2177          if(row)
2178          {
2179             FileSystemNode node = (FileSystemNode)row.tag;
2180          }
2181          return true;
2182       }
2183    };
2184
2185    // Edit Menu
2186    Menu editMenu { menu, "Edit", e };
2187    MenuItem itemEditCut
2188    {
2189       editMenu, "Cut\tCtrl+X", t, disabled = true;
2190
2191       bool NotifySelect(MenuItem selection, Modifiers mods)
2192       {
2193          //EditCut();
2194          return true;
2195       }
2196    };
2197    MenuItem itemEditCopy
2198    {
2199       editMenu, "Copy\tCtrl+C", c, disabled = true;
2200
2201       bool NotifySelect(MenuItem selection, Modifiers mods)
2202       {
2203          //EditCopy();
2204          return true;
2205       }
2206    };
2207    MenuItem itemEditPaste
2208    {
2209       editMenu, "Paste\tCtrl+V", p;
2210
2211       bool NotifySelect(MenuItem selection, Modifiers mods)
2212       {
2213          //EditPaste();
2214          return true;
2215       }
2216    };
2217    MenuItem itemEditDelete
2218    {
2219       editMenu, "Delete\tDel", d, disabled = true;
2220
2221       bool NotifySelect(MenuItem selection, Modifiers mods)
2222       {
2223          //EditDelete();
2224          return true;
2225       }
2226    };
2227
2228    // WHY is this crashing ?
2229    /-*void OnResize(int width, int height)
2230    {
2231       if(this && nameField)
2232          nameField.width = width - 80;
2233    }*-/
2234
2235    ExplorerTree()
2236    {
2237       tree.AddField(nameField);
2238    }
2239
2240    void Load()
2241    {
2242       FileSystemNode parent;
2243       FileSystemNode node;
2244       FileListing listing { "/" };
2245
2246       tree.Clear();
2247
2248       root = FileSystemNode { type = computer, loaded = true, childrenLoaded = true };
2249    #ifdef __WIN32__
2250       root.name = rootName;
2251    #else
2252       root.name = "/";
2253    #endif
2254       AddTreeNode(root, true, false, false, null, tree);
2255
2256    // How can this make sense for linux?
2257    #ifdef __WIN32__
2258       while(listing.Find())
2259       {
2260          int len = strlen(listing.name);
2261          char info[MAX_LOCATION];
2262          char name[MAX_LOCATION];
2263          if(listing.stats.attribs.isDrive &&
2264                len > 3 && !strncmp(&listing.name[1], ": [", 3))
2265          {
2266             strncpy(name, listing.name, 2);
2267             name[2] = 0;
2268             strncpy(info, &listing.name[4], len - 5);
2269             info[len - 5] = 0;
2270          }
2271          else
2272          {
2273             strcpy(name, listing.name);
2274             info[0] = 0;
2275          }
2276
2277          parent = MakeFileSystemNode(listing.stats, name);
2278          if(info[0])
2279             parent.info = CopyString(info);
2280          parent.loaded = true;
2281          AddTreeNode(parent, !listing.stats.attribs.isDirectory, false, listing.stats.attribs.isDirectory, root, tree);
2282          if(!listing.stats.attribs.isDirectory)
2283             parent.childrenLoaded = true;
2284       }
2285    #endif
2286       node = FileSystemNode { name = msNetwork, type = network };
2287       AddTreeNode(node, false, false, true, null, tree);
2288       node.row.collapsed = true;
2289       tree.Sort(nameField, 1);
2290       tree.SelectRow(root.row);
2291    }
2292 }
2293
2294 #if 0
2295 public class ClipBoardFiles
2296 {
2297
2298 public:
2299
2300    property
2301
2302 }
2303
2304    // CLIPBOARD
2305    void Copy()
2306    {
2307       if(this)
2308       {
2309          int size = SelSize();
2310          if(size)
2311          {
2312             // Try to allocate memory
2313             ClipBoard clipBoard { };
2314             if(clipBoard.Allocate(size+1))
2315             {
2316                GetSel(clipBoard.memory, true);
2317                // Save clipboard
2318                clipBoard.Save();
2319             }
2320             delete clipBoard;
2321          }
2322       }
2323    }
2324
2325    void Paste()
2326    {
2327       if(this)
2328       {
2329          ClipBoard clipBoard { };
2330          if(clipBoard.Load())
2331             PutS(clipBoard.memory);
2332          delete clipBoard;
2333       }
2334    }
2335
2336    void Cut()
2337    {
2338       if(this)
2339       {
2340          Copy();
2341          DelSel();
2342          SetViewToCursor(true);
2343          Modified();
2344       }
2345    }
2346
2347 /-*
2348 Private Type DROPFILES
2349    pFiles As Long
2350    pt As POINTAPI
2351    fNC As Long
2352    fWide As Long
2353 End Type
2354 For iCounter = 0 To filelist.ListCount - 1
2355   If filelist.Selected(iCounter) = True Then
2356     strFiles = strFiles & FixPath(filelist.Path) & filelist.List(iCounter) & vbNullChar
2357   End If
2358 Next
2359 'all selected items are now put in strFiles
2360
2361 hGlobal = GlobalAlloc(GHND, Len(DF) + Len(strFiles)) 'put all files to a exclusive number
2362 If hGlobal Then 'if the globalalloc worked
2363   lpGlobal = GlobalLock(hGlobal) 'lock the hGlobal
2364   DF.pFiles = Len(DF) 'set the size of the files
2365
2366   Call CopyMem(ByVal lpGlobal, DF, Len(DF)) 'copy df to the lpglobal
2367   Call CopyMem(ByVal (lpGlobal + Len(DF)), ByVal strFiles, Len(strFiles)) 'copy strfiles to lpglobal
2368   Call GlobalUnlock(hGlobal) 'unlock hglobal again
2369
2370   SetClipboardData CF_HDROP, hGlobal 'put files to the clipboard
2371 End If
2372 *-/
2373    bool SaveFile(const char * filePath)
2374    {
2375    }
2376 #endif
2377
2378 #if 0
2379 public class FileTreeNodeBSArray : ArrayBinarySorted
2380 {
2381    type = class(FileSystemNode);
2382 public:
2383    FileSystemNode * const _;
2384    BSloc Add(FileSystemNode item)
2385    {
2386       BSloc result = Find(item);
2387       if(!result.valid)
2388       {
2389          Insert(result.pos, 1);
2390          _[result.pos] = item;
2391       }
2392       return result;
2393    }
2394    BSloc Remove(FileSystemNode item)
2395    {
2396
2397    }
2398 }
2399 #endif
2400
2401 #if 0
2402 public class FileTreeNodeArray : RedjArray
2403 {
2404    type = class(FileSystemNode);
2405 public:
2406    FileSystemNode * const _;
2407    FileSystemNode * Add(FileSystemNode item)
2408    {
2409       uint pos = _count;
2410       Append(1);
2411       _[pos] = item;
2412       return &_[pos];
2413    }
2414    FileSystemNode * AddBefore(uint position, FileSystemNode item)
2415    {
2416       Insert(position, 1);
2417       _[position] = item;
2418       return &_[position];
2419    }
2420 }
2421 #endif
2422
2423 #if 0
2424 public class ExplorerFileItem : struct
2425 {
2426    char * path;
2427    char * name;
2428    char * info;
2429    char * extension;
2430    _FileType type;
2431    int indent;
2432
2433    Bitmap bitmap;
2434
2435    void OnDisplay(Surface surface, int x, int y, int width, FileSystemBox control, Alignment alignment, DataDisplayFlags displayFlags)
2436    {
2437       int indentSize = (displayFlags.dropBox) ? 0 : 10;
2438       int textOffset;
2439       int len;
2440       char label[MAX_FILENAME];
2441
2442       //float scale = Min((float)clientSize.w / (float)bitmap.width, (float)clientSize.h / (float)bitmap.height);
2443       int w = 16; //(int)(bitmap.width * scale);
2444       int h = 16; //(int)(bitmap.height * scale);
2445
2446       Bitmap icon;
2447
2448       icon = control.fileIcons[type].bitmap;
2449       if(!icon)
2450       {
2451          if(type == folder || type == folderOpen)
2452             surface.SetForeground(red); //Color { 170, 170, 0 } // REDJ What is that color?
2453          indentSize = 8;
2454       }
2455       textOffset = indent * indentSize + (icon ? (icon.width + 6) : 0);
2456
2457       if(info)
2458          sprintf(label, "%s [%s]", name, info);
2459       else
2460          strcpy(label, name);
2461       len = strlen(label);
2462
2463       surface.WriteTextDots
2464          (alignment, x + textOffset, y + 2, width - textOffset, label, len);
2465       if(type == pictureFile && control.previewPictures && bitmap)
2466       {
2467 #ifndef __linux__
2468          //surface.Filter(bitmap, (clientSize.w - w) / 2,(clientSize.h - h) / 2, 0,0, w, h, bitmap.width, bitmap.height);
2469          surface.Filter(bitmap, x + indent * indentSize + 2, y, 0, 0, w, h, bitmap.width, bitmap.height);
2470 #else
2471          // Until Filter / Stretch works with X
2472          //surface.Blit(bitmap, (clientSize.w - bitmap.width) / 2,(clientSize.h - bitmap.height) / 2, 0,0, bitmap.width, bitmap.height);
2473          surface.blend = true;
2474          surface.Blit(bitmap, x + indent * indentSize + 2, y,0,0, w, h);
2475 #endif
2476          //bitmap.Free();
2477          //delete bitmap;
2478       }
2479       else if(icon)
2480          surface.Blit(icon, x + indent * indentSize + 2, y,0,0, icon.width, icon.height);
2481    }
2482
2483    int OnCompare(ExplorerFileItem b)
2484    {
2485       int result;
2486       if(type == b.type || (type < folder && b.type < folder) || (type >= drive))
2487          result = strcmpi(name, b.name);
2488       else
2489       {
2490          if(type == folder && b.type < folder) result = -1;
2491          else if(type < folder && b.type == folder) result = 1;
2492       }
2493       return result;
2494    }
2495
2496    void OnCopy(ExplorerFileItem newData)
2497    {
2498       type = newData.type;
2499       indent = newData.indent;
2500       if(newData.name)
2501       {
2502          int len = strlen(newData.name) + 1;
2503          name = new char[len];
2504          CopyBytes(name, newData.name, len);
2505       }
2506    }
2507
2508    bool OnGetDataFromString(char * string)
2509    {
2510       int len = strlen(string) + 1;
2511       name = new char[len];
2512       CopyBytes(name, string, len);
2513       return true;
2514    }
2515
2516    void OnFree()
2517    {
2518       delete path;
2519       delete name;
2520       delete info;
2521       delete extension;
2522       if(bitmap)
2523          bitmap.Free();
2524    }
2525
2526    char * OnGetString(char * string, void * fieldData, bool * needClass)
2527    {
2528       return name;
2529    }
2530 };
2531
2532 public class ExplorerFileItemArray : RedjArray
2533 {
2534    type = class(ExplorerFileItem);
2535 public:
2536    ExplorerFileItem * const _;
2537    ExplorerFileItem * Add(ExplorerFileItem item)
2538    {
2539       uint pos = _count;
2540       Append(1);
2541       _[pos] = item;
2542       return &_[pos];
2543    }
2544    ExplorerFileItem * AddBefore(uint position, ExplorerFileItem item)
2545    {
2546       Insert(position, 1);
2547       _[position] = item;
2548       return &_[position];
2549    }
2550    void Clear()
2551    {
2552       int c;
2553       for(c = 0; c < _count; c++)
2554       {
2555          //_[c].Free()
2556          delete _[c];
2557       }
2558       count = 0;
2559       size = 0;
2560    }
2561 }
2562
2563 ExplorerFileItem MakeFileItem(const FileAttribs attribs, const char * fileName, const char * filePath, const bool previewPicture, const DisplaySystem displaySystem)
2564 {
2565    int len = strlen(fileName);
2566    char info[MAX_LOCATION];
2567    char name[MAX_LOCATION];
2568    char extension[MAX_EXTENSION];
2569
2570    ExplorerFileItem item { };
2571
2572    //if(stats.attribs.isFile) // -- should work now
2573    if(attribs.isDirectory)
2574    {
2575       extension[0] = 0;
2576
2577       item.type = (attribs.isDrive) ? drive : folder;
2578       if(attribs.isServer)
2579          item.type = server;
2580       if(attribs.isShare)
2581          item.type = share;
2582       if(attribs.isCDROM)
2583          item.type = cdrom;
2584       if(attribs.isRemote)
2585          item.type = netDrive;
2586       if(attribs.isRemovable)
2587       {
2588          if(fileName[0] == 'A' || fileName[0] == 'B')
2589             item.type = floppy;
2590          else
2591             item.type = removable;
2592       }
2593    }
2594    else
2595    {
2596       GetExtension(fileName, extension);
2597       //strupr(extension);
2598       strlwr(extension);
2599
2600       item.type = _FileType::SelectByExtension(extension);
2601    }
2602
2603    if(attribs.isDrive &&
2604          len > 3 && !strncmp(&fileName[1], ": [", 3))
2605    {
2606       strncpy(name, fileName, 2);
2607       name[2] = 0;
2608       strncpy(info, &fileName[4], len - 5);
2609       info[len - 5] = 0;
2610    }
2611    else
2612    {
2613       strcpy(name, fileName);
2614       info[0] = 0;
2615    }
2616
2617    item.path = CopyString(filePath);
2618    item.name = CopyString(name);
2619    if(info[0])
2620       item.info = CopyString(info);
2621    item.extension = CopyString(extension);
2622
2623    if(item.type == pictureFile && previewPicture)
2624    {
2625       item.bitmap = Bitmap { };
2626       item.bitmap.Load(filePath, null, displaySystem);
2627    }
2628
2629    return item;
2630 }
2631 #endif
2632 */
2633
2634 public class FileSystemBoxSelection
2635 {
2636 public:
2637    FileSystemNode node;
2638    Array<FileSystemNode> nodes { };
2639
2640 private:
2641    FileSystemBoxSelection Copy()
2642    {
2643       FileSystemBoxSelection copy { node = node };
2644       for(node : nodes)
2645       {
2646          copy.nodes.Add(node);
2647          incref node;
2648       }
2649       return copy;
2650    }
2651
2652    ~FileSystemBoxSelection()
2653    {
2654       nodes.Free();
2655    }
2656 }
2657
2658 class FileSystemNodeBits
2659 {
2660    bool loaded:1, childrenLoaded:1, isListItem:1;
2661 };
2662
2663 public class FileSystemNode
2664 {
2665
2666 private:
2667    FileSystemNodeBits bits;
2668    char * path;
2669    char * name;
2670    char * extension;
2671    char * label;
2672    char * info;
2673
2674    ~FileSystemNode()
2675    {
2676       Free();
2677    }
2678
2679 public:
2680    /*//LinkElement<FileSystemNode> link;
2681    FileSystemNode parent;
2682
2683    FileSystemNodeType type;
2684
2685    char * name;*/
2686
2687    FileSystemNode prev, next;
2688
2689    int indent;
2690
2691    property bool isListItem { set { bits.isListItem = value; } get { return bits.isListItem; } };
2692
2693    property char * path
2694    {
2695       set { delete path; if(value && value[0]) path = CopyString(value); }
2696       get { return path; } isset { return path && path[0]; }
2697    }
2698    property char * name
2699    {
2700       set { delete name; if(value && value[0]) name = CopyString(value); }
2701       get { return name; } isset { return name && name[0]; }
2702    }
2703    property char * extension
2704    {
2705       set { delete extension; if(value && value[0]) extension = CopyString(value); }
2706       get { return extension; } isset { return extension && extension[0]; }
2707    }
2708    property char * label
2709    {
2710       set { delete label; if(value && value[0]) label = CopyString(value); }
2711       get { return label; } isset { return label && label[0]; }
2712    }
2713    property char * info
2714    {
2715       set { delete info; if(value && value[0]) info = CopyString(value); }
2716       get { return info; } isset { return info && info[0]; }
2717    }
2718
2719    DataRow row;
2720    OldList children;
2721    _FileType type;
2722    FileSystemNode parent;
2723
2724    FileStats stats;
2725
2726    Bitmap bitmap;
2727
2728    int cmpIcon;
2729    bool cmpNot;
2730    Array<int> exists; // would use (see) BoolArrayInt to pack this into an int if could be accessed as an array
2731
2732    void GetPath(String outputPath)
2733    {
2734       if(path)
2735          strcpy(outputPath, path);
2736       else if(parent)
2737       {
2738          FileSystemNode up;
2739          if(name)
2740             strcpy(outputPath, name);
2741          for(up = parent; up; up = up.parent)
2742          {
2743             char temp[MAX_LOCATION];
2744             strcpy(temp, up.name);
2745             PathCat(temp, outputPath);
2746             strcpy(outputPath, temp);
2747          }
2748       }
2749       else
2750          strcpy(outputPath, name ? name : "");
2751    }
2752
2753    bool IsChildOf(FileSystemNode node)
2754    {
2755       FileSystemNode test;
2756       for(test = parent; test; test = test.parent)
2757          if(test == node)
2758             return true;
2759       return false;
2760    }
2761
2762    void DuplicateChildren(bool recursive, bool forceExpanded, FileSystemNode addTo, FileSystemBox fsb)
2763    {
2764       if(children.first)
2765       {
2766          FileSystemNode child;
2767
2768          for(child = children.first; child; child = child.next)
2769          {
2770             FileSystemNode copy { };
2771             copy.name = child.name; //CopyString(child.name);
2772             copy.type = child.type;
2773             fsb.AddTreeNode(copy, child.bits.loaded, false, false, addTo);
2774             if(forceExpanded)
2775                copy.row.collapsed = false;
2776             if(recursive)
2777                child.DuplicateChildren(recursive, forceExpanded, copy, fsb);
2778          }
2779       }
2780    }
2781
2782    void EnsureVisible(bool expand)
2783    {
2784       if(parent)
2785          parent.EnsureVisible(true);
2786       if(expand)
2787          row.collapsed = false;
2788       // TODO: row.EnsureVisible(); // making the row visible by scrolling
2789    }
2790
2791    void OnFree()
2792    {
2793       //delete name;
2794    }
2795
2796    void Free()
2797    {
2798       FileSystemNode child;
2799       for(; (child = children.first); )
2800       {
2801          child.Free();
2802          children.Delete(child);
2803       }
2804       //if(name)
2805       delete path;
2806       delete name;
2807       delete extension;
2808       delete label;
2809       delete info;
2810    }
2811
2812    void Delete()
2813    {
2814       Free();
2815       if(parent)
2816          parent.children.Delete(this);
2817    }
2818
2819    void OnDisplay(Surface surface, int x, int y, int width, FileSystemBox fsb, Alignment alignment, DataDisplayFlags displayFlags)
2820    {
2821       //int indentSize = (displayFlags.dropBox) ? 0 : 10;
2822       int indent = 16;
2823       int xStart;
2824       int len;
2825       int w, h;
2826       //int textOffset;
2827       char * alt;
2828       char text[MAX_LOCATION];
2829       bool comp;
2830
2831       Bitmap icon;
2832       Bitmap diffIcon;
2833       Bitmap notIcon;
2834
2835       if(!this)
2836          return;
2837
2838       comp = fsb.comparedPaths && fsb.comparedPaths.count > 1;
2839
2840       icon = fsb.fileIcons[type].bitmap;
2841       alt = bits.isListItem ? path : name;
2842       if(comp && !fsb.bits.columnsCompareStyle && cmpIcon)
2843       {
2844          /*
2845          diffIcon = Bitmap { };
2846          diffIcon.AllocateDD(
2847                surface.display.displaySystem,
2848                fsb.compIcons[cmpIcon].bitmap.width,
2849                fsb.compIcons[cmpIcon].bitmap.height);
2850          if(fsb.compIcons[cmpIcon].bitmap)
2851             diffIcon.Copy(fsb.compIcons[cmpIcon].bitmap);
2852          */
2853          diffIcon = fsb.compIcons[cmpIcon-1].bitmap;
2854          notIcon = fsb.compIcons[countOfCompIconNames-1].bitmap;
2855       }
2856       //xStart = indent * indent + x + (icon ? (icon.width + 5) : 0);
2857       xStart = x + (icon ? (icon.width + 5) : 0) + (comp ? 18*(fsb.bits.columnsCompareStyle ? fsb.comparedPaths.count : 1) : 0);
2858
2859       if(!alt)
2860          return;
2861
2862       if(info)
2863          sprintf(text, "%s [%s]", label ? label : alt, info);
2864       else
2865          strcpy(text, label ? label : alt); //"%d-%d/%s", stats.inode, stats.nlink
2866          //sprintf(text, "%d-%d/%s", stats.inode, stats.nlink, label ? label : alt);
2867       len = strlen(text);
2868
2869       if(!icon)
2870       {
2871          if(type == folder || type == folderOpen)
2872             surface.SetForeground(yellow);
2873          //indentSize = 8;
2874          indent = 8;
2875       }
2876       //textOffset = indent * indentSize + (icon ? (icon.width + 4) : 0);
2877
2878       surface.SetForeground(displayFlags.selected ? fsb.selectionText : fsb.foreground);
2879       surface.TextOpacity(false);
2880       surface.TextExtent(text, len, &w, &h);
2881       h = Max(h, 16);
2882
2883       // Draw the current row stipple
2884       if(displayFlags.selected)
2885          //surface.Area(xStart - 1, y, xStart - 1, y + h - 1);
2886          //surface.Area(xStart + w - 1, y, xStart + w + 1, y + h - 1);
2887          surface.Area(xStart - 3, y, xStart + w + 1, y + h - 1);
2888       //surface.WriteTextDots(alignment, x + textOffset, y + 2, width - textOffset, alt, strlen(alt));
2889       surface.WriteTextDots(alignment, xStart, y + 2, width, text, len);
2890
2891       if(!guiApp.textMode)
2892       {
2893          if(displayFlags.current)
2894          {
2895             if(displayFlags.active)
2896             {
2897                surface.LineStipple(0x5555);
2898                if(displayFlags.selected)
2899                   surface.SetForeground(0xFFFFFF80);
2900                else
2901                   surface.SetForeground(black);
2902             }
2903             else
2904             {
2905                surface.SetForeground(selectionColor);
2906             }
2907             surface.Rectangle(xStart - 3, y, xStart + w + 1, y + h - 1);
2908             surface.LineStipple(0);
2909          }
2910
2911          if(comp)
2912          {
2913             if(!fsb.bits.columnsCompareStyle && diffIcon)
2914             {
2915                w = diffIcon.width;
2916                h = diffIcon.height;
2917                /*if(cmpNot && notIcon)
2918                {
2919                   Surface s = diffIcon.GetSurface(0,0, {w,h});
2920                   s.SetForeground(white);
2921                   s.Blit(notIcon, x,y, 0,0, w,h);
2922                   delete s;
2923                }*/
2924                surface.SetForeground(white);
2925                surface.Blit(diffIcon, x,y, 0,0, w,h);
2926                if(cmpNot && notIcon)
2927                   surface.Blit(notIcon, x,y, 0,0, w,h);
2928                x+=18;
2929                //delete diffIcon;
2930             }
2931             else if(fsb.bits.columnsCompareStyle && exists && exists.count)
2932             {
2933                int c, d;
2934                for(c = d = 0; c < fsb.comparedPaths.count; c++)
2935                {
2936                   if(d == exists.count || exists[d] != c)
2937                      x+=18;
2938                   else
2939                   {
2940                      diffIcon = fsb.compIcons[c].bitmap;
2941                      if(diffIcon)
2942                      {
2943                         w = diffIcon.width;
2944                         h = diffIcon.height;
2945                         surface.SetForeground(white);
2946                         surface.Blit(diffIcon, x,y, 0,0, w,h);
2947                      }
2948                      x+=18;
2949                      d++;
2950                   }
2951                }
2952                /*
2953                for(c = d = 0; c < exists.count; c++)
2954                {
2955                   if(exists[c] != d)
2956                   {
2957                      d = exists[c]+1;
2958                      x+=18*(exists[c]-d);
2959                   }
2960                   else
2961                   {
2962                      diffIcon = fsb.compIcons[exists[c]].bitmap;
2963                      if(diffIcon)
2964                      {
2965                         w = diffIcon.width;
2966                         h = diffIcon.height;
2967                         surface.SetForeground(white);
2968                         surface.Blit(diffIcon, x,y, 0,0, w,h);
2969                      }
2970                      d++;
2971                      x+=18;
2972                   }
2973                }
2974                if(exists.count < fsb.comparedPaths.count && exists[exists.count-1] != d)
2975                {
2976                   x+=18*(exists[exists.count-1]-d);
2977                }
2978                */
2979             }
2980             else if(fsb.bits.columnsCompareStyle)
2981             {
2982                x+=18*fsb.comparedPaths.count;
2983             }
2984          }
2985          if(icon)
2986          {
2987             w = icon.width;
2988             h = icon.height;
2989          }
2990          if(type == pictureFile && fsb.previewPictures && bitmap)
2991          {
2992             surface.SetForeground(white);
2993             surface.blend = true;
2994    //#ifndef __linux__
2995             //surface.Filter(bitmap, (clientSize.w - w) / 2,(clientSize.h - h) / 2, 0,0, w, h, bitmap.width, bitmap.height);
2996             //surface.Filter(bitmap, x + indent/* * indentSize*/ + 2, y, 0, 0, w, h, bitmap.width, bitmap.height);
2997             surface.Filter(bitmap, x,y,0,0, w, h, bitmap.width, bitmap.height);
2998    //#else
2999             // Until Filter / Stretch works with X
3000             //surface.Blit(bitmap, (clientSize.w - bitmap.width) / 2,(clientSize.h - bitmap.height) / 2, 0,0, bitmap.width, bitmap.height);
3001    //         surface.blend = true;
3002             //surface.Blit(bitmap, x + indent/* * indentSize*/ + 2, y,0,0, w, h);
3003             //surface.Blit(bitmap, x,y,0,0, bitmap.width, bitmap.height);
3004    //#endif
3005             //bitmap.Free();
3006             //delete bitmap;
3007          }
3008          else if(icon)
3009          {
3010             //surface.blend = true;
3011             //surface.alphaWrite = blend;
3012             surface.SetForeground(white);
3013             //surface.Blit(icon, x + indent * indentSize, y,0,0, icon.width, icon.height);
3014             surface.Blit(icon, x,y, 0,0, w,h);
3015          }
3016       }
3017    }
3018
3019    Window OnEdit(DataBox dataBox, DataBox obsolete, int x, int y, int w, int h, void * userData)
3020    {
3021       EditBox editBox
3022       {
3023          dataBox, anchor = { 0, 0, 0, 0 };
3024          borderStyle = none;
3025          //borderStyle = contour;
3026          opacity = 1.0f;
3027          //background = white;
3028          //autoSize = true;
3029          contents = name;
3030       };
3031       //dataBox.borderStyle = none;
3032       dataBox.borderStyle = contour;
3033       dataBox.background = white;
3034       //dataBox.opacity = 0.0f;
3035       editBox.Create();
3036       return editBox;
3037    }
3038
3039    bool OnSaveEdit(EditBox editBox, void * object)
3040    {
3041       bool changed = false;
3042       if(editBox.modifiedDocument)
3043       {
3044 #if 0
3045          // how the heck did this work for PathBox? :S
3046          //String::OnFree();
3047          //changed = _class._vTbl[__ecereVMethodID_class_OnGetDataFromString](_class, &this, editBox.contents);
3048          PrintLn(name);
3049          //if(strcmp(editBox.contents, this.name))
3050          ;
3051          /*{
3052             //changed = NotifyNodeRename(this.master, this, node);
3053             changed = true;
3054             if(changed && RenameFile(name, editBox.contents))
3055             {
3056                name = editBox.contents;
3057             }
3058             else
3059             {
3060                changed = false;
3061             }
3062          }*/
3063 #endif
3064       }
3065       return changed;
3066    }
3067
3068    int OnCompare(FileSystemNode b)
3069    {
3070       int result;
3071       FileSystemNode a = this;
3072       if(a.type == b.type || (a.type < folder && b.type < folder) || (a.type >= drive))
3073       {
3074          if(!a.name || !b.name)
3075             PrintLn("error: FileSystemNode::OnCompare -- null-named node");
3076          result = strcmpi(a.name, b.name);
3077       }
3078       else
3079       {
3080          if(a.type == folder && b.type < folder) result = -1;
3081          else if(a.type < folder && b.type == folder) result = 1;
3082          else result = 0;
3083       }
3084       return result;
3085    }
3086
3087 #if 0
3088    //int OnCompare(FileSystemNode b)
3089    //{
3090       //int result;
3091       //FileSystemNode a = this;
3092       //if(a.parent < b.parent) result = -1;
3093       //else if(a.parent > b.parent) result = 1;
3094       //else
3095          //result = fstrcmp(a.name, b.name);
3096       //return result;
3097    //}
3098 #endif
3099
3100    bool OnGetDataFromString(char * string)
3101    {
3102 #if 0
3103       if(string && *string)
3104       {
3105          int len = strlen(string) + 1;
3106          name = new char[len];
3107          CopyBytes(name, string, len);
3108          return true;
3109       }
3110 #endif
3111       return false;
3112    }
3113
3114    char * OnGetString(char * tempString, FileSystemToolWindow fileSysToolWnd, bool * needClass)
3115    {
3116       return name ? name : "";
3117    }
3118 }
3119
3120 /*FileSystemNode MakeFileSystemNode(const FileStats stats, const char * name)
3121 {
3122    FileSystemNode node { stats = stats };
3123    node.name = CopyString(name);
3124    if(!node.name)
3125       node.name = null;
3126    if(stats.attribs.isDirectory)
3127    {
3128       node.type = (stats.attribs.isDrive) ? drive : folder;
3129       if(stats.attribs.isServer) node.type = server;
3130       if(stats.attribs.isShare) node.type = share;
3131       if(stats.attribs.isCDROM) node.type = cdrom;
3132       if(stats.attribs.isRemote) node.type = netDrive;
3133       if(stats.attribs.isRemovable)
3134       {
3135          if(name[0] == 'A' || name[0] == 'B')
3136             node.type = floppy;
3137          else
3138             node.type = removable;
3139       }
3140    }
3141    else
3142    {
3143       char extension[MAX_EXTENSION];
3144       GetExtension(node.name, extension);
3145       node.type = _FileType::SelectByExtension(extension);
3146    }
3147    return node;
3148 }*/
3149
3150 FileSystemNode MakeFileSystemNode(
3151    const FileStats stats,
3152    const char * name,
3153    const char * path,
3154    const bool pathAddName,
3155    const bool previewPicture,
3156    const bool isListItem,
3157    const DisplaySystem displaySystem)
3158 {
3159    int len = strlen(name);
3160    char info[MAX_LOCATION];
3161    char name2[MAX_LOCATION];
3162    char extension[MAX_EXTENSION];
3163
3164    FileSystemNode node { stats = stats };
3165
3166    /*if(!pathAddName)
3167    {
3168       char o[MAX_LOCATION];
3169       //char r[MAX_LOCATION];
3170       //StripLastDirectory(path, o);
3171       GetLastDirectory(path, o);
3172       if(fstrcmp(name, o))
3173       //if(!FileExists(path))
3174          PrintLn("Stop!");
3175    }*/
3176    //if(stats.attribs.isFile) // TODO fix this in ecere -- WTH -- this has been fixed :/
3177    if(stats.attribs.isDirectory)
3178    {
3179       extension[0] = '\0';
3180
3181       node.type = (stats.attribs.isDrive) ? drive : folder;
3182       if(stats.attribs.isServer) node.type = server;
3183       if(stats.attribs.isShare) node.type = share;
3184       if(stats.attribs.isCDROM) node.type = cdrom;
3185       if(stats.attribs.isRemote) node.type = netDrive;
3186       if(stats.attribs.isRemovable)
3187       {
3188          if(name[0] == 'A' || name[0] == 'B')
3189             node.type = floppy;
3190          else
3191             node.type = removable;
3192       }
3193    }
3194    else
3195    {
3196       GetExtension(name, extension);
3197       strlwr(extension);
3198
3199       node.type = _FileType::SelectByExtension(extension);
3200    }
3201
3202    if(stats.attribs.isDrive &&
3203          len > 3 && !strncmp(&name[1], ": [", 3))
3204    {
3205       strncpy(name2, name, 2);
3206       name2[2] = 0;
3207       strncpy(info, &name[4], len - 5);
3208       info[len - 5] = 0;
3209    }
3210    else
3211    {
3212       strcpy(name2, name);
3213       info[0] = 0;
3214    }
3215
3216    if(pathAddName)
3217    {
3218       bool isFile = stats.attribs.isFile;
3219       bool isFolder = stats.attribs.isDirectory;
3220       char full[MAX_LOCATION];
3221       strcpy(full, path);
3222       PathCat(full, name);
3223       node.path = full; //CopyString(full);
3224    }
3225    else
3226       node.path = path; //CopyString(path);
3227    node.name = name2; //CopyString(name2);
3228    if(info[0])
3229       node.info = info; //CopyString(info);
3230    node.extension = extension; //CopyString(extension);
3231
3232    if(node.type == pictureFile && previewPicture)
3233    {
3234       node.bitmap = Bitmap { alphaBlend = true };
3235       node.bitmap.Load(path, null, displaySystem);
3236    }
3237
3238    if(isListItem)
3239       node.bits.isListItem = true;
3240
3241    return node;
3242 }
3243
3244 FileSystemNode MakeComparedFileSystemNode(
3245    const FileStats stats,
3246    const char * name,
3247    const char * path,
3248    const bool pathAddName,
3249    const bool previewPicture,
3250    const int cmpIcon,
3251    const bool cmpNot,
3252    const Array<int> exists,
3253    const DisplaySystem displaySystem)
3254 {
3255    FileSystemNode node = MakeFileSystemNode(stats, name, path, pathAddName, previewPicture, false, displaySystem);
3256    if(node)
3257    {
3258       node.cmpIcon = cmpIcon;
3259       node.cmpNot = cmpNot;
3260       node.exists = exists;
3261    }
3262    return node;
3263 }
3264
3265 #if 0 // could we do this?
3266 class BoolArrayInt : int
3267 {
3268    // packing 32 bools in one int exposing them as an array
3269    bool [32]:1; // the :1 specifies the size of each element
3270    // byte [4]:8; // packing 4 bytes in an int exposing them as an arrat
3271 }
3272 // allowing you to access each 32 bits with the following notation:
3273 static void Dummy()
3274 {
3275    int c;
3276    BoolArrayInt a;
3277    a[0] = true;
3278    a[31] = false;
3279    for(c = 0; c < 32; c++)
3280       a[c] = SomFunction(...);
3281 }
3282 #endif
3283 class BoolArrayInt : int
3284 {
3285    bool  _0:1;
3286    bool  _1:1;
3287    bool  _2:1;
3288    bool  _3:1;
3289    bool  _4:1;
3290    bool  _5:1;
3291    bool  _6:1;
3292    bool  _7:1;
3293    bool  _8:1;
3294    bool  _9:1;
3295    bool _10:1;
3296    bool _11:1;
3297    bool _12:1;
3298    bool _13:1;
3299    bool _14:1;
3300    bool _15:1;
3301 }