The Ecere SDK - ede/blob - libede/src/FileSystemBox.ec

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