开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
Flu_File_Chooser.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：98k
源码类别：

生物技术

开发平台：

C/C++

Flu_File_Chooser.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Flu_File_Chooser.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 21:05:46  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.3
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*
  11.  * These files were imported into NCBI's CVS directly from FLU version 2.9.1.
  12.  * Modifications to the source are listed below.
  13.  *
  14.  * ==========================================================================
  15.  * $Log: Flu_File_Chooser.cpp,v $
  16.  * Revision 1000.1  2004/06/01 21:05:46  gouriano
  17.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.3
  18.  *
  19.  * Revision 1.3  2004/05/21 22:27:51  gorelenk
  20.  * Added PCH ncbi_pch.hpp
  21.  *
  22.  * Revision 1.2  2004/03/11 14:10:10  dicuccio
  23.  * Fixes for 64-bit compilation.  Cast away const from strchr() where needed
  24.  *
  25.  * Revision 1.1  2004/03/11 13:51:39  dicuccio
  26.  * Imported FLU version 2.9.1.  Altered export specifiers to match NCBI layout.
  27.  * Altered include paths to match NCBI toolkit layout.
  28.  *
  29.  * ==========================================================================
  30.  */
  31. // $Id: Flu_File_Chooser.cpp,v 1000.1 2004/06/01 21:05:46 gouriano Exp $
  33. /***************************************************************
  34.  *                FLU - FLTK Utility Widgets 
  35.  *  Copyright (C) 2002 Ohio Supercomputer Center, Ohio State University
  36.  *
  37.  * This file and its content is protected by a software license.
  38.  * You should have received a copy of this license with this file.
  39.  * If not, please contact the Ohio Supercomputer Center immediately:
  40.  * Attn: Jason Bryan Re: FLU 1224 Kinnear Rd, Columbus, Ohio 43212
  41.  * 
  42.  ***************************************************************/
  46. #include <ncbi_pch.hpp>
  47. #include <stdio.h>
  48. #include <string.h>
  49. #include <stdlib.h>
  50. #include <ctype.h>
  51. #include <time.h>
  52. #include <sys/types.h>
  53. #include <sys/stat.h>
  55. #ifdef WIN32
  56. #include <windows.h>
  57. #include <shellapi.h>
  58. #include <lmcons.h>
  59. #endif
  61. #if defined WIN32 && !defined CYGWIN
  62. #include <direct.h>
  63. #else
  64. #include <unistd.h>
  65. #endif
  67. #include <FL/Fl.H>
  68. #include <FL/fl_draw.H>
  69. #include <FL/fl_ask.H>
  70. #include <FL/math.h>
  71. #include <FL/filename.H>
  72. #include <FL/Fl_Pixmap.H>
  73. #include <FL/Fl_Scroll.H>
  74. #include <FL/Fl_Shared_Image.H>
  76. #include <gui/widgets/FLU/flu_pixmaps.h>
  77. #include <gui/widgets/FLU/Flu_Label.h>
  78. #include <gui/widgets/FLU/Flu_Tree_Browser.h>
  79. #include <gui/widgets/FLU/Flu_Separator.h>
  80. #include <gui/widgets/FLU/Flu_Enumerations.h>
  82. #include <gui/widgets/FLU/Flu_File_Chooser.h>
  83. #include <gui/widgets/FLU/flu_file_chooser_pixmaps.h>
  84. #include <gui/widgets/FLU/flu_pixmaps.h>
  86. // just a string that no file could probably ever be called
  87. #define FAVORITES_UNIQUE_STRING   "t!@#$%^&*(Favorites)-=+"
  89. #define DEFAULT_ENTRY_WIDTH 235
  91. Fl_Pixmap up_folder_img( (char*const*)big_folder_up_xpm ),
  92.   trash( (char*const*)trash_xpm ),
  93.   new_folder( (char*const*)big_folder_new_xpm ),
  94.   reload( (char*const*)reload_xpm ),
  95.   preview_img( (char*const*)monalisa_xpm ),
  96.   file_list_img( (char*const*)filelist_xpm ),
  97.   file_listwide_img( (char*const*)filelistwide_xpm ),
  98.   fileDetails( (char*const*)filedetails_xpm ),
  99.   add_to_favorite_folder( (char*const*)folder_favorite_xpm ),
  100.   home( (char*const*)bighome_xpm ),
  101.   favorites( (char*const*)bigfavorites_xpm ),
  102.   desktop( (char*const*)desktop_xpm ),
  103.   folder_closed( (char*const*)folder_closed_xpm ),
  104.   default_file( (char*const*)textdoc_xpm ),
  105.   my_computer( (char*const*)my_computer_xpm ),
  106.   computer( (char*const*)computer_xpm ),
  107.   disk_drive( (char*const*)disk_drive_xpm ),
  108.   cd_drive( (char*const*)cd_drive_xpm ),
  109.   floppy_drive( (char*const*)floppy_drive_xpm ),
  110.   removable_drive( (char*const*)removable_drive_xpm ),
  111.   ram_drive( (char*const*)ram_drive_xpm ),
  112.   network_drive( (char*const*)network_drive_xpm ),
  113.   documents( (char*const*)filled_folder_xpm ),
  114.   littlehome( (char*const*)home_xpm ),
  115.   little_favorites( (char*const*)mini_folder_favorites_xpm ),
  116.   little_desktop( (char*const*)mini_desktop_xpm ),
  117.   bigdocuments( (char*const*)bigdocuments_xpm ),
  118.   bigtemporary( (char*const*)bigtemporary_xpm );
  120. #define streq(a,b) (strcmp(a,b)==0)
  122. Flu_File_Chooser::FileTypeInfo* Flu_File_Chooser::types = NULL;
  123. int Flu_File_Chooser::numTypes = 0;
  124. int Flu_File_Chooser::typeArraySize = 0;
  125. Flu_File_Chooser::ContextHandlerVector Flu_File_Chooser::contextHandlers;
  126. Flu_File_Chooser::PreviewHandlerVector Flu_File_Chooser::previewHandlers;
  127. Flu_File_Chooser::ImgTxtPreview* Flu_File_Chooser::imgTxtPreview = 0;
  128. int (*Flu_File_Chooser::customSort)(const char*,const char*) = 0;
  130. // taken explicitly from fltk/src/filename_match.cxx
  131. // and changed to support case-sensitive matching
  132. static int flu_filename_match(const char *s, const char *p)
  133. {
  134.   int matched;
  136.   for (;;) {
  137.     switch(*p++) {
  139.     case '?' : // match any single character
  140.       if (!*s++) return 0;
  141.       break;
  143.     case '*' : // match 0-n of any characters
  144.       if (!*p) return 1; // do trailing * quickly
  145.       while (!flu_filename_match(s, p)) if (!*s++) return 0;
  146.       return 1;
  148.     case '[': { // match one character in set of form [abc-d] or [^a-b]
  149.       if (!*s) return 0;
  150.       int reverse = (*p=='^' || *p=='!'); if (reverse) p++;
  151.       matched = 0;
  152.       char last = 0;
  153.       while (*p) {
  154. if (*p=='-' && last) {
  155.   if (*s <= *++p && *s >= last ) matched = 1;
  156.   last = 0;
  157. } else {
  158.   if (*s == *p) matched = 1;
  159. }
  160. last = *p++;
  161. if (*p==']') break;
  162.       }
  163.       if (matched == reverse) return 0;
  164.       s++; p++;}
  165.     break;
  167.     case '{' : // {pattern1|pattern2|pattern3}
  168.     NEXTCASE:
  169.     if (flu_filename_match(s,p)) return 1;
  170.     for (matched = 0;;) {
  171.       switch (*p++) {
  172.       case '\': if (*p) p++; break;
  173.       case '{': matched++; break;
  174.       case '}': if (!matched--) return 0; break;
  175.       case '|': case ',': if (matched==0) goto NEXTCASE;
  176.       case 0: return 0;
  177.       }
  178.     }
  179.     case '|': // skip rest of |pattern|pattern} when called recursively
  180.     case ',':
  181.       for (matched = 0; *p && matched >= 0;) {
  182. switch (*p++) {
  183. case '\': if (*p) p++; break;
  184. case '{': matched++; break;
  185. case '}': matched--; break;
  186. }
  187.       }
  188.       break;
  189.     case '}':
  190.       break;
  192.     case 0: // end of pattern
  193.       return !*s;
  195.     case '\': // quote next character
  196.       if (*p) p++;
  197.     default:
  198.       //if (tolower(*s) != tolower(*(p-1))) return 0;
  199.       if( *s != *(p-1) ) return 0;
  200.       s++;
  201.       break;
  202.     }
  203.   }
  204. }
  206. void Flu_File_Chooser :: add_context_handler( int type, const char *ext, const char *name,
  207.       void (*cb)(const char*,int,void*), void *cbd )
  208. {
  209.   if( cb == NULL )
  210.     return;
  211.   ContextHandler h;
  212.   h.ext = ext ? ext : "";
  213.   h.ext.downcase();
  214.   h.type = type;
  215.   h.name = name;
  216.   h.callback = cb;
  217.   h.callbackData = cbd;
  218.   Flu_File_Chooser::contextHandlers.add( h );
  219. }
  221. void Flu_File_Chooser :: add_preview_handler( PreviewWidgetBase *w )
  222. {
  223.   if( w == NULL )
  224.     return;
  225.   Flu_File_Chooser::previewHandlers.add( w );
  226. }
  228. // extensions == NULL implies directories
  229. void Flu_File_Chooser :: add_type( const char *extensions, const char *short_description, Fl_Image *icon )
  230. {
  231.   FluSimpleString ext;
  232.   if( extensions )
  233.     ext = extensions;
  234.   else
  235.     ext = "t"; // indicates a directory
  236.   ext.upcase();
  238.   // are we overwriting an existing type?
  239.   for( int i = 0; i < numTypes; i++ )
  240.     {
  241.       if( types[i].extensions == ext )
  242. {
  243.   types[i].icon = icon;
  244.   types[i].type = short_description;
  245.   return;
  246. }
  247.     }
  249.   if( numTypes == typeArraySize )
  250.     {
  251.       int newSize = ( typeArraySize == 0 ) ? 1 : typeArraySize*2; // double the size of the old list (same behavior as STL vector)
  252.       // allocate the new list
  253.       FileTypeInfo* newTypes = new FileTypeInfo[ newSize ];
  254.       // copy the old list to the new list
  255.       for( int i = 0; i < numTypes; i++ )
  256. {
  257.   newTypes[i].icon = types[i].icon;
  258.   newTypes[i].extensions = types[i].extensions;
  259.   newTypes[i].type = types[i].type;
  260. }
  261.       // delete the old list and replace it with the new list
  262.       delete[] types;
  263.       types = newTypes;
  264.       typeArraySize = newSize;
  265.     }
  267.   types[numTypes].icon = icon;
  268.   types[numTypes].extensions = ext;
  269.   types[numTypes].type = short_description;
  271.   numTypes++;
  272. }
  274. Flu_File_Chooser::FileTypeInfo* Flu_File_Chooser :: find_type( const char *extension )
  275. {
  276.   FluSimpleString ext;
  277.   if( extension )
  278.     ext = extension;
  279.   else
  280.     ext = "t"; // indicates a directory
  281.   ext.upcase();
  283.   // lookup the type based on the extension
  284.   for( int i = 0; i < numTypes; i++ )
  285.     {
  286.       // check extension against every token
  287.       FluSimpleString e = types[i].extensions;
  288.       char *tok = strtok( (char*)e.c_str(), " ," );
  289.       while( tok )
  290. {
  291.   if( ext == tok )
  292.     return &(types[i]);
  293.   tok = strtok( NULL, " ," );
  294. }
  295.     }
  297.   return NULL;
  298. }
  300. Flu_File_Chooser :: Flu_File_Chooser( const char *pathname, const char *pat, int type, const char *title )
  301.   : Fl_Double_Window( 600, 400, title ),
  302.     filename( 70, h()-60, w()-70-85-10, 25, "Filename:", this ),
  303.     ok( w()-90, h()-60, 85, 25, "Ok" ),
  304.     cancel( w()-90, h()-30, 85, 25, "Cancel" ),
  305.     entryPopup( 0, 0, 0, 0 )
  306. {
  307.   Fl_Double_Window::size_range( 600, 400 );
  309.   Fl_Group *g;
  311.   add_type( NULL, "Directory", &folder_closed );
  313.   history = currentHist = NULL;
  314.   walkingHistory = false;
  315.   fileEditing = true;
  316. #ifdef WIN32
  317.   refreshDrives = true;
  318.   caseSort = false;
  319. #else
  320.   caseSort = true;
  321. #endif
  323.   int oldNormalSize = FL_NORMAL_SIZE;
  324.   FL_NORMAL_SIZE = 12;
  325.   selectionType = type;
  326.   filenameEnterCallback = filenameTabCallback = false;
  327.   sortMethod = SORT_NAME;
  329.   lastSelected = NULL;
  330.   filename.labelsize( 12 );
  331.   filename.when( FL_WHEN_ENTER_KEY_ALWAYS );
  332.   filename.callback( _filenameCB, this );
  333.   filename.value( "" );
  335.   Fl_Group *quickIcons = new Fl_Group( 5, 5, 100, h()-10-60 );
  336.   quickIcons->box( FL_DOWN_BOX );
  337.   quickIcons->color( FL_DARK3 );
  339.   Flu_Button *desktopBtn = new Flu_Button( 30, 18, 50, 48 );
  340.   desktopBtn->box( FL_FLAT_BOX );
  341.   desktopBtn->image( desktop );
  342.   desktopBtn->enter_box( FL_THIN_UP_BOX );
  343.   desktopBtn->color( FL_DARK3 );
  344.   desktopBtn->callback( _desktopCB, this );
  345.   { 
  346.     Flu_Label *l = new Flu_Label( 5, 62, 100, 20, "Desktop" );
  347.     l->labelcolor( FL_WHITE );
  348.     l->align( FL_ALIGN_CENTER );
  349.   }
  351.   Flu_Button *homeBtn = new Flu_Button( 30, 98, 50, 48 );
  352.   homeBtn->box( FL_FLAT_BOX );
  353.   homeBtn->enter_box( FL_THIN_UP_BOX );
  354.   homeBtn->color( FL_DARK3 );
  355.   homeBtn->callback( _homeCB, this );
  356.   {
  357. #ifdef WIN32
  358.     Flu_Label *l = new Flu_Label( 5, 142, 100, 20, "My Computer" );
  359.     homeBtn->image( my_computer );
  360. #else
  361.     Flu_Label *l = new Flu_Label( 5, 142, 100, 20, "Home" );
  362.     homeBtn->image( home );
  363. #endif
  364.     l->labelcolor( FL_WHITE );
  365.     l->align( FL_ALIGN_CENTER );
  366.   }
  368.   Flu_Button *documentsBtn = new Flu_Button( 30, 178, 50, 48 );
  369.   documentsBtn->box( FL_FLAT_BOX );
  370.   documentsBtn->enter_box( FL_THIN_UP_BOX );
  371.   documentsBtn->labelcolor( FL_WHITE );
  372.   documentsBtn->color( FL_DARK3 );
  373.   documentsBtn->callback( _documentsCB, this );
  374.   { 
  375. #ifdef WIN32
  376.     Flu_Label *l = new Flu_Label( 5, 222, 100, 20, "My Documents" );
  377.     documentsBtn->image( &bigdocuments );
  378. #else
  379.     Flu_Label *l = new Flu_Label( 5, 222, 100, 20, "Temporary" );
  380.     documentsBtn->image( &bigtemporary );
  381. #endif
  382.     l->labelcolor( FL_WHITE );
  383.     l->align( FL_ALIGN_CENTER );
  384.   }
  386.   Flu_Button *favoritesBtn = new Flu_Button( 30, 258, 50, 48 );
  387.   favoritesBtn->box( FL_FLAT_BOX );
  388.   favoritesBtn->image( favorites );
  389.   favoritesBtn->enter_box( FL_THIN_UP_BOX );
  390.   favoritesBtn->color( FL_DARK3 );
  391.   favoritesBtn->callback( _favoritesCB, this );
  392.   { 
  393.     Flu_Label *l = new Flu_Label( 5, 302, 100, 20, "Favorites" );
  394.     l->labelcolor( FL_WHITE );
  395.     l->align( FL_ALIGN_CENTER );
  396.   }
  398.   favoritesList = new Fl_Browser( 0, 0, 0, 0 );
  399.   favoritesList->hide();
  401.   {
  402.     Fl_Group* dummy = new Fl_Group( 5, h()-10-61, 100, 1 );
  403.     quickIcons->resizable( dummy );
  404.   }
  405.   quickIcons->end();
  407.   Fl_Group *dummy = new Fl_Group( 110, 0, w()-110, 60 );
  409.   filesystems = new Flu_Combo_Tree( 166, 5, w()-171, 22, "Location:" );
  410.   filesystems->editable( false );
  411.   filesystems->pop_height( 200 );
  412.   filesystems->tree.all_branches_always_open( true );
  413. #ifdef WIN32
  414.   filesystems->tree.show_root( false );
  415. #endif
  416.   filesystems->tree.show_connectors( false );
  417.   filesystems->tree.horizontal_gap( -10 );
  418.   filesystems->tree.show_leaves( false );
  419.   filesystems->callback( _filesystemsCB, this );
  421.   ////////////////////////////////////////////////////////////////
  423.   g = new Fl_Group( 110, 30, w()-110, 30 ); // group enclosing all the buttons at top
  425.   backBtn = new Flu_Button( 285, 33, 25, 25, "@<-" );
  426.   backBtn->labelcolor( fl_rgb_color( 80, 180, 200 ) );
  427.   backBtn->labelsize( 16 );
  428.   backBtn->box( FL_FLAT_BOX );
  429.   backBtn->enter_box( FL_THIN_UP_BOX );
  430.   backBtn->callback( _backCB, this );
  431.   backBtn->tooltip( "Go back one directory in the history" );
  433.   forwardBtn = new Flu_Button( 310, 33, 25, 25, "@->" );
  434.   forwardBtn->labelcolor( fl_rgb_color( 80, 180, 200 ) );
  435.   forwardBtn->labelsize( 16 );
  436.   forwardBtn->box( FL_FLAT_BOX );
  437.   forwardBtn->enter_box( FL_THIN_UP_BOX );
  438.   forwardBtn->callback( _forwardCB, this );
  439.   forwardBtn->tooltip( "Go forward one directory in the history" );
  441.   upDirBtn = new Flu_Button( 335, 33, 25, 25 );
  442.   upDirBtn->image( up_folder_img );
  443.   upDirBtn->box( FL_FLAT_BOX );
  444.   upDirBtn->enter_box( FL_THIN_UP_BOX );
  445.   upDirBtn->callback( upDirCB, this );
  446.   upDirBtn->tooltip( "Go to the parent directory" );
  448.   reloadBtn = new Flu_Button( 360, 33, 25, 25 );
  449.   reloadBtn->image( reload );
  450.   reloadBtn->box( FL_FLAT_BOX );
  451.   reloadBtn->enter_box( FL_THIN_UP_BOX );
  452.   reloadBtn->callback( reloadCB, this );
  453.   reloadBtn->tooltip( "Refresh this directory" );
  455.   {
  456.     Flu_Separator *sep = new Flu_Separator( 385, 32, 10, 28 );
  457.     sep->type( Flu_Separator::VERTICAL );
  458.     sep->box( FL_ENGRAVED_BOX );
  459.   }
  461.   trashBtn = new Flu_Button( 395, 33, 25, 25 );
  462.   trashBtn->image( trash );
  463.   trashBtn->box( FL_FLAT_BOX );
  464.   trashBtn->enter_box( FL_THIN_UP_BOX );
  465.   trashBtn->callback( _trashCB, this );
  466.   trashBtn->tooltip( "Delete file(s)" );
  468.   newDirBtn = new Flu_Button( 420, 33, 25, 25 );
  469.   newDirBtn->image( new_folder );
  470.   newDirBtn->box( FL_FLAT_BOX );
  471.   newDirBtn->enter_box( FL_THIN_UP_BOX );
  472.   newDirBtn->callback( _newFolderCB, this );
  473.   newDirBtn->tooltip( "Create new directory" );
  475.   addFavoriteBtn = new Flu_Button( 445, 33, 25, 25 );
  476.   addFavoriteBtn->image( add_to_favorite_folder );
  477.   addFavoriteBtn->box( FL_FLAT_BOX );
  478.   addFavoriteBtn->enter_box( FL_THIN_UP_BOX );
  479.   addFavoriteBtn->callback( _addToFavoritesCB, this );
  480.   addFavoriteBtn->tooltip( "Add this directory to my favorites" );
  482.   {
  483.     Flu_Separator *sep = new Flu_Separator( 470, 32, 10, 28 );
  484.     sep->type( Flu_Separator::VERTICAL );
  485.     sep->box( FL_ENGRAVED_BOX );
  486.   }
  488.   previewBtn = new Flu_Button( 482, 33, 23, 25 );
  489.   previewBtn->type( FL_TOGGLE_BUTTON );
  490.   previewBtn->image( preview_img );
  491.   previewBtn->callback( _previewCB, this );
  492.   previewBtn->tooltip( "Preview files" );
  494.   {
  495.     Fl_Group *g = new Fl_Group( 511, 33, 81, 25 );
  496.     fileListBtn = new Flu_Button( 511, 33, 25, 25 );
  497.     fileListBtn->type( FL_RADIO_BUTTON );
  498.     fileListBtn->value(1);
  499.     fileListBtn->callback( reloadCB, this );
  500.     fileListBtn->image( file_list_img );
  501.     fileListBtn->tooltip( "List mode" );
  502.     fileListWideBtn = new Flu_Button( 540, 33, 25, 25 );
  503.     fileListWideBtn->type( FL_RADIO_BUTTON );
  504.     fileListWideBtn->callback( reloadCB, this );
  505.     fileListWideBtn->image( file_listwide_img );
  506.     fileListWideBtn->tooltip( "Wide List mode" );
  507.     fileDetailsBtn = new Flu_Button( 569, 33, 25, 25 );
  508.     fileDetailsBtn->type( FL_RADIO_BUTTON );
  509.     fileDetailsBtn->image( fileDetails );
  510.     fileDetailsBtn->callback( reloadCB, this );
  511.     fileDetailsBtn->tooltip( "Detail mode" );
  512.     g->end();
  513.   }
  515.   hiddenFiles = new Fl_Check_Button( 110, 33, 130, 25, "Show Hidden Files" );
  516.   hiddenFiles->callback( reloadCB, this );
  517. #ifdef WIN32
  518.   hiddenFiles->hide();
  519. #endif
  521.   g->resizable( hiddenFiles );
  522.   g->end();
  524.   dummy->resizable( filesystems );
  525.   dummy->end();
  527.   ////////////////////////////////////////////////////////////////
  529.   previewTile = new PreviewTile( 110, 60, w()-110-5, h()-80-40-5, this );
  530.   fileGroup = new Fl_Group( 110, 60, w()-120-5, h()-80-40-5 );
  531.   {
  532.     fileGroup->box( FL_DOWN_FRAME );
  533.     filelist = new FileList( fileGroup->x()+2, fileGroup->y()+2, fileGroup->w()-4, fileGroup->h()-4, this );
  534.     filelist->box( FL_FLAT_BOX );
  535.     filelist->color( FL_WHITE );
  536.     filelist->type( FL_HORIZONTAL );
  537.     filelist->spacing( 4, 1 );
  538.     filelist->scrollbar.linesize( DEFAULT_ENTRY_WIDTH+4 );
  539.     filelist->end();
  541.     fileDetailsGroup = new Fl_Group( fileGroup->x()+2, fileGroup->y()+2, fileGroup->w()-4, fileGroup->h()-4 );
  542.     filecolumns = new FileColumns( fileGroup->x()+2, fileGroup->y()+2, fileGroup->w()-4, 20, this );
  543.     //filecolumns->hide();
  544.     filescroll = new Fl_Scroll( fileGroup->x()+2, fileGroup->y()+22, fileGroup->w()-4, fileGroup->h()-20-4 );
  545.     filescroll->color( FL_WHITE );
  546.     filescroll->scrollbar.linesize( 20 );
  547.     filescroll->box( FL_FLAT_BOX );
  548.     filescroll->type( Fl_Scroll::VERTICAL );
  549.     {
  550.       filedetails = new FileDetails( fileGroup->x()+2, fileGroup->y()+22, fileGroup->w()-4, fileGroup->h()-20-4, this );
  551.       filedetails->end();
  552.     }
  553.     filescroll->end();
  554.     //filescroll->hide();
  555.     fileDetailsGroup->end();
  556.     fileDetailsGroup->resizable( filescroll );
  558.     fileGroup->resizable( filelist );
  559.   }
  560.   fileGroup->end();
  562.   previewGroup = new PreviewGroup( fileGroup->x()+fileGroup->w(), fileGroup->y(), previewTile->w()-fileGroup->w(), fileGroup->h(), this );
  563.   previewGroup->end();
  564.   {
  565.     Fl_Box *b = new Fl_Box( previewTile->x()+250, previewTile->y(), previewTile->w()-350, previewTile->h() );
  566.     previewTile->add_resizable( *b );
  567.   }
  568.   previewTile->end();
  569.   previewTile->position( previewGroup->x(), previewGroup->y(), previewTile->x()+previewTile->w(), previewGroup->y() );
  570.   previewTile->last = previewTile->x()+previewTile->w()-200;
  572.   resizable( previewTile );
  574.   filePattern = new Flu_Combo_List( 70, h()-30, w()-70-85-10, 25, "File types:" );
  575.   filePattern->editable( false );
  576.   filePattern->callback( reloadCB, this );
  577.   filePattern->pop_height( 200 );
  579.   ok.callback( _okCB, this );
  580.   cancel.callback( _cancelCB, this );
  582.   {
  583.     g = new Fl_Group( 0, h()-60, w(), 30 );
  584.     g->end();
  585.     g->add( filename );
  586.     g->add( ok );
  587.     g->resizable( filename );
  588.     g = new Fl_Group( 0, h()-30, w(), 30 );
  589.     g->end();
  590.     g->add( filePattern );
  591.     g->add( cancel );
  592.     g->resizable( filePattern );
  593.   }
  595.   end();
  597.   FL_NORMAL_SIZE = oldNormalSize;
  599.   char buf[1024];
  601.   // determine the user's home area for loading/storing favorites and transient config info
  602. #ifdef WIN32
  603.   {
  604.     LPTSTR lpszSystemInfo;          // pointer to system information string 
  605.     DWORD cchBuff = 256;            // size of user name
  606.     TCHAR tchBuffer[UNLEN + 1];     // buffer for expanded string
  608.     lpszSystemInfo = tchBuffer;
  610.     // Get the user name.
  611.     GetUserName(lpszSystemInfo, &cchBuff);
  612.     userHome = "C:/Documents and Settings/";
  613.     userHome += lpszSystemInfo;
  614.     userHome += "/";
  615.   }
  616. #else
  617.   fl_filename_expand( buf, 1024, "~/" );
  618.   userHome = buf;
  619. #endif
  620.   configFilename = userHome + ".Flu_File_Chooser.favorites";
  622.   // try to load the favorites
  623.   {
  624.     FILE *f = fopen( configFilename.c_str(), "r" );
  625.     //printf( "load: %s %Xn", buf, f );
  626.     if( f )
  627.       {
  628. buf[0] = '';
  629. while( !feof(f) )
  630.   {
  631.     fgets( buf, 1024, f );
  632.     char *newline = strrchr( buf, 'n' );
  633.     if( newline )
  634.       *newline = '';
  635.     if( strlen( buf ) > 0 )
  636.       {
  637. // eliminate duplicates
  638. bool duplicate = false;
  639. for( int i = 1; i <= favoritesList->size(); i++ )
  640.   {
  641.     if( streq( buf, favoritesList->text(i) ) )
  642.       {
  643. duplicate = true;
  644. break;
  645.       }
  646.   }
  647. if( !duplicate )
  648.   favoritesList->add( buf );
  649.       }
  650.   }
  651. fclose( f );
  652.       }
  653.   }
  655.   if( !imgTxtPreview )
  656.     {
  657.       imgTxtPreview = new ImgTxtPreview();
  658.       add_preview_handler( imgTxtPreview );
  659.     }
  661.   pattern( pat );
  662.   default_file_icon( &default_file );
  663.   cd( NULL ); // prime with the current directory
  664.   clear_history();
  665.   cd( pathname );
  666. }
  668. Flu_File_Chooser :: ~Flu_File_Chooser()
  669. {
  670.   Fl::remove_timeout( Entry::_editCB );
  672.   filelist->clear();
  673.   filedetails->clear();
  675.   clear_history();
  676. }
  678. void Flu_File_Chooser :: cancelCB()
  679. { 
  680.   filename.value("");
  681.   filename.position( filename.size(), filename.size() );
  682.   unselect_all();
  683.   hide();
  684. }
  686. void Flu_File_Chooser :: pattern( const char *p )
  687. {
  688.   // just like in Fl_File_Chooser, we accept tab, |, and ; delimited strings like this:
  689.   // "Description (patterns)" or just "patterns" where patterns is 
  690.   // of the form *.xxx or *.{xxx,yyy,zzz}}
  692.   rawPattern = p;
  694.   // clear out the old
  695.   filePattern->list.clear();
  696.   filePattern->input.value( "" );
  697.   patterns.clear();
  699.   if( p == 0 )
  700.     p = "*";
  701.   else if( p[0] == '' )
  702.     p = "*";
  704.   FluSimpleString pat = p, pattern;
  706.   bool addedAll = false;
  707.   const char *next = strtok( (char*)pat.c_str(), "t|;" );
  708.   const char *start;
  709.   while( next )
  710.     {
  711.       //printf( "next pattern = %sn", next );
  713.       if( next[0] == '' )
  714. break;
  716.       // eat whitespace
  717.       while( isspace( *next ) )
  718. next++;
  720.       // degenerate check
  721.       if( strcmp( next, "*" ) == 0 )
  722. {
  723.   addedAll = true;
  724.   filePattern->list.add( "All Files (*)" );
  725.   patterns.add( "*" );
  726.   next = strtok( NULL, "t|;" );
  727.   continue;
  728. }
  730.       // extract the patterns from the substring
  731.       if( next[0] != '*' ) // starts with description
  732. {
  733.   // the pattern starts after the first '('
  734.   start = strchr( next, '(' );
  735.   if( !start ) // error: couldn't find the '('
  736.     {
  737.       next = strtok( NULL, "t|;" );
  738.       continue;
  739.     }
  740.   start++; // skip the '('
  741. }
  742.       else
  743. start = next;
  745.       if( start[0] != '*' )
  746. {
  747.   next = strtok( NULL, "t|;" );
  748.   continue;
  749. }
  750.       start++; // skip the '*'
  752.       if( start[0] != '.' )
  753. {
  754.   next = strtok( NULL, "t|;" );
  755.   continue;
  756. }
  757.       start++; // skip the '.'
  759.       if( start[0] == '{' )
  760. {
  761.   // the pattern is between '{' and '}'
  762.   pattern = start+1;
  763. }
  764.       else
  765. pattern = start;
  767.       // remove the last '}'
  768.       int brace = pattern.find( '}' );
  769.       if( brace != -1 )
  770. pattern[brace] = '';
  772.       // remove the last ')'
  773.       int paren = pattern.find( ')' );
  774.       if( paren != -1 )
  775. pattern[paren] = '';
  777.       //printf( "patterns: %sn", pattern.c_str() );
  778.       if( pattern.size() )
  779. {
  780.   // add the whole string to the list
  781.   filePattern->list.add( next );
  782.   patterns.add( pattern );
  783. }
  785.       // advance to the pattern token
  786.       next = strtok( NULL, "t|;" );
  787.    }
  789.   // add all files
  790.   if( !addedAll )
  791.     {
  792.       filePattern->list.add( "All Files (*)" );
  793.       patterns.add( "*" );
  794.     }
  796.   // choose the first added item
  797.   filePattern->value( filePattern->list.text(1) );
  798. }
  800. int Flu_File_Chooser :: handle( int event )
  801. {
  802.   if( Fl_Double_Window::handle( event ) )
  803.     return 1;
  804.   else if( event == FL_KEYDOWN && Fl::event_key(FL_Escape) )
  805.     {
  806.       cancel.do_callback();
  807.       return 1;
  808.     }
  809.   else if( event == FL_KEYDOWN && Fl::event_key('a') && Fl::event_state(FL_CTRL) )
  810.     {
  811.       select_all();
  812.       return 1;
  813.     }
  814.   else
  815.     return 0;
  816. }
  818. void Flu_File_Chooser :: newFolderCB()
  819. {
  820.   // start with the name "New Folder". while the name exists, keep appending a number (1..2..etc)
  821.   FluSimpleString newName = "New Folder", path = currentDir + newName;
  822.   int count = 1;
  823.   int i;
  824.   for(;;)
  825.     {
  826.       bool found = false;
  827.       // see if any entry already has that name
  828.       Fl_Group *g = getEntryGroup();
  829.       for( i = 0; i < g->children(); i++ )
  830. {
  831.   if( ((Entry*)g->child(i))->filename == newName )
  832.     {
  833.       found = true;
  834.       break;
  835.     }
  836. }
  838.       // since an entry already exists, change the name and try again
  839.       if( found )
  840. {
  841.   char buf[16];
  842.   sprintf( buf, "%d", count++ );
  843.   newName = "New Folder" + FluSimpleString(buf);
  844.   path = currentDir + newName;
  845. }
  846.       else
  847. break;
  848.     }
  850.   // try to create the folder
  851. #if ( defined WIN32 || defined MINGW ) && !defined CYGWIN
  852.   if( mkdir( path.c_str() ) != 0 )
  853. #else
  854.   if( mkdir( path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) != 0 )
  855. #endif
  856.     {
  857.       fl_alert( "Could not create directory '%s'. You may not have permission to perform this operation.",
  858. newName.c_str() );
  859.       return;
  860.     }  
  862.   // create a new entry with the name of the new folder. add to either the list or the details
  863.   Entry *entry = new Entry( newName.c_str(), ENTRY_DIR, fileDetailsBtn->value(), this );
  864.   if( !fileDetailsBtn->value() )
  865.     filelist->add( *entry );
  866.   else
  867.     filedetails->add( *entry );
  869.   // switch that entry to input mode and scroll the browser to it
  870.   entry->editCB();
  871.   /*
  872.   entry->editMode = 2;
  873.   entry->value( entry->filename.c_str() );
  874.   entry->take_focus();
  875.   entry->position( 0, entry->filename.size() );  
  876.   entry->redraw();
  877.   */
  878.   if( !fileDetailsBtn->value() )
  879.     filelist->scroll_to( entry );
  880.   else
  881.     filedetails->scroll_to( entry );
  882. }
  884. void Flu_File_Chooser :: recursiveScan( const char *dir, StringVector *files )
  885. {
  886.   dirent **e;
  887.   char *name;
  888.   FluSimpleString fullpath;
  889.   int num = fl_filename_list( dir, &e );
  890.   for( int i = 0; i < num; i++ )
  891.     {
  892.       name = e[i]->d_name;
  894.       // if 'name' ends in '/' or '', remove it
  895.       if( name[strlen(name)-1] == '/' || name[strlen(name)-1] == '\' )
  896. name[strlen(name)-1] = '';
  898.       // ignore the "." and ".." names
  899.       if( strcmp( name, "." ) == 0 || strcmp( name, ".." ) == 0 )
  900. continue;
  902.       // file or directory?
  903.       fullpath = dir;
  904.       fullpath += "/";
  905.       fullpath += name;
  906.       if( fl_filename_isdir( fullpath.c_str() ) != 0 )
  907. recursiveScan( fullpath.c_str(), files );
  909.       files->add( fullpath );
  910.     }
  911.   files->add( dir );
  912. }
  914. void Flu_File_Chooser :: trashCB( bool recycle )
  915. {
  916.   // linux doesn't have a recycle bin
  917. #ifndef WIN32
  918.   recycle = false;
  919. #endif
  921.   bool inFavorites = ( currentDir == FAVORITES_UNIQUE_STRING );
  922.   if( inFavorites )
  923.     recycle = false;
  925.   // see how many files are selected
  926.   FluSimpleString name;
  927.   int selected = 0;
  928.   int i;
  929.   const char *first = "";
  930.   Fl_Group *g = getEntryGroup();
  931.   for( i = 0; i < g->children(); i++ )
  932.     {
  933.       if( ((Entry*)g->child(i))->selected )
  934. {
  935.   if( selected == 0 )
  936.     first = ((Entry*)g->child(i))->filename.c_str();
  937.   selected++;
  938. }
  939.     }
  941.    if( selected )
  942.      {
  943.        if( selected == 1 )
  944.  {
  945.    if( recycle )
  946.      {
  947.        if( !fl_ask( "Really send '%s' to the Recycle Bin?", first ) )
  948.  return;
  949.      }
  950.    else
  951.      {
  952.        if( !fl_ask( "Really delete '%s'?", first ) )
  953.  return;
  954.      }
  955.  }
  956.        else
  957.  {
  958.    if( recycle )
  959.      {
  960.        if( !fl_ask( "Really send these %d files to the Recycle Bin?", selected ) )
  961.  return;
  962.      }
  963.    else
  964.      {
  965.        if( !fl_ask( "Really delete these %d files?", selected ) )
  966.  return;
  967.      }
  968.  }
  970.        if( inFavorites )
  971.  {
  972.    for( i = 0; i < g->children(); )
  973.      {
  974.        Entry *e = ((Entry*)g->child(i));
  975.        if( e->selected )
  976.  {
  977.    favoritesList->remove(i+1);
  978.    g->remove( *e );
  979.    delete e;
  980.  }
  981.        else 
  982.  i++;
  983.      }
  984.    // save the favorites
  985.    FILE *f = fopen( configFilename.c_str(), "w" );
  986.    if( f )
  987.      {
  988.        for( i = 1; i <= favoritesList->size(); i++ )
  989.  fprintf( f, "%sn", favoritesList->text(i) );
  990.        fclose( f );
  991.      }
  992.    cd( FAVORITES_UNIQUE_STRING );
  993.    return;
  994.  }
  996. #ifdef WIN32
  997.        SHFILEOPSTRUCT fileop;
  998.        memset( &fileop, 0, sizeof(SHFILEOPSTRUCT) );
  999.        fileop.fFlags = FOF_SILENT | FOF_NOERRORUI | FOF_NOCONFIRMATION;
  1000.        if( recycle )
  1001.  fileop.fFlags |= FOF_ALLOWUNDO;
  1002.        fileop.wFunc = FO_DELETE;
  1003.        fileop.pTo = NULL;
  1004. #endif
  1006.        for( i = 0; i < g->children(); i++ )
  1007.  {
  1008.    if( ((Entry*)g->child(i))->selected )
  1009.      {
  1010.        int result = 0;
  1012.        name = currentDir + ((Entry*)g->child(i))->filename;
  1014.        // if directory, recursively remove
  1015.        if( ((Entry*)g->child(i))->type == ENTRY_DIR )
  1016.  {
  1017.    // if we are recycling in windows, then the recursive part happens automatically
  1018. #ifdef WIN32
  1019.    if( !recycle )
  1020. #endif
  1021.      {
  1022.        Fl_Group::current(0);
  1023.        Fl_Window *win = new Fl_Window( 200, 100, "Notice" );
  1024.        Flu_Label *label = new Flu_Label( 30, 30, 150, 30, "Preparing to delete..." );
  1025.        win->end();
  1026.        win->show();
  1027.        Fl::check();
  1028.        // recursively build a list of all files that will be deleted
  1029.        StringVector files;
  1030.        recursiveScan( name.c_str(), &files );
  1031.        // delete all the files
  1032.        label->label( "Deleting files..." );
  1033.        for( unsigned int i = 0; i < files.size(); i++ )
  1034.  {
  1035.    //printf( "%sn", files[i].c_str() );
  1036.    if( ::remove( files[i].c_str() ) != 0 )
  1037.      {
  1038.        win->hide();
  1039.        delete win;
  1040.        cd( "./" );
  1041.        return;
  1042.      }
  1043.  }
  1044.        win->hide();
  1045.        delete win;
  1046.        Fl::check();
  1047.        continue;
  1048.      }
  1049.  }
  1051. #ifdef WIN32
  1052.        // this moves files to the recycle bin, depending on the value of 'recycle'
  1053.        {
  1054.  int len = name.size();
  1055.  char *buf = (char*)malloc( len+2 );
  1056.  strcpy( buf, name.c_str() );
  1057.  buf[len+1] = ''; // have to have 2 '' at the end
  1058.  fileop.pFrom = buf;
  1059.  result = SHFileOperation( &fileop );
  1060.  free( buf );
  1061.        }
  1062. #else
  1063.        result = ::remove( name.c_str() );
  1064. #endif
  1066.        // if remove fails, report an error
  1067.        if( result != 0 )
  1068.  {
  1069.    fl_alert( "An error ocurred while trying to delete '%s'.", name.c_str() );
  1070.    cd( "./" );
  1071.    return;
  1072.  }
  1073.      }
  1074.  }
  1076.        // refresh this directory
  1077.        cd( "./" );
  1078.     }
  1079. }
  1081. void Flu_File_Chooser :: filesystemsCB( const char *path )
  1082. {
  1083.   //printf( "filesystems: %sn", path );
  1084. #ifdef WIN32
  1085.   FluSimpleString p = path;
  1086.   if( p == "/Favorites/" )
  1087.     favoritesCB();
  1088.   else if( p == "/Desktop/My Computer/" )
  1089.     myComputerCB();
  1090.   else if( p == "/Desktop/My Documents/" )
  1091.     documentsCB();
  1092.   else if( p == "/Desktop/" )
  1093.     desktopCB();
  1094.   // if the path leads off with "/Desktop/My Computer", then strip that part off and cd
  1095.   // to the remaining
  1096.   else if( strstr( path, "/Desktop/My Computer/" ) == path )
  1097.     {
  1098.       // seach for '(' and if present, extract the drive name and cd to it
  1099.       char *paren = strrchr( path, '(' );
  1100.       if( paren )
  1101. {
  1102.   char drive[] = "A:/";
  1103.   drive[0] = paren[1];
  1104.   cd( drive );
  1105. }
  1106.       else
  1107. {
  1108.   cd( path+21 );
  1109. }
  1110.     }
  1111. #else
  1112.   cd( path );
  1113. #endif
  1114. }
  1116. void Flu_File_Chooser :: favoritesCB()
  1117. { 
  1118.   cd( FAVORITES_UNIQUE_STRING );
  1119. }
  1121. void Flu_File_Chooser :: myComputerCB()
  1122. { 
  1123.   cd( "/" );
  1124. }
  1126. void Flu_File_Chooser :: documentsCB()
  1127. {
  1128. #ifdef WIN32
  1129.   FluSimpleString s = userHome + "My Documents";
  1130.   cd( s.c_str() );
  1131. #else
  1132.   cd( "/tmp/" );
  1133. #endif
  1134. }
  1136. Flu_File_Chooser :: FileInput :: FileInput( int x, int y, int w, int h, const char *l, Flu_File_Chooser *c )
  1137.   : Fl_Input( x, y, w, h, l )
  1138. {
  1139.   chooser = c;
  1140. }
  1142. Flu_File_Chooser :: FileInput :: ~FileInput()
  1143. {
  1144. }
  1146. int Flu_File_Chooser :: FileInput :: handle( int event )
  1147. {
  1148.   if( event == FL_KEYDOWN )
  1149.     {
  1150.       if( Fl::event_key(FL_Tab) )
  1151. {
  1152.   chooser->filenameTabCallback = true;
  1153.   FluSimpleString v(value());
  1154. #ifdef WIN32
  1155.   // turn "c:" into "c:"
  1156.   if( v.size() >= 2 )
  1157.     if( v[1] == ':' && v[2] == '' )
  1158.       {
  1159. v += "/";
  1160. value( v.c_str() );
  1161. position( size(), size() );
  1162.       }
  1163. #endif
  1164.   chooser->delayedCd = v + "*";
  1165.   Fl::add_timeout( 0.0f, Flu_File_Chooser::delayedCdCB, chooser );
  1166.   return 1;
  1167. }
  1168.       else if( Fl::event_key(FL_Left) )
  1169. {
  1170.   if( Fl_Input::position() == 0 )
  1171.     return 1;
  1172.   else
  1173.     return Fl_Input::handle( event );
  1174. }
  1175.       else if( Fl::event_key(FL_Right) )
  1176. {
  1177.   if( Fl_Input::position() == (int)strlen(Fl_Input::value()) )
  1178.     return 1;
  1179.   else
  1180.     return Fl_Input::handle( event );
  1181. }
  1182.       else if( Fl::event_key(FL_Up) || Fl::event_key(FL_Down) )
  1183. {
  1184.   chooser->getEntryContainer()->take_focus();
  1185.   if( !chooser->lastSelected )
  1186.     {
  1187.       if( chooser->getEntryGroup()->children() )
  1188. {
  1189.   Flu_File_Chooser::Entry *e = (Flu_File_Chooser::Entry*)chooser->getEntryGroup()->child(0);
  1190.   e->selected = true;
  1191.   chooser->lastSelected = e;
  1192.   e->redraw();
  1193. }
  1194.     }
  1195.   return chooser->getEntryContainer()->handle( event );
  1196. }
  1197.     }
  1199.   return Fl_Input::handle( event );
  1200. }
  1202. Flu_File_Chooser :: PreviewTile :: PreviewTile( int x, int y, int w, int h, Flu_File_Chooser *c )
  1203.    : Fl_Tile( x, y, w, h )
  1204. {
  1205.   chooser = c;
  1206. }
  1208. int Flu_File_Chooser :: PreviewTile :: handle( int event )
  1209. {
  1210.   // if we're not in preview mode, then the user isn't allowed to resize the tile
  1211.   if( !chooser->previewBtn->value() )
  1212.     return Fl_Group::handle( event );
  1213.   if( event == FL_DRAG )
  1214.     {
  1215.       // the user is probably dragging to resize the columns
  1216.       // update the sizes for each entry
  1217.       chooser->updateEntrySizes();
  1218.       chooser->redraw();
  1219.     }
  1220.   return Fl_Tile::handle(event);
  1221. }
  1223. Flu_File_Chooser :: PreviewWidgetBase :: PreviewWidgetBase()
  1224.   : Fl_Group( 0, 0, 0, 0 )
  1225. {
  1226. }
  1228. Flu_File_Chooser :: PreviewWidgetBase :: ~PreviewWidgetBase()
  1229. {
  1230. }
  1232. Flu_File_Chooser :: PreviewGroup :: PreviewGroup( int x, int y, int w, int h, Flu_File_Chooser *c )
  1233.   : Fl_Group( x, y, w, h )
  1234. {
  1235.   box( FL_DOWN_BOX );
  1236.   align( FL_ALIGN_CENTER | FL_ALIGN_CLIP );
  1237.   labelsize( 60 );
  1238.   labelfont( FL_HELVETICA );
  1239.   chooser = c;
  1240.   handled = 0;
  1241. }
  1243. void Flu_File_Chooser :: PreviewGroup :: draw()
  1244. {
  1245.   if( !chooser->previewBtn->value() )
  1246.     return;
  1248.   if( file.size() == 0 )
  1249.     return;
  1251.   FILE *f = fopen( file.c_str(), "rb" );
  1252.   if( !f )
  1253.     {
  1254.       label( "" );
  1255.       Fl_Group::draw();
  1256.       return;
  1257.     }
  1258.   fclose( f );
  1260.   if( lastFile != file )
  1261.     {
  1262.       lastFile = file;
  1264.       handled = 0;
  1265.       PreviewWidgetBase *next;
  1266.       for( int i = chooser->previewHandlers.size()-1; i >= 0; i-- )
  1267. {
  1268.   next = chooser->previewHandlers[i];
  1269.   next->hide();
  1270.   if( !handled )
  1271.     {
  1272.       Fl_Group *p = next->parent();
  1273.       Fl_Group::add( next );
  1274.       if( next->preview( file.c_str() ) != 0 )
  1275. {
  1276.   next->show();
  1277.   handled = next;
  1278. }
  1279.       Fl_Group::remove( *next );
  1280.       if( p )
  1281. p->add( next );
  1282.     }
  1283. }
  1284.     }
  1286.   if( handled == 0 )
  1287.     {
  1288.       label( "?" );
  1289.       Fl_Group::draw();
  1290.     }
  1291.   else
  1292.     {
  1293.       label( "" );
  1294.       Fl_Group *p = handled->parent();
  1295.       Fl_Group::add( handled );
  1296.       handled->resize( x()+Fl::box_dx(box()), y()+Fl::box_dy(box()),
  1297.        w()-Fl::box_dw(box()), h()-Fl::box_dh(box()) );
  1298.       Fl_Group::draw();
  1299.       Fl_Group::remove( *handled );
  1300.       if( p )
  1301. p->add( handled );
  1302.     }
  1303. }
  1305. // adapted from Fl_File_Chooser2.cxx : update_preview()
  1306. int Flu_File_Chooser :: ImgTxtPreview ::  preview( const char *filename )
  1307. {
  1308.   Fl_Shared_Image *img, // New image
  1309. *oldimg; // Old image
  1310.   int pbw, pbh; // Width and height of preview box
  1311.   int w, h; // Width and height of preview image
  1313.   window()->cursor( FL_CURSOR_WAIT );
  1314.   Fl::check();
  1316.   img = Fl_Shared_Image::get( filename );
  1317.   if( img )
  1318.     {
  1319.       window()->cursor( FL_CURSOR_DEFAULT );
  1320.       Fl::check();
  1321.     }
  1323.   oldimg = (Fl_Shared_Image*)image();
  1324.   if( oldimg )
  1325.     oldimg->release();
  1326.   image(0);
  1328.   if( !img )
  1329.     {
  1330.       // Try reading the first 1k of data for a label...
  1331.       FILE *f = fopen( filename, "rb" );
  1332.       if( f )
  1333. {
  1334.   int bytes = fread( previewTxt, 1, sizeof(previewTxt) - 1, f );
  1335.   previewTxt[bytes] = '';
  1336.   fclose( f );
  1337. } 
  1338.       else
  1339. return 0;
  1341.       window()->cursor( FL_CURSOR_DEFAULT );
  1342.       Fl::check();
  1344.       // Scan the buffer for printable chars...
  1345.       unsigned char *ptr;
  1346.       for( ptr = previewTxt; *ptr && (isprint(*ptr) || isspace(*ptr)); ptr++ ) {}
  1348.       if( *ptr || ptr == previewTxt )
  1349. {
  1350.   // Non-printable file - can't handle
  1351.   return 0;
  1352. } 
  1353.       else
  1354. {
  1355.   // Show the first 1k of text...
  1356.   label( (const char*)previewTxt );
  1357.   align((Fl_Align)(FL_ALIGN_CLIP | FL_ALIGN_INSIDE | FL_ALIGN_LEFT | FL_ALIGN_TOP));
  1358.   labelsize( 12 );
  1359.   labelfont( FL_COURIER );
  1360. }
  1361.     }
  1362.   else if( img->w() > 0 && img->h() > 0 )
  1363.     {
  1365.       pbw = this->w() - 20;
  1366.       pbh = this->h() - 20;
  1367.       pbw = (pbw < 10) ? 10 : pbw;
  1368.       pbh = (pbh < 10) ? 10 : pbh;
  1370.       if( img->w() > pbw || img->h() > pbh )
  1371. {
  1372.   w = pbw;
  1373.   h = int(float(w*img->h()) / float(img->w()));
  1375.   if( h > pbh )
  1376.     {
  1377.       h = pbh;
  1378.       w = int(float(h*img->w()) / float(img->h()));
  1379.     }
  1381.   oldimg = (Fl_Shared_Image *)img->copy(w, h);
  1382.   image((Fl_Image *)oldimg);
  1384.   img->release();
  1385. }
  1386.       else
  1387. image((Fl_Image *)img);
  1389.       align( FL_ALIGN_CLIP );
  1390.       label(0);
  1391.     }
  1393.   redraw();
  1395.   return 1;
  1396. }
  1398. void Flu_File_Chooser :: previewCB()
  1399. {
  1400.   if( previewBtn->value() )
  1401.     {
  1402.       fileGroup->resize( fileGroup->x(), fileGroup->y(), previewTile->last-fileGroup->x(), fileGroup->h() );
  1403.       previewGroup->resize( previewTile->last, previewGroup->y(), previewTile->w()-fileGroup->w(), previewGroup->h() );
  1404.       previewGroup->show();
  1405.     }
  1406.   else
  1407.     {
  1408.       previewTile->last = previewGroup->x();
  1409.       fileGroup->resize( fileGroup->x(), fileGroup->y(), previewTile->w(), fileGroup->h() );
  1410.       previewGroup->resize( previewTile->x()+previewTile->w(), previewGroup->y(), 0, previewGroup->h() );
  1411.       previewGroup->hide();
  1412.     }
  1413.   previewGroup->redraw();
  1414.   previewTile->init_sizes();
  1415.   //filescroll->parent()->init_sizes();
  1416.   fileDetailsGroup->parent()->init_sizes();
  1417.   updateEntrySizes();
  1418.   redraw();
  1419. }
  1421. void Flu_File_Chooser :: sortCB( Fl_Widget *w )
  1422. {
  1423.   // if the sort method is already selected, toggle the REVERSE bit
  1424.   if( w == detailNameBtn )
  1425.     {
  1426.       if( sortMethod & SORT_NAME )
  1427. sortMethod ^= SORT_REVERSE;
  1428.       else
  1429. sortMethod = SORT_NAME;
  1430.     }
  1431.   else if( w == detailSizeBtn )
  1432.     {
  1433.       if( sortMethod & SORT_SIZE )
  1434. sortMethod ^= SORT_REVERSE;
  1435.       else
  1436. sortMethod = SORT_SIZE;
  1437.     }
  1438.   else if( w == detailDateBtn )
  1439.     {
  1440.       if( sortMethod & SORT_DATE )
  1441. sortMethod ^= SORT_REVERSE;
  1442.       else
  1443. sortMethod = SORT_DATE;
  1444.     }
  1445.   else if( w == detailTypeBtn )
  1446.     {
  1447.       if( sortMethod & SORT_TYPE )
  1448. sortMethod ^= SORT_REVERSE;
  1449.       else
  1450. sortMethod = SORT_TYPE;
  1451.     }
  1453.   bool reverse = ( sortMethod & SORT_REVERSE );
  1454.   detailNameBtn->label( "Name" );
  1455.   detailSizeBtn->label( "Size" );
  1456.   detailDateBtn->label( "Date" );
  1457.   detailTypeBtn->label( "Type" );
  1458.   switch( sortMethod & ~SORT_REVERSE )
  1459.     {
  1460.     case SORT_NAME: detailNameBtn->label( reverse?"@-12DnArrow Name":"@-18UpArrow Name" ); break;
  1461.     case SORT_SIZE: detailSizeBtn->label( reverse?"@-12DnArrow Size":"@-18UpArrow Size" ); break;
  1462.     case SORT_DATE: detailDateBtn->label( reverse?"@-12DnArrow Date":"@-18UpArrow Date" ); break;
  1463.     case SORT_TYPE: detailTypeBtn->label( reverse?"@-12DnArrow Type":"@-18UpArrow Type" ); break;
  1464.     }
  1466.   filelist->sort();
  1467.   filedetails->sort();
  1468. }
  1470. Flu_File_Chooser :: CBTile :: CBTile( int x, int y, int w, int h, Flu_File_Chooser *c )
  1471.    : Fl_Tile( x, y, w, h )
  1472. {
  1473.   chooser = c;
  1474. }
  1476. int Flu_File_Chooser :: CBTile :: handle( int event )
  1477. {
  1478.   if( event == FL_DRAG )
  1479.     {
  1480.       // the user is probably dragging to resize the columns
  1481.       // update the sizes for each entry
  1482.       chooser->updateEntrySizes();
  1483.       chooser->redraw();
  1484.     }
  1485.   return Fl_Tile::handle(event);
  1486. }
  1488. Flu_File_Chooser :: FileColumns :: FileColumns( int x, int y, int w, int h, Flu_File_Chooser *c )
  1489.   : Fl_Tile( x, y, w, h )
  1490. {
  1491.   chooser = c;
  1493.   W1 = int(float(w)*0.35f);
  1494.   W2 = int(float(w)*0.20f);
  1495.   W3 = int(float(w)*0.15f);
  1496.   W4 = w-W1-W2-W3;
  1498.   Fl_Box *box = new Fl_Box( x+50, y, w-200, h );
  1499.   add_resizable( *box );
  1500.   c->detailNameBtn = new Flu_Button( x, y, W1, h, "Name" );
  1501.   c->detailNameBtn->align( FL_ALIGN_CLIP );
  1502.   c->detailNameBtn->callback( Flu_File_Chooser::_sortCB, c );
  1503.   {
  1504.     CBTile *tile = new CBTile( x+W1, y, W2+W3+W4, h, c );
  1505.     Fl_Box *box = new Fl_Box( tile->x()+50, tile->y(), tile->w()-150, tile->h() );
  1506.     tile->add_resizable( *box );
  1507.     c->detailTypeBtn = new Flu_Button( x+W1, y, W2, h, "Type" );
  1508.     c->detailTypeBtn->align( FL_ALIGN_CLIP );
  1509.     c->detailTypeBtn->callback( Flu_File_Chooser::_sortCB, c );
  1510.     {
  1511.       CBTile *tile = new CBTile( x+W1+W2, y, W3+W4, h, c );
  1512.       Fl_Box *box = new Fl_Box( tile->x()+50, tile->y(), tile->w()-100, tile->h() );
  1513.       tile->add_resizable( *box );
  1514.       c->detailSizeBtn = new Flu_Button( x+W1+W2, y, W3, h, "Size" );
  1515.       c->detailSizeBtn->align( FL_ALIGN_CLIP );
  1516.       c->detailSizeBtn->callback( Flu_File_Chooser::_sortCB, c );
  1517.       c->detailDateBtn = new Flu_Button( x+W1+W2+W3, y, W4, h, "Date" );
  1518.       c->detailDateBtn->align( FL_ALIGN_CLIP );
  1519.       c->detailDateBtn->callback( Flu_File_Chooser::_sortCB, c );
  1520.       tile->end();
  1521.     }
  1522.     tile->end();
  1523.   }
  1524.   end();
  1525. }
  1527. Flu_File_Chooser :: FileColumns :: ~FileColumns()
  1528. {
  1529. }
  1531. void Flu_File_Chooser :: FileColumns :: resize( int x, int y, int w, int h )
  1532. {
  1533.   // TODO resize the buttons/tiles according to their stored relative sizes
  1534.   Fl_Tile::resize( x, y, w, h );
  1535. }
  1537. int Flu_File_Chooser :: FileColumns :: handle( int event )
  1538. {
  1539.   if( event == FL_DRAG )
  1540.     {
  1541.       // the user is probably dragging to resize the columns
  1542.       // update the sizes for each entry
  1543.       chooser->updateEntrySizes();
  1544.       chooser->redraw();
  1545.     }
  1546.   return Fl_Tile::handle(event);
  1547. }
  1549. void Flu_File_Chooser :: filenameCB()
  1550. {
  1551.   filenameEnterCallback = true;
  1552.   cd( filename.value() );
  1553. }
  1555. inline bool _isProbablyAPattern( const char *s )
  1556. {
  1557.   return( strpbrk( s, "*;|[]?" ) != NULL );
  1558. }
  1560. void Flu_File_Chooser :: okCB()
  1561. {
  1562.   // only hide if the filename is not blank or the user is choosing directories,
  1563.   // in which case use the current directory
  1565.   //printf( "%sn", filename.value() );
  1567.   if( selectionType & DIRECTORY )
  1568.     {
  1569. #ifdef WIN32
  1570.       if( strcmp( filename.value(), "My Computer" ) == 0 )
  1571. return;
  1572. #endif
  1573.       if( !(selectionType & MULTI ))
  1574. {
  1575.   if( strlen( filename.value() ) != 0 )
  1576.     cd( filename.value() );
  1577.   filename.value( currentDir.c_str() );
  1578.   filename.position( filename.size(), filename.size() );
  1579. }
  1580.       hide();
  1581.     }
  1582.   else
  1583.     {
  1584.       if( strlen( filename.value() ) != 0 )
  1585. {
  1586.   if( _isProbablyAPattern( filename.value() ) )
  1587.     {
  1588.       cd( filename.value() );
  1589.       return;
  1590.     }
  1591. #ifdef WIN32
  1592.   if( filename.value()[1] == ':' )
  1593. #else
  1594.   if( filename.value()[0] == '/' )
  1595. #endif
  1596.     if( fl_filename_isdir( filename.value() ) )
  1597.       {
  1598. filename.value( "" );
  1599. return;
  1600.       }
  1601.   // prepend the path
  1602.   FluSimpleString path = currentDir + filename.value();
  1603.   filename.value( path.c_str() );
  1604.   filename.position( filename.size(), filename.size() );
  1605.   hide();
  1606. }
  1607.     }
  1608. }
  1610. void Flu_File_Chooser :: homeCB()
  1611. {
  1612. #ifdef WIN32
  1613.   cd( "/" );
  1614. #else
  1615.   cd( userHome.c_str() );
  1616. #endif
  1617. }
  1619. void Flu_File_Chooser :: desktopCB()
  1620. {
  1621. #ifdef WIN32
  1622.   FluSimpleString s = "/Desktop";
  1623. #else
  1624.   FluSimpleString s = userHome + "Desktop";
  1625. #endif
  1626.   cd( s.c_str() );
  1627. }
  1629. #define QSCANL( field ) 
  1630.       while( ((Flu_File_Chooser::Entry*)array[left])->field < 
  1631.              ((Flu_File_Chooser::Entry*)array[pivot])->field ) left++
  1632. #define QSCANR( field ) 
  1633.       while( ((Flu_File_Chooser::Entry*)array[right])->field > 
  1634.      ((Flu_File_Chooser::Entry*)array[pivot])->field ) right--
  1636. #define RQSCANL( field ) 
  1637.       while( ((Flu_File_Chooser::Entry*)array[left])->field > 
  1638.              ((Flu_File_Chooser::Entry*)array[pivot])->field ) left++
  1639. #define RQSCANR( field ) 
  1640.       while( ((Flu_File_Chooser::Entry*)array[right])->field < 
  1641.      ((Flu_File_Chooser::Entry*)array[pivot])->field ) right--
  1643. #define CASE_QSCANL( field ) 
  1644.       while( casecompare( ((Flu_File_Chooser::Entry*)array[left])->field, 
  1645.              ((Flu_File_Chooser::Entry*)array[pivot])->field ) < 0 ) left++
  1646. #define CASE_QSCANR( field ) 
  1647.       while( casecompare( ((Flu_File_Chooser::Entry*)array[right])->field, 
  1648.      ((Flu_File_Chooser::Entry*)array[pivot])->field ) > 0 ) right--
  1650. #define CASE_RQSCANL( field ) 
  1651.       while( casecompare( ((Flu_File_Chooser::Entry*)array[left])->field, 
  1652.              ((Flu_File_Chooser::Entry*)array[pivot])->field ) > 0 ) left++
  1653. #define CASE_RQSCANR( field ) 
  1654.       while( casecompare( ((Flu_File_Chooser::Entry*)array[right])->field, 
  1655.      ((Flu_File_Chooser::Entry*)array[pivot])->field ) < 0 ) right--
  1657. #define CUSTOM_QSCANL( field ) 
  1658.       while( customSort( ((Flu_File_Chooser::Entry*)array[left])->field, 
  1659.              ((Flu_File_Chooser::Entry*)array[pivot])->field ) < 0 ) left++
  1660. #define CUSTOM_QSCANR( field ) 
  1661.       while( customSort( ((Flu_File_Chooser::Entry*)array[right])->field, 
  1662.      ((Flu_File_Chooser::Entry*)array[pivot])->field ) > 0 ) right--
  1664. #define CUSTOM_RQSCANL( field ) 
  1665.       while( customSort( ((Flu_File_Chooser::Entry*)array[left])->field, 
  1666.              ((Flu_File_Chooser::Entry*)array[pivot])->field ) > 0 ) left++
  1667. #define CUSTOM_RQSCANR( field ) 
  1668.       while( customSort( ((Flu_File_Chooser::Entry*)array[right])->field, 
  1669.      ((Flu_File_Chooser::Entry*)array[pivot])->field ) < 0 ) right--
  1671. void Flu_File_Chooser :: _qSort( int how, bool caseSort, Fl_Widget **array, int low, int high )
  1672. {
  1673.   int left, right, pivot;
  1674.   Fl_Widget *temp;
  1675.   bool reverse = ( how & SORT_REVERSE );
  1677.   if( high > low )
  1678.     {
  1679.       left = low;
  1680.       right = high;
  1681.       pivot = low;
  1683.       while( right >= left )
  1684. {
  1685.   switch( how & ~SORT_REVERSE )
  1686.     {
  1687.     case SORT_NAME:
  1688.       if( reverse )
  1689. {
  1690.   if( customSort )
  1691.     {
  1692.       CUSTOM_RQSCANL( filename.c_str() );
  1693.       CUSTOM_RQSCANR( filename.c_str() );
  1694.     }
  1695.   else if( !caseSort )
  1696.     {
  1697.       CASE_RQSCANL( filename );
  1698.       CASE_RQSCANR( filename );
  1699.     }
  1700.   else
  1701.     {
  1702.       RQSCANL( filename );
  1703.       RQSCANR( filename );
  1704.     }
  1705. }
  1706.       else
  1707. {
  1708.   if( customSort )
  1709.     {
  1710.       CUSTOM_QSCANL( filename.c_str() );
  1711.       CUSTOM_QSCANR( filename.c_str() );
  1712.     }
  1713.   else if( !caseSort )
  1714.     {
  1715.       CASE_QSCANL( filename );
  1716.       CASE_QSCANR( filename );
  1717.     }
  1718.   else
  1719.     {
  1720.       QSCANL( filename );
  1721.       QSCANR( filename );
  1722.     }
  1723. }
  1724.       break;
  1725.     case SORT_SIZE:
  1726.       if( reverse )
  1727. {
  1728.   RQSCANL( isize );
  1729.   RQSCANR( isize );
  1730. }
  1731.       else
  1732. {
  1733.   QSCANL( isize );
  1734.   QSCANR( isize );
  1735. }
  1736.       break;
  1737.     case SORT_DATE:
  1738.       if( reverse )
  1739. {
  1740.   RQSCANL( idate );
  1741.   RQSCANR( idate );
  1742. }
  1743.       else
  1744. {
  1745.   QSCANL( idate );
  1746.   QSCANR( idate );
  1747. }
  1748.       break;
  1749.     case SORT_TYPE:
  1750.       if( reverse )
  1751. {
  1752.   RQSCANL( description );
  1753.   RQSCANR( description );
  1754. }
  1755.       else
  1756. {
  1757.   QSCANL( description );
  1758.   QSCANR( description );
  1759. }
  1760.       break;
  1761.     }
  1763.   if( left > right )
  1764.     break;
  1766.   temp = array[left];
  1767.   array[left] = array[right];
  1768.   array[right] = temp;
  1769.   left++;
  1770.   right--;
  1771. }
  1773.       _qSort( how, caseSort, array, low, right );
  1774.       _qSort( how, caseSort, array, left, high );
  1775.     }
  1776. }
  1778. Flu_File_Chooser :: FileList :: FileList( int x, int y, int w, int h, Flu_File_Chooser *c )
  1779.   : Flu_Wrap_Group( x, y, w, h )
  1780. {
  1781.   chooser = c;
  1782. }
  1784. Flu_File_Chooser :: FileList :: ~FileList()
  1785. {
  1786. }
  1788. void Flu_File_Chooser :: FileList :: sort( int n )
  1789. {
  1790.   if( n != -1 )
  1791.     numDirs = n;
  1792.   if( children() == 0 )
  1793.     return;
  1794.   // the directories are already first. sort the directories then the names lexigraphically
  1795.   //if( chooser->sortMethod & Flu_File_Chooser::SORT_NAME )
  1796.   Flu_File_Chooser::_qSort( chooser->sortMethod, chooser->caseSort, (Fl_Widget**)array(), 0, numDirs-1 );
  1797.   Flu_File_Chooser::_qSort( chooser->sortMethod, chooser->caseSort, (Fl_Widget**)array(), numDirs, children()-1 );
  1798.   chooser->redraw();
  1799. }
  1801. int Flu_File_Chooser :: FileList :: handle( int event )
  1802. {
  1803.   //printf( "%dn", event );
  1804.   if( event == FL_FOCUS || event == FL_UNFOCUS )
  1805.     return 1;
  1806.   if( Flu_Wrap_Group::handle( event ) )
  1807.     return 1;
  1808.   // if push on no file, unselect all files and turn off editing mode
  1809.   if( event == FL_PUSH && !Fl::event_key( FL_SHIFT ) && !Fl::event_key( FL_CTRL ) )
  1810.     {
  1811.       chooser->unselect_all();
  1812.       chooser->filename.value( "" );
  1813.       chooser->filename.position( chooser->filename.size(), chooser->filename.size() );
  1815.       if( Fl::event_button3() )
  1816. return chooser->popupContextMenu( NULL );
  1818.       return 1;
  1819.     }
  1820.   else if( event == FL_KEYDOWN )
  1821.     {
  1822.       if( Fl::event_key( FL_Delete ) )
  1823. {
  1824.   // recycle by default, unless the shift key is held down
  1825.   chooser->trashCB( !Fl::event_state( FL_SHIFT ) );
  1826.   return 1;
  1827. }
  1829.       Flu_File_Chooser::Entry *e = chooser->lastSelected;
  1830.       if( !e )
  1831. {
  1832.   for( int i = 0; i < children(); i++ )
  1833.     if( ((Flu_File_Chooser::Entry*)child(i))->selected )
  1834.       {
  1835. e = (Flu_File_Chooser::Entry*)child(i);
  1836. break;
  1837.       }
  1838. }
  1839.       if( e )
  1840. {
  1841.   switch( Fl::event_key() )
  1842.     {
  1843.     case FL_Up: e = (Flu_File_Chooser::Entry*)previous( e );
  1844.       if( !e && children() ) e = (Flu_File_Chooser::Entry*)child(0); break;
  1845.     case FL_Down: e = (Flu_File_Chooser::Entry*)next( e );
  1846.       if( !e && children() ) e = (Flu_File_Chooser::Entry*)child(children()-1); break;
  1847.     case FL_Left: e = (Flu_File_Chooser::Entry*)left( e ); break;
  1848.     case FL_Right: e = (Flu_File_Chooser::Entry*)right( e ); break;
  1849.     case FL_Home: if( children() ) e = (Flu_File_Chooser::Entry*)child(0); break;
  1850.     case FL_End: if( children() ) e = (Flu_File_Chooser::Entry*)child(children()-1); break;
  1851.     case FL_Enter:
  1852.       chooser->filenameEnterCallback = true;
  1853.       chooser->cd( e->filename.c_str() );
  1854.       return 1;
  1855.     case ' ':
  1856.       chooser->cd( e->filename.c_str() );
  1857.       return 1;
  1858.     default: e = 0; break;
  1859.     }
  1860.   if( e )
  1861.     {
  1862.       chooser->unselect_all();
  1863.       e->selected = true;
  1864.       chooser->lastSelected = e;
  1865.       chooser->filename.value( e->filename.c_str() );
  1866.       chooser->filename.position( chooser->filename.size(), chooser->filename.size() );
  1867.       chooser->redraw();
  1868.       scroll_to( e );
  1869.       //take_focus();
  1870.       return 1;
  1871.     }
  1872. }
  1873.     }
  1875.   return 0;
  1876. }
  1878. Flu_File_Chooser :: FileDetails :: FileDetails( int x, int y, int w, int h, Flu_File_Chooser *c )
  1879.   : Fl_Pack( x, y, w, h )
  1880. {
  1881.   chooser = c;
  1882. }
  1884. Flu_File_Chooser :: FileDetails :: ~FileDetails()
  1885. {
  1886. }
  1888. void Flu_File_Chooser :: FileDetails :: scroll_to( Fl_Widget *w )
  1889. {
  1890.   // we know all the widgets are the same height
  1891.   // so just find this widget and scroll to the accumulated height
  1892.   int H = 0;
  1893.   for( int i = 0; i < children(); i++ )
  1894.     {
  1895.       if( child(i) == w )
  1896. {
  1897.   if( H > (int)chooser->filescroll->scrollbar.maximum() )
  1898.     H = (int)chooser->filescroll->scrollbar.maximum();
  1899.   chooser->filescroll->position( 0, H );
  1900.   return;
  1901. }
  1902.       H += w->h();
  1903.     }
  1904. }
  1906. void Flu_File_Chooser :: FileDetails :: sort( int n )
  1907. {
  1908.   if( n != -1 )
  1909.     numDirs = n;
  1910.   if( children() == 0 )
  1911.     return;
  1912.   // the directories are already first. sort the directories then the names lexigraphically
  1913.   //if( chooser->sortMethod & Flu_File_Chooser::SORT_NAME )
  1914.   Flu_File_Chooser::_qSort( chooser->sortMethod, chooser->caseSort, (Fl_Widget**)array(), 0, numDirs-1 );
  1915.   Flu_File_Chooser::_qSort( chooser->sortMethod, chooser->caseSort, (Fl_Widget**)array(), numDirs, children()-1 );
  1916.   chooser->redraw();
  1917. }
  1919. Fl_Widget* Flu_File_Chooser :: FileDetails :: next( Fl_Widget* w )
  1920. {
  1921.   for( int i = 0; i < children()-1; i++ )
  1922.     {
  1923.       if( w == child(i) )
  1924. return child(i+1);
  1925.     }
  1926.   return NULL;
  1927. }
  1929. Fl_Widget* Flu_File_Chooser :: FileDetails :: previous( Fl_Widget* w )
  1930. {
  1931.   for( int i = 1; i < children(); i++ )
  1932.     {
  1933.       if( w == child(i) )
  1934. return child(i-1);
  1935.     }
  1936.   return NULL;
  1937. }
  1939. int Flu_File_Chooser :: FileDetails :: handle( int event )
  1940. {
  1941.   if( event == FL_FOCUS || event == FL_UNFOCUS )
  1942.     return 1;
  1943.   if( Fl_Pack::handle( event ) )
  1944.     return 1;
  1945.   else if( event == FL_PUSH )
  1946.     return 1;
  1948.   else if( event == FL_KEYDOWN )
  1949.     {
  1950.       if( Fl::event_key( FL_Delete ) )
  1951. {
  1952.   // recycle by default, unless the shift key is held down
  1953.   chooser->trashCB( !Fl::event_state( FL_SHIFT ) );
  1954.   return 1;
  1955. }
  1957.       Flu_File_Chooser::Entry *e = chooser->lastSelected;
  1958.       if( !e )
  1959. {
  1960.   for( int i = 0; i < children(); i++ )
  1961.     if( ((Flu_File_Chooser::Entry*)child(i))->selected )
  1962.       {
  1963. e = (Flu_File_Chooser::Entry*)child(i);
  1964. break;
  1965.       }
  1966. }
  1967.       if( e )
  1968. {
  1969.   switch( Fl::event_key() )
  1970.     {
  1971.     case FL_Up: e = (Flu_File_Chooser::Entry*)previous( e );
  1972.       if( !e && children() ) e = (Flu_File_Chooser::Entry*)child(0); break;
  1973.     case FL_Down: e = (Flu_File_Chooser::Entry*)next( e );
  1974.       if( !e && children() ) e = (Flu_File_Chooser::Entry*)child(children()-1); break;
  1975.     case FL_Home: if( children() ) e = (Flu_File_Chooser::Entry*)child(0); break;
  1976.     case FL_End: if( children() ) e = (Flu_File_Chooser::Entry*)child(children()-1); break;
  1977.     case FL_Enter:
  1978.       chooser->filenameEnterCallback = true;
  1979.       chooser->cd( e->filename.c_str() );
  1980.       return 1;
  1981.     case ' ':
  1982.       chooser->cd( e->filename.c_str() );
  1983.       return 1;
  1984.     default: e = 0; break;
  1985.     }
  1986.   if( e )
  1987.     {
  1988.       chooser->unselect_all();
  1989.       e->selected = true;
  1990.       chooser->lastSelected = e;
  1991.       chooser->filename.value( e->filename.c_str() );
  1992.       chooser->filename.position( chooser->filename.size(), chooser->filename.size() );
  1993.       chooser->redraw();
  1994.       scroll_to( e );
  1995.       //take_focus();
  1996.       return 1;
  1997.     }
  1998. }
  1999.     }
  2001.   return 0;
  2002. }
  2004. Flu_File_Chooser :: Entry :: Entry( const char* name, int t, bool d, Flu_File_Chooser *c )
  2005.   : Fl_Input( 0, 0, 0, 0 )
  2006. {
  2007.   resize( 0, 0, DEFAULT_ENTRY_WIDTH, 20 );
  2008.   labelsize( 12 );
  2009.   textsize( 12 );
  2010.   box( FL_BORDER_BOX );
  2011.   when( FL_WHEN_RELEASE_ALWAYS | FL_WHEN_ENTER_KEY_ALWAYS );
  2012.   callback( _inputCB, this );
  2013.   filename = name;
  2014.   selected = false;
  2015.   chooser = c;
  2016.   details = d;
  2017.   type = t;
  2018.   icon = NULL;
  2019.   editMode = 0;
  2020.   description = "";
  2022.   updateSize();
  2023.   updateIcon();
  2024. }
  2026. void Flu_File_Chooser :: Entry :: updateIcon()
  2027. {
  2028.   Flu_File_Chooser::FileTypeInfo *tt = NULL;
  2029.   if( type==ENTRY_MYCOMPUTER )
  2030.     {
  2031.       icon = &computer;
  2032.       description = "My Computer";
  2033.     }
  2034.   else if( type==ENTRY_MYDOCUMENTS )
  2035.     {
  2036.       icon = &documents;
  2037.       description = "My Documents";
  2038.     }
  2039.   else if( type==ENTRY_DRIVE )
  2040.     {
  2041.       //icon = &disk_drive;
  2042.       //description = "";
  2043.     }
  2044.   else if( type==ENTRY_DIR || type==ENTRY_FAVORITE )
  2045.     tt = Flu_File_Chooser::find_type( NULL );
  2046.   else
  2047.     {
  2048.       const char *dot = strrchr( filename.c_str(), '.' );
  2049.       if( dot )
  2050. {
  2051.   tt = Flu_File_Chooser::find_type( dot+1 );
  2052.   if( !tt )
  2053.     description = dot+1;
  2054. }
  2055.     }
  2056.   if( tt )
  2057.     {
  2058.       icon = tt->icon;
  2059.       description = tt->type;
  2060.     }
  2061.   // if there is no icon, assign a default one
  2062.   if( !icon && type==ENTRY_FILE )
  2063.     icon = chooser->defaultFileIcon;
  2064.   if( type==ENTRY_FAVORITE )
  2065.     icon = &little_favorites;
  2067.   toolTip = "Name: " + filename;
  2068.   if( type == ENTRY_FILE )
  2069.     toolTip += "nSize: " + filesize;
  2070.   toolTip += "nType: " + description;
  2071.   tooltip( toolTip.c_str() );
  2073.   redraw();
  2074. }
  2076. void Flu_File_Chooser :: resize( int x, int y, int w, int h )
  2077. {
  2078.   Fl_Double_Window::resize( x, y, w, h );
  2079.   if( fileListWideBtn->value() )
  2080.     filelist->scrollbar.linesize( filelist->w() );
  2081.   else if( fileListBtn->value() )
  2082.     filelist->scrollbar.linesize( DEFAULT_ENTRY_WIDTH+4 );
  2083.   for( int i = 0; i < filelist->children(); i++ )
  2084.     ((Entry*)filelist->child(i))->updateSize();
  2085. }
  2087. void Flu_File_Chooser :: Entry :: updateSize()
  2088. {
  2089.   if( type==ENTRY_FAVORITE || chooser->fileListWideBtn->value() )
  2090.     {
  2091.       resize( x(), y(), chooser->filelist->w()-4, 20 );
  2092.     }
  2094.   if( details )
  2095.     {
  2096.       nameW = chooser->detailNameBtn->w();
  2097.       typeW = chooser->detailTypeBtn->w();
  2098.       sizeW = chooser->detailSizeBtn->w();
  2099.       dateW = chooser->detailDateBtn->w();
  2100.       resize( x(), y(), chooser->filedetails->w(), 20 );
  2101.     }
  2102.   else
  2103.     nameW = w();
  2105.   // how big is the icon?
  2106.   int iW = 0, iH = 0;
  2107.   if( icon )
  2108.     {
  2109.       iW = icon->w()+2;
  2110.       iH = icon->h();
  2111.     }
  2113.   fl_font( labelfont(), labelsize() );
  2115.   // measure the name and see if we need a truncated version
  2116.   int W = 0, H = 0;
  2117.   fl_measure( filename.c_str(), W, H );  
  2118.   if( W > nameW-iW )
  2119.     {
  2120.       // progressively strip characters off the end of the name until
  2121.       // it fits with "..." at the end
  2122.       if( altname[0] != '' )
  2123. shortname = altname;
  2124.       else
  2125. shortname = filename;
  2126.       int len = shortname.size();
  2127.       while( W > (nameW-iW) && len > 3 )
  2128. {
  2129.   shortname[len-3] = '.';
  2130.   shortname[len-2] = '.';
  2131.   shortname[len-1] = '.';
  2132.   shortname[len] = '';
  2133.   len--;
  2134.   W = 0;
  2135.   fl_measure( shortname.c_str(), W, H );  
  2136. }
  2137.     }
  2138.   else
  2139.     shortname = "";
  2141.   // measure the description and see if we need a truncated version
  2142.   shortDescription = "";
  2143.   if( details )
  2144.     {
  2145.       W = 0; H = 0;
  2146.       fl_measure( description.c_str(), W, H );  
  2147.       if( W > typeW-4 )
  2148. {
  2149.   // progressively strip characters off the end of the description until
  2150.   // it fits with "..." at the end
  2151.   shortDescription = description;
  2152.   int len = shortDescription.size();
  2153.   while( W > typeW-4 && len > 3 )
  2154.     {
  2155.       shortDescription[len-3] = '.';
  2156.       shortDescription[len-2] = '.';
  2157.       shortDescription[len-1] = '.';
  2158.       shortDescription[len] = '';
  2159.       len--;
  2160.       W = 0;
  2161.       fl_measure( shortDescription.c_str(), W, H );  
  2162.     }
  2163. }
  2164.     }
  2166.   redraw();
  2167. }
  2169. Flu_File_Chooser :: Entry :: ~Entry()
  2170. {
  2171. }
  2173. void Flu_File_Chooser :: Entry :: inputCB()
  2174. {
  2175.   redraw();
  2177.   // if the user tried to change the string to nothing, restore the original name and turn off edit mode
  2178.   if( strlen( value() ) == 0 )
  2179.     {
  2180.       editMode = 0;
  2181.       return;
  2182.     }
  2184.   // if input text is different from filename, try to change the filename
  2185.   if( strcmp( value(), filename.c_str() ) != 0 )
  2186.     {
  2187.       // build the total old filename and new filename
  2188.       FluSimpleString oldName = chooser->currentDir + filename,
  2189. newName = chooser->currentDir + value();
  2190.       // see if new name already exists
  2191.       struct stat s;
  2192.       int result = ::stat( newName.c_str(), &s );
  2193.       if( result == 0 )
  2194. {
  2195.   fl_alert( "File '%s' already exists!", newName.c_str() );
  2196.   return;  // leave editing on
  2197. }
  2199.       if( rename( oldName.c_str(), newName.c_str() ) == -1 )
  2200. {
  2201.   fl_alert( "Unable to rename '%s' to '%s'", oldName.c_str(), newName.c_str() );
  2202.   //return;  // leave editing on
  2203. }
  2204.       else
  2205. {
  2206.   filename = value();
  2207.   updateSize();
  2208.   updateIcon();
  2209. }
  2210.       // QUESTION: should we set the chooser filename to the modified name?
  2211.       //chooser->filename.value( filename.c_str() );
  2212.     }
  2214.   // only turn off editing if we have a successful name change
  2215.   editMode = 0;
  2216. }
  2218. Fl_Group* Flu_File_Chooser :: getEntryGroup()
  2219. {
  2220.   return (!fileDetailsBtn->value() || currentDir == FAVORITES_UNIQUE_STRING ) ? &(filelist->group) : filedetails;
  2221. }
  2223. Fl_Group* Flu_File_Chooser :: getEntryContainer()
  2224. {
  2225.   return (!fileDetailsBtn->value() || currentDir == FAVORITES_UNIQUE_STRING ) ? (Fl_Group*)filelist : filedetails;
  2226. }
  2228. int Flu_File_Chooser :: Entry :: handle( int event )
  2229. {
  2230.   if( editMode )
  2231.     {
  2232.       // if user hits 'Escape' while in edit mode, restore the original name and turn off edit mode
  2233.       if( event == FL_KEYDOWN && Fl::event_key( FL_Escape ) )
  2234. {
  2235.   editMode = 0;
  2236.   redraw();
  2237.   if( selected )
  2238.     chooser->trashBtn->activate();
  2239.   return 1;
  2240. }
  2241.       return Fl_Input::handle( event );
  2242.     }
  2244.   if( event == FL_FOCUS || event == FL_UNFOCUS )
  2245.     return 1;
  2247.   if( event == FL_ENTER || event == FL_LEAVE )
  2248.     return 1;
  2250.   Fl_Group *g = chooser->getEntryGroup();
  2251.   if( event == FL_PUSH )
  2252.     {
  2253.       if( Fl::event_clicks() > 0 )
  2254. {
  2255.   Fl::event_clicks(0);
  2256.   // double-clicking a favorite cd's to it
  2257.   if( type == ENTRY_FAVORITE )
  2258.     {
  2259.       chooser->delayedCd = filename;
  2260.       Fl::add_timeout( 0.0f, Flu_File_Chooser::delayedCdCB, chooser );
  2261.     }
  2262.   // double-clicking a directory cd's to it
  2263.   else if( type != ENTRY_FILE )
  2264.     {
  2265. #ifdef WIN32
  2266.       if( filename[1] == ':' )
  2267. chooser->delayedCd = filename;
  2268.       else
  2269. #endif
  2270. chooser->delayedCd = chooser->currentDir + filename + "/";
  2271.       Fl::add_timeout( 0.0f, Flu_File_Chooser::delayedCdCB, chooser );
  2272.     }
  2273.   // double-clicking a file chooses it if we are in file selection mode
  2274.   else if( (chooser->selectionType & DIRECTORY) == 0 )
  2275.     {
  2276.       // prepend the path
  2277.       FluSimpleString path = chooser->currentDir + filename;
  2278.       chooser->filename.value( path.c_str() );
  2279.       //chooser->filename.value( filename.c_str() );
  2280.       chooser->filename.position( chooser->filename.size(), chooser->filename.size() );
  2281.       Fl::add_timeout( 0.0f, Flu_File_Chooser::selectCB, chooser );
  2282.     }
  2283.   if( selected )
  2284.     chooser->trashBtn->activate();
  2285.   return 1;
  2286. }
  2288.       /*
  2289.       if( selected && !Fl::event_button3() && !Fl::event_state(FL_CTRL) && !Fl::event_state(FL_SHIFT) )
  2290. {
  2291.   // only allow editing of certain files and directories
  2292.   if( chooser->fileEditing && ( type == ENTRY_FILE || type == ENTRY_DIR ) )
  2293.     {
  2294.       // if already selected, switch to input mode
  2295.       Fl::add_timeout( 1.0, _editCB, this );
  2296.       return 1;
  2297.     }
  2298. }
  2300. else*/ if( chooser->selectionType & MULTI )
  2301. {
  2302.   if( Fl::event_state(FL_CTRL) )
  2303.     {
  2304.       selected = !selected;  // toggle this item
  2305.       chooser->lastSelected = this;
  2306.       if( type == ENTRY_FILE )
  2307. chooser->previewGroup->file = chooser->currentDir + filename;
  2308.       chooser->redraw();
  2309.       chooser->getEntryContainer()->take_focus();
  2310.     }
  2311.   else if( Fl::event_state(FL_SHIFT) )
  2312.     {
  2313.       // toggle all items from the last selected item to this one
  2314.       if( chooser->lastSelected == NULL )
  2315. {
  2316.   selected = true;
  2317.   chooser->lastSelected = this;
  2318.   if( type == ENTRY_FILE )
  2319.     chooser->previewGroup->file = chooser->currentDir + filename;
  2320.   chooser->redraw();
  2321.   chooser->getEntryContainer()->take_focus();
  2322. }
  2323.       else
  2324. {
  2325.   // get the index of the last selected item and this item
  2326.   int lastindex = -1, thisindex = -1;
  2327.   int i;
  2328.   for( i = 0; i < g->children(); i++ )
  2329.     {
  2330.       if( g->child(i) == chooser->lastSelected )
  2331. lastindex = i;
  2332.       if( g->child(i) == this )
  2333. thisindex = i;
  2334.       if( lastindex >= 0 && thisindex >= 0 )
  2335. break;
  2336.     }
  2337.   if( lastindex >= 0 && thisindex >= 0 )
  2338.     {
  2339.       // loop from this item to the last item, toggling each item except the last
  2340.       int inc;
  2341.       if( thisindex > lastindex )
  2342. inc = -1;
  2343.       else
  2344. inc = 1;
  2345.       Entry *e;
  2346.       for( i = thisindex; i != lastindex; i += inc )
  2347. {
  2348.   e = (Entry*)g->child(i);
  2349.   e->selected = !e->selected;
  2350.   e->redraw();
  2351. }
  2352.       chooser->lastSelected = this;
  2353.       if( type == ENTRY_FILE )
  2354. chooser->previewGroup->file = chooser->currentDir + filename;
  2355.       chooser->redraw();
  2356.       chooser->getEntryContainer()->take_focus();
  2357.     }
  2358. }
  2359.     }
  2360.   else
  2361.     {
  2362.       chooser->unselect_all();
  2363.       selected = true;
  2364.       chooser->lastSelected = this;
  2365.       if( type == ENTRY_FILE )
  2366. chooser->previewGroup->file = chooser->currentDir + filename;
  2367.       chooser->redraw();
  2368.       chooser->getEntryContainer()->take_focus();
  2369.     }
  2370. }
  2371.       else
  2372. {
  2373.   chooser->unselect_all();
  2374.   selected = true;
  2375.   chooser->lastSelected = this;
  2376.   if( type == ENTRY_FILE )
  2377.     chooser->previewGroup->file = chooser->currentDir + filename;
  2378.   chooser->redraw();
  2379.   chooser->getEntryContainer()->take_focus();
  2380. }
  2382.       //g->take_focus();
  2384.       redraw();
  2385.       if( selected )
  2386. chooser->trashBtn->activate();
  2388.       if( Fl::event_button3() )
  2389. return chooser->popupContextMenu( this );
  2391.       // don't put the filename into the box if we are directory but we are not choosing directories
  2392.       if( (chooser->selectionType & Flu_File_Chooser::DIRECTORY)  ||  type==ENTRY_FILE )
  2393. chooser->filename.value( filename.c_str() );
  2394.       else
  2395. chooser->filename.value( "" );
  2396.       chooser->filename.position( chooser->filename.size(), chooser->filename.size() );
  2398.       return 1;
  2399.     }
  2400.   else if( event == FL_DRAG )
  2401.     {
  2402.       if( chooser->selectionType & MULTI )
  2403. {
  2404.   // toggle all items from the last selected item to this one
  2405.   if( chooser->lastSelected != NULL )
  2406.     {
  2407.       selected = true;
  2408.       // get the index of the last selected item and this item
  2409.       int lastindex = -1, thisindex = -1;
  2410.       int i;
  2411.       for( i = 0; i < g->children(); i++ )
  2412. {
  2413.   if( g->child(i) == chooser->lastSelected )
  2414.     lastindex = i;
  2415.   if( g->child(i) == this )
  2416.     thisindex = i;
  2417.   if( lastindex >= 0 && thisindex >= 0 )
  2418.     break;
  2419. }
  2420.       if( lastindex >= 0 && thisindex >= 0 )
  2421. {
  2422.   // loop from this item to the last item, toggling each item except the last
  2423.   int inc;
  2424.   if( thisindex > lastindex )
  2425.     inc = -1;
  2426.   else
  2427.     inc = 1;
  2428.   Entry *e;
  2429.   for( i = thisindex; i != lastindex; i += inc )
  2430.     {
  2431.       e = (Entry*)g->child(i);
  2432.       e->selected = !e->selected;
  2433.       e->redraw();
  2434.     }
  2435.   chooser->lastSelected = this;
  2436.   if( type == ENTRY_FILE )
  2437.     chooser->previewGroup->file = chooser->currentDir + filename;
  2438.   chooser->redraw();
  2439. }
  2440.       redraw();
  2441.       chooser->getEntryContainer()->take_focus();
  2442.       if( selected )
  2443. chooser->trashBtn->activate();
  2444.       return 1;
  2445.     }
  2446. }
  2447.     }
  2448.   return Fl_Widget::handle(event);
  2449. }
  2451. void Flu_File_Chooser :: Entry :: editCB()
  2452. {
  2453.   // if already selected, switch to input mode
  2454.   editMode = 2;
  2455.   value( filename.c_str() );
  2456.   take_focus();
  2457.   // select the text up to but not including the extension
  2458.   const char *dot = strrchr( filename.c_str(), '.' );
  2459.   if( dot )
  2460.     position( 0, dot-filename.c_str() );
  2461.   else
  2462.     position( 0, filename.size() );
  2463.   chooser->trashBtn->deactivate();
  2464.   redraw();
  2465. }
  2467. int Flu_File_Chooser :: popupContextMenu( Entry *entry )
  2468. {
  2469.   int type = entry ? entry->type : ENTRY_NONE;
  2470.   const char *filename = entry ? entry->filename.c_str() : NULL;
  2471.   char *ext = NULL;
  2473.   if( filename )
  2474.     ext = (char*)strrchr( filename, '.' );
  2475.   if( ext )
  2476.     {
  2477.       ext = strdup( ext+1 ); // skip the '.'
  2478.       for( unsigned int i = 0; i < strlen(ext); i++ )
  2479. ext[i] = tolower( ext[i] );
  2480.     }
  2482.   enum { ACTION_NEW_FOLDER = -1, ACTION_RENAME = -2, ACTION_DELETE = -3 };
  2484.   entryPopup.clear();
  2485.   switch( type )
  2486.     {
  2487.     case ENTRY_NONE: // right click on nothing
  2488.       entryPopup.add( "New Folder", 0, 0, (void*)ACTION_NEW_FOLDER );
  2489.       break;
  2491.     case ENTRY_DIR:
  2492.       entryPopup.add( "Rename", 0, 0, (void*)ACTION_RENAME );
  2493.       entryPopup.add( "Delete", 0, 0, (void*)ACTION_DELETE );
  2494.       break;
  2496.     case ENTRY_FILE:
  2497.       entryPopup.add( "Rename", 0, 0, (void*)ACTION_RENAME );
  2498.       entryPopup.add( "Delete", 0, 0, (void*)ACTION_DELETE );
  2499.       break;
  2501.    case ENTRY_FAVORITE:
  2502.      entryPopup.add( "Delete", 0, 0, (void*)ACTION_DELETE );
  2503.       break;
  2505.     case ENTRY_DRIVE:
  2506.       break;
  2508.     case ENTRY_MYDOCUMENTS:
  2509.       break;
  2511.     case ENTRY_MYCOMPUTER:
  2512.       break;
  2513.     }
  2515.   // add the programmable context handlers
  2516.   for( unsigned int i = 0; i < contextHandlers.size(); i++ )
  2517.     {
  2518.       if( !(contextHandlers[i].type & type) )
  2519. continue;
  2520.       if( type == ENTRY_FILE )
  2521. if( contextHandlers[i].ext.size() && contextHandlers[i].ext != ext )
  2522.   continue;
  2523.       entryPopup.add( contextHandlers[i].name.c_str(), 0, 0, (void*)i );
  2524.     }
  2525.   if( ext )
  2526.     free( ext );
  2528.   entryPopup.position( Fl::event_x(), Fl::event_y() );
  2529.   const Fl_Menu_Item *selection = entryPopup.popup();
  2530.   if( selection )
  2531.     {
  2532.       int handler = static_cast<int>(reinterpret_cast<long>(selection->user_data()));
  2533.       switch( handler )
  2534. {
  2535. case ACTION_NEW_FOLDER:
  2536.   newFolderCB();
  2537.   break;
  2538. case ACTION_RENAME:
  2539.   entry->editCB();
  2540.   /*
  2541.   entry->editMode = 2;
  2542.   entry->value( entry->filename.c_str() );
  2543.   entry->take_focus();
  2544.   entry->position( 0, entry->filename.size() );
  2545.   trashBtn->deactivate();
  2546.   */
  2547.   break;
  2548. case ACTION_DELETE:
  2549.   // recycle by default, unless the shift key is held down
  2550.   trashCB( !Fl::event_state( FL_SHIFT ) );
  2551.   break;
  2552. default:
  2553.   contextHandlers[handler].callback( filename, type, contextHandlers[handler].callbackData );
  2554.   break;
  2555. }
  2556.     }
  2557.   else
  2558.     return handle( FL_PUSH );
  2559.   return 1;
  2560. }
  2562. void Flu_File_Chooser :: Entry :: draw()
  2563. {
  2564.   if( editMode )
  2565.     {
  2566.       if( editMode == 2 )
  2567. {
  2568.   editMode--;
  2569.   fl_draw_box( FL_FLAT_BOX, x(), y(), w(), h(), FL_WHITE );
  2570.   redraw();
  2571. }
  2572.       Fl_Input::draw();
  2573.       return;
  2574.     }
  2576.   if( selected )
  2577.     {
  2578.       fl_draw_box( FL_FLAT_BOX, x(), y(), w(), h(), FL_SELECTION_COLOR );
  2579.       fl_color( FL_WHITE );
  2580.     }
  2581.   else
  2582.     {
  2583.       fl_draw_box( FL_FLAT_BOX, x(), y(), w(), h(), FL_WHITE );
  2584.       fl_color( FL_BLACK );
  2585.     }
  2587.   int X = x()+4;
  2588.   if( icon )
  2589.     {
  2590.       icon->draw( X, y()+h()/2-icon->h()/2 );
  2591.       X += icon->w()+2;
  2592.     }
  2594.   fl_font( labelfont(), labelsize() );
  2596.   if( shortname[0] != '' )
  2597.     fl_draw( shortname.c_str(), X, y(), nameW, h(), FL_ALIGN_LEFT );
  2598.   else if( altname[0] != '' )
  2599.     fl_draw( altname.c_str(), X, y(), nameW, h(), FL_ALIGN_LEFT );
  2600.   else
  2601.     fl_draw( filename.c_str(), X, y(), nameW, h(), FL_ALIGN_LEFT );
  2603.   X = x()+4 + nameW;
  2605.   if( details )
  2606.     {
  2607.       if( shortDescription[0] != '' )
  2608. fl_draw( shortDescription.c_str(), X, y(), typeW-4, h(), Fl_Align(FL_ALIGN_LEFT | FL_ALIGN_CLIP) );
  2609.       else
  2610. fl_draw( description.c_str(), X, y(), typeW-4, h(), Fl_Align(FL_ALIGN_LEFT | FL_ALIGN_CLIP) );
  2612.       X += typeW;
  2614.       fl_draw( filesize.c_str(), X, y(), sizeW-4, h(), Fl_Align(FL_ALIGN_RIGHT | FL_ALIGN_CLIP) );
  2616.       X += sizeW+4;
  2618.       fl_draw( date.c_str(), X, y(), dateW-4, h(), Fl_Align(FL_ALIGN_LEFT | FL_ALIGN_CLIP) );
  2619.     }
  2620. }
  2622. void Flu_File_Chooser :: unselect_all()
  2623. {
  2624.   Fl_Group *g = getEntryGroup();
  2625.   Entry *e;
  2626.   for( int i = 0; i < g->children(); i++ )
  2627.     {
  2628.       e = ((Entry*)g->child(i));
  2629.       e->selected = false;
  2630.       e->editMode = 0;
  2631.     }
  2632.   lastSelected = 0;
  2633.   previewGroup->file = "";
  2634.   previewGroup->redraw();
  2635.   trashBtn->deactivate();
  2636.   redraw();
  2637. }
  2639. void Flu_File_Chooser :: select_all()
  2640. {
  2641.   if( !( selectionType & MULTI ) )
  2642.     return;
  2643.   Fl_Group *g = getEntryGroup();
  2644.   Entry *e;
  2645.   previewGroup->file = "";
  2646.   for( int i = 0; i < g->children(); i++ )
  2647.     {
  2648.       e = ((Entry*)g->child(i));
  2649.       e->selected = true;
  2650.       e->editMode = 0;
  2651.       previewGroup->file = e->filename;
  2652.       filename.value( e->filename.c_str() );
  2653.     }
  2654.   lastSelected = 0;
  2655.   previewGroup->redraw();
  2656.   trashBtn->deactivate();
  2657.   redraw();
  2658. }
  2660. void Flu_File_Chooser :: updateEntrySizes()
  2661. {
  2662.   filecolumns->W1 = detailNameBtn->w();
  2663.   filecolumns->W2 = detailTypeBtn->w();
  2664.   filecolumns->W3 = detailSizeBtn->w();
  2665.   filecolumns->W4 = detailDateBtn->w();
  2667.   // update the size of each entry because the user changed the size of each column
  2668.   filedetails->resize( filedetails->x(), filedetails->y(), filescroll->w(), filedetails->h() );
  2669.   for( int i = 0; i < filedetails->children(); i++ )
  2670.     ((Entry*)filedetails->child(i))->updateSize();
  2671. }
  2673. const char* Flu_File_Chooser :: value()
  2674. {
  2675.   if( filename.size() == 0 )
  2676.     return NULL;
  2677.   else
  2678.     return filename.value();
  2679. }
  2681. int Flu_File_Chooser :: count()
  2682. {
  2683.   if( selectionType & MULTI )
  2684.     {
  2685.       int n = 0;
  2686.       Fl_Group *g = getEntryGroup();
  2687.       for( int i = 0; i < g->children(); i++ )
  2688. {
  2689. #ifdef WIN32
  2690.   if( ((Entry*)g->child(i))->filename == "My Computer" )
  2691.     continue;
  2692. #endif
  2693.   if( ((Entry*)g->child(i))->selected )
  2694.     n++;
  2695. }
  2696.       return n;
  2697.     }
  2698.   else
  2699.     return (strlen(filename.value())==0)? 0 : 1;
  2700. }
  2702. void Flu_File_Chooser :: value( const char *v )
  2703. {
  2704.   cd( v );
  2705.   if( !v )
  2706.     return;
  2707.   // try to find the file and select it
  2708.   const char *slash = strrchr( v, '/' );
  2709.   if( slash )
  2710.     slash++;
  2711.   else
  2712.     {
  2713.       slash = strrchr( v, '\' );
  2714.       if( slash )
  2715. slash++;
  2716.       else
  2717. slash = v;
  2718.     }
  2719.   filename.value( slash );
  2720.   filename.position( filename.size(), filename.size() );
  2721.   Fl_Group *g = getEntryGroup();
  2722.   for( int i = 0; i < g->children(); i++ )
  2723.     {
  2724.       if( ((Entry*)g->child(i))->filename == slash )
  2725. {
  2726.   ((Entry*)g->child(i))->selected = true;
  2727.   filelist->scroll_to( (Entry*)g->child(i) );
  2728.   filedetails->scroll_to( (Entry*)g->child(i) );
  2729.   redraw();
  2730.   return;
  2731. }
  2732.     }
  2733. }
  2735. const char* Flu_File_Chooser :: value( int n )
  2736. {
  2737.   Fl_Group *g = getEntryGroup();
  2738.   for( int i = 0; i < g->children(); i++ )
  2739.     {
  2740. #ifdef WIN32
  2741.       if( ((Entry*)g->child(i))->filename == "My Computer" )
  2742. continue;
  2743. #endif
  2744.       if( ((Entry*)g->child(i))->selected )
  2745. {
  2746.   n--;
  2747.   if( n == 0 )
  2748.     {
  2749.       FluSimpleString s = currentDir + ((Entry*)g->child(i))->filename;
  2750.       filename.value( s.c_str() );
  2751.       filename.position( filename.size(), filename.size() );
  2752.       return value();
  2753.     }
  2754. }
  2755.     }
  2756.   return "";
  2757. }
  2759. void Flu_File_Chooser :: reloadCB()
  2760. {
  2761. #ifdef WIN32
  2762.   refreshDrives = true;
  2763. #endif
  2764.   cd( currentDir.c_str() );
  2765. }
  2767. void Flu_File_Chooser :: addToFavoritesCB()
  2768. {
  2769.   // eliminate duplicates
  2770.   bool duplicate = false;
  2771.   for( int i = 1; i <= favoritesList->size(); i++ )
  2772.     {
  2773.       if( streq( currentDir.c_str(), favoritesList->text(i) ) )
  2774. {
  2775.   duplicate = true;
  2776.   break;
  2777. }
  2778.     }
  2779.   if( !duplicate )
  2780.     favoritesList->add( currentDir.c_str() );
  2782.   // save the favorites
  2783.   FILE *f = fopen( configFilename.c_str(), "w" );
  2784.   if( f )
  2785.     {
  2786.       for( int i = 1; i <= favoritesList->size(); i++ )
  2787. fprintf( f, "%sn", favoritesList->text(i) );
  2788.       fclose( f );
  2789.     }
  2790. }
  2792. FluSimpleString Flu_File_Chooser :: formatDate( const char *d )
  2793. {
  2794.   // convert style "Wed Mar 19 07:23:11 2003" to "MM/DD/YY HH:MM AM|PM"
  2796.   int month, day, year, hour, minute, second;
  2797.   bool pm;
  2798.   char MM[16], dummy[64];
  2800.   sscanf( d, "%s %s %d %d:%d:%d %d", dummy, MM, &day, &hour, &minute, &second, &year );
  2802.   pm = ( hour >= 12 );
  2803.   if( hour == 0 )
  2804.     hour = 12;
  2805.   if( hour >= 13 )
  2806.     hour -= 12;
  2808.   if( strcmp(MM,"Jan")==0 ) month = 1;
  2809.   else if( strcmp(MM,"Feb")==0 ) month = 2;
  2810.   else if( strcmp(MM,"Mar")==0 ) month = 3;
  2811.   else if( strcmp(MM,"Apr")==0 ) month = 4;
  2812.   else if( strcmp(MM,"May")==0 ) month = 5;
  2813.   else if( strcmp(MM,"Jun")==0 ) month = 6;
  2814.   else if( strcmp(MM,"Jul")==0 ) month = 7;
  2815.   else if( strcmp(MM,"Aug")==0 ) month = 8;
  2816.   else if( strcmp(MM,"Sep")==0 ) month = 9;
  2817.   else if( strcmp(MM,"Oct")==0 ) month = 10;
  2818.   else if( strcmp(MM,"Nov")==0 ) month = 11;
  2819.   else month = 12;
  2821.   sprintf( dummy, "%d/%d/%02d %d:%02d %s", month, day, year, hour, minute, pm?"PM":"AM" );
  2823.   FluSimpleString formatted = dummy;
  2825.   return formatted;
  2826. }
  2828. void Flu_File_Chooser :: win2unix( FluSimpleString &s )
  2829. {
  2830.   int len = s.size();
  2831.   for( int i = 0; i < len; i++ )
  2832.     if( s[i] == '\' )
  2833.       s[i] = '/';
  2834. }
  2836. void Flu_File_Chooser :: cleanupPath( FluSimpleString &s )
  2837. {
  2838.   // convert all '' to '/'
  2839.   win2unix( s );
  2841.   FluSimpleString newS(s.size()+1);
  2843.   int oldPos, newPos;
  2844.   for( oldPos = 0, newPos = 0; oldPos < s.size(); oldPos++ )
  2845.     {
  2846.       // remove "./" 
  2847.       if( s[oldPos] == '.' && s[oldPos+1] == '/' )
  2848. oldPos += 2;
  2850.       // convert "//" to "/"
  2851.       else if( s[oldPos] == '/' && s[oldPos+1] == '/' )
  2852. oldPos++;
  2854. #ifdef WIN32
  2855.       // upcase "c:" to "C:"
  2856.       else if( s[oldPos+1] == ':' )
  2857. s[oldPos] = toupper( s[oldPos] );
  2858. #endif
  2860.       // remove "../" by removing everything back to the last "/"
  2861.       if( oldPos+2 < s.size() ) // bounds check
  2862. {
  2863.   if( s[oldPos] == '.' && s[oldPos+1] == '.' && s[oldPos+2] == '/' && newS != "/" )
  2864.     {
  2865.       // erase the last character, which should be a '/'
  2866.       newPos--;
  2867.       newS[newPos] = '';
  2868.       // look for the previous '/'
  2869.       const char *lastSlash = strrchr( newS.c_str(), '/' );
  2870.       // make the new string position after the slash
  2871.       newPos = (lastSlash-newS.c_str())+1;
  2872.       oldPos += 3;
  2873.     }
  2874. }
  2876.       newS[newPos] = s[oldPos];
  2877.       newPos++;
  2878.     }
  2880.   newS[newPos] = '';
  2881.   s = newS;
  2882. }
  2884. bool Flu_File_Chooser :: correctPath( FluSimpleString &path )
  2885. {
  2886.   // the path may or may not be an alias, needing corrected
  2887. #ifdef WIN32
  2888.   // point to the correct desktop
  2889.   if( path == "/Desktop/" || path == "/Desktop" )
  2890.     {
  2891.       path = userHome + "Desktop";
  2892.       return true;
  2893.     }
  2894.   else if( path == userHome+"Desktop" || path == userHome+"Desktop/" )
  2895.     return true;
  2896.   else if( path == "/Desktop/My Computer/" || path == "/Desktop/My Computer" || 
  2897.    path == userHome+"Desktop/My Computer/" || path == userHome+"Desktop/My Computer" )
  2898.     path = "/";
  2899.   else if( path == "/Desktop/My Documents/" || path == "/Desktop/My Documents" ||
  2900.    path == userHome+"Desktop/My Documents/" || path == userHome+"Desktop/My Documents" )
  2901.     path = userHome + "My Documents";
  2902. #endif
  2903.   return false;
  2904. }
  2906. void Flu_File_Chooser :: backCB()
  2907. {
  2908.   if( !currentHist ) return;
  2909.   if( currentHist->last )
  2910.     {
  2911.       currentHist = currentHist->last;
  2912.       walkingHistory = true;
  2913.       delayedCd = currentHist->path;
  2914.       Fl::add_timeout( 0.0f, Flu_File_Chooser::delayedCdCB, this );
  2915.     }
  2916. }
  2918. void Flu_File_Chooser :: forwardCB()
  2919. {
  2920.   if( !currentHist ) return;
  2921.   if( currentHist->next )
  2922.     {
  2923.       currentHist = currentHist->next;
  2924.       walkingHistory = true;
  2925.       delayedCd = currentHist->path;
  2926.       Fl::add_timeout( 0.0f, Flu_File_Chooser::delayedCdCB, this );
  2927.     }
  2928. }
  2930. void Flu_File_Chooser :: buildFilesystemsCombo()
  2931. {
  2932.   // add all filesystems
  2933.   filesystems->tree.clear();
  2935. #ifdef WIN32
  2936.   char volumeName[1024];
  2937.   Flu_Tree_Browser::Node *n;
  2938.   n = filesystems->tree.add( "Desktop/" ); n->branch_icon( &little_desktop );
  2939.   n = filesystems->tree.add( "Desktop/My Documents/" ); n->branch_icon( &documents );
  2940.   n = filesystems->tree.add( "Desktop/My Computer/" ); n->branch_icon( &computer );
  2941.   // get the filesystems and add them
  2942.   {
  2943.     if( refreshDrives )
  2944.       driveMask = GetLogicalDrives();
  2945.     DWORD mask = driveMask;
  2947.     for( int i = 0; i < 26; i++ )
  2948.       {
  2949. drives[i] = "";
  2950. driveIcons[i] = &disk_drive;
  2951. if( mask & 1 )
  2952.   {
  2953.     FluSimpleString s = "Desktop/My Computer/";
  2954.     char drive[] = "A:";
  2955.     char windrive[] = "A:\";
  2956.     windrive[0] = drive[0] = 'A' + i;
  2957.     DWORD type;
  2958.     if( refreshDrives )
  2959.       {
  2960. volumeName[0] = '';
  2961. type = driveTypes[i] = GetDriveType( windrive );
  2962. if( type != DRIVE_REMOVABLE && type != DRIVE_REMOTE )
  2963.   GetVolumeInformation( windrive, volumeName, 1024, NULL, NULL, NULL, NULL, 0 );
  2964. volumeNames[i] = volumeName;
  2965.       }
  2966.     else
  2967.       {
  2968. strncpy( volumeName, volumeNames[i].c_str(), 1024 );
  2969. type = driveTypes[i];
  2970.       }
  2972.     //s += volume
  2973.     const char *disk = "Disk";
  2974.     switch( type )
  2975.       {
  2976.       case DRIVE_REMOVABLE: 
  2977. disk = strlen(volumeName)?volumeName: ( 1 < 2 ? "Floppy Disk" : "Removable Disk" );
  2978. driveIcons[i] = &floppy_drive;
  2979. break;
  2980.       case DRIVE_FIXED: 
  2981. disk = strlen(volumeName)?volumeName:"Local Disk";
  2982. //driveIcons[i] = &disk_drive;
  2983. break;
  2984.       case DRIVE_CDROM: 
  2985. disk = strlen(volumeName)?volumeName:"Compact Disk";
  2986. driveIcons[i] = &cd_drive;
  2987. break;
  2988.       case DRIVE_REMOTE: 
  2989. disk = strlen(volumeName)?volumeName:"Network Disk";
  2990. driveIcons[i] = &network_drive;
  2991. break;
  2992.       case DRIVE_RAMDISK: 
  2993. disk = strlen(volumeName)?volumeName:"RAM Disk";
  2994. driveIcons[i] = &ram_drive;
  2995. break;
  2996.       }
  2997.     drives[i] = FluSimpleString(disk) + " (" + FluSimpleString(drive) + ")/";
  2998.     s += drives[i];
  2999.     n = filesystems->tree.add( s.c_str() ); n->branch_icon( driveIcons[i] );
  3000.     // erase the trailing '/' to make things look nicer
  3001.     drives[i][ drives[i].size()-1 ] = '';
  3002.   }
  3003. mask >>= 1;
  3004.       }
  3005.   }
  3006.   n = filesystems->tree.add( "Favorites/" ); n->branch_icon( &little_favorites );
  3007.   refreshDrives = false;
  3009. #elif defined __APPLE__
  3011.   filesystems->tree.label( "/" );
  3013.   // get all volume mount points and add to the filesystems combobox
  3014.   dirent **e;
  3015.   char *name;
  3016.   int num = fl_filename_list( "/Volumes/", &e );
  3017.   if( num > 0 )
  3018.     {
  3019.       int i;
  3020.       for( i = 0; i < num; i++ )
  3021. {
  3022.   name = e[i]->d_name;
  3024.   // ignore the "." and ".." names
  3025.   if( strcmp( name, "." ) == 0 || strcmp( name, ".." ) == 0 ||
  3026.       strcmp( name, "./" ) == 0 || strcmp( name, "../" ) == 0 ||
  3027.       strcmp( name, ".\" ) == 0 || strcmp( name, "..\" ) == 0 )
  3028.     continue;
  3030.   // if 'name' ends in '/', remove it
  3031.   if( name[strlen(name)-1] == '/' )
  3032.     name[strlen(name)-1] = '';
  3034.   FluSimpleString fullpath = "/Volumes/";
  3035.   fullpath += name;
  3036.   fullpath += "/";
  3037.   filesystems->tree.add( fullpath.c_str() );
  3038. }
  3039.     }
  3041. #else
  3043.   filesystems->tree.label( "/" );
  3045.   // get all mount points and add to the filesystems combobox
  3046.   FILE *fstab; // /etc/mtab or /etc/mnttab file
  3047.   char dummy[256], mountPoint[256], line[1024]; // Input line
  3048.   FluSimpleString mount;
  3050.   fstab = fopen( "/etc/fstab", "r" ); // Otherwise fallback to full list
  3051.   if( fstab )
  3052.     {
  3053.       while( fgets( line, 1024, fstab ) )
  3054. {
  3055.   if( line[0] == '#' || line[0] == 'n' )
  3056.     continue;
  3058.   // in fstab, mount point is second full string
  3059.   sscanf( line, "%s %s", dummy, mountPoint );
  3060.   mount = mountPoint;
  3062.   // cull some stuff
  3063.   if( mount[0] != '/' ) continue;
  3064.   if( mount == "/" ) continue;
  3065.   if( mount == "/boot" ) continue;
  3066.   if( mount == "/proc" ) continue;
  3068.   // now add the mount point
  3069.   mount += "/";
  3070.   filesystems->tree.add( mount.c_str() );
  3071. }
  3073.       fclose( fstab );
  3074.     }
  3076. #endif
  3077. }
  3079. void Flu_File_Chooser :: clear_history()
  3080. {
  3081.   currentHist = history;
  3082.   while( currentHist )
  3083.     {
  3084.       History *next = currentHist->next;
  3085.       delete currentHist;
  3086.       currentHist = next;
  3087.     }
  3088.   currentHist = history = NULL;
  3089.   backBtn->deactivate();
  3090.   forwardBtn->deactivate();
  3091. }
  3093. void Flu_File_Chooser :: addToHistory()
  3094. {
  3095.   // remember history
  3096.   // only store this path in the history if it is not the current directory
  3097.   if( currentDir.size() && !walkingHistory )
  3098.     {
  3099.       if( history == NULL )
  3100. {
  3101.   history = new History;
  3102.   currentHist = history;
  3103.   currentHist->path = currentDir;
  3104. }
  3105.       else if( currentHist->path != currentDir )
  3106. {
  3107.   // since we are adding a new path, delete everything after this path
  3108.   History *h = currentHist->next;
  3109.   while( h )
  3110.     {
  3111.       History *next = h->next;
  3112.       delete h;
  3113.       h = next;
  3114.     }
  3115.   currentHist->next = new History;
  3116.   currentHist->next->last = currentHist;
  3117.   currentHist = currentHist->next;
  3118.   currentHist->path = currentDir;
  3119. }
  3120.       History * h = history;
  3121.       while( h )
  3122. h = h->next;
  3123.     }
  3124.   walkingHistory = false;
  3126.   if( currentHist )
  3127.     {
  3128.       if( currentHist->last )
  3129. backBtn->activate();
  3130.       else
  3131. backBtn->deactivate();
  3132.       if( currentHist->next )
  3133. forwardBtn->activate();
  3134.       else
  3135. forwardBtn->deactivate();
  3136.     }
  3137. }
  3139. // treating the string as a '|' or ';' delimited sequence of patterns, strip them out and place in patterns
  3140. // return whether it is likely that "s" represents a regexp file-matching pattern
  3141. bool Flu_File_Chooser :: stripPatterns( FluSimpleString s, StringVector* patterns )
  3142. {
  3143.   if( s.size() == 0 )
  3144.     return false;
  3146.   char *tok = strtok( (char*)s.c_str(), "|;" );
  3147.   int tokens = 0;
  3148.   while( tok )
  3149.     {
  3150.       tokens++;
  3151.       if( tok[0] == ' ' )
  3152. tok++; // skip whitespace
  3153.       patterns->add( tok );
  3154.       tok = strtok( NULL, "|;" );
  3155.     }
  3157.   // if there is just a single token and it looks like it's not a pattern,
  3158.   // then it is probably JUST a filename, in which case it should not be
  3159.   // treated as a pattern
  3160.   if( _isProbablyAPattern( s.c_str() ) )
  3161.     return true;
  3162.   else if( tokens == 1 )
  3163.     {
  3164.       patterns->clear();
  3165.       return false;
  3166.     }
  3167.   else
  3168.     return true;
  3169. }
  3171. void Flu_File_Chooser :: cd( const char *path )
  3172. {
  3173.   Entry *entry;
  3174.   char cwd[1024];
  3176.   if( !path || path[0] == '' )
  3177.     {
  3178.       path = getcwd( cwd, 1024 );
  3179.       if( !path )
  3180. path = "./";
  3181.     }
  3183.   lastSelected = 0;
  3184.   previewGroup->file = "";
  3185.   previewGroup->redraw();
  3187.   filelist->scroll_to_beginning();
  3188.   filescroll->position( 0, 0 );
  3190.   bool listMode = !fileDetailsBtn->value() || streq( path, FAVORITES_UNIQUE_STRING );
  3192. #ifdef WIN32
  3193.   // refresh the drives if viewing "My Computer"
  3194.   if( strcmp( path, "/" ) == 0 )
  3195.     refreshDrives = true;
  3196. #endif
  3197.   buildFilesystemsCombo();
  3199.   filename.take_focus();
  3201.   trashBtn->deactivate();
  3202.   reloadBtn->activate();
  3203.   newDirBtn->activate();
  3204.   previewBtn->activate();
  3205.   hiddenFiles->activate();
  3206.   addFavoriteBtn->activate();
  3208.   resize( x(), y(), w(), h() );
  3209.   if( listMode )
  3210.     {
  3211.       //filecolumns->hide();
  3212.       //filescroll->hide();
  3213.       fileDetailsGroup->hide();
  3214.       filelist->show();
  3215.       filelist->parent()->resizable( filelist );
  3216.     }
  3217.   else
  3218.     {
  3219.       filelist->hide();
  3220.       //filecolumns->show();
  3221.       //filescroll->show();
  3222.       //filescroll->parent()->resizable( filescroll );
  3223.       fileDetailsGroup->show();
  3224.       fileDetailsGroup->parent()->resizable( fileDetailsGroup );
  3225.       updateEntrySizes();
  3226.     }
  3228.   FluSimpleString currentFile = filename.value();
  3229.   filescroll->position( 0, 0 );
  3230.   //Fl::focus( &filename );
  3231.   upDirBtn->activate();
  3232.   ok.activate();
  3234.   // check for favorites
  3235.   if( streq( path, FAVORITES_UNIQUE_STRING ) )
  3236.     {
  3237.       currentDir = FAVORITES_UNIQUE_STRING;
  3238.       addToHistory();
  3240.       newDirBtn->deactivate();
  3241.       previewBtn->deactivate();
  3242.       reloadBtn->deactivate();
  3243.       addFavoriteBtn->deactivate();
  3244.       hiddenFiles->deactivate();
  3245.       filesystems->input.value( "Favorites" );
  3247.       filelist->clear();
  3248.       filedetails->clear();
  3249.       if( listMode )
  3250. filelist->begin();
  3251.       else
  3252. filedetails->begin();
  3253.       for( int i = 1; i <= favoritesList->size(); i++ )
  3254. {
  3255.   entry = new Entry( favoritesList->text(i), ENTRY_FAVORITE, false/*fileDetailsBtn->value()*/, this );
  3256.   entry->updateSize();
  3257.   entry->updateIcon();
  3258. }
  3259.       if( listMode )
  3260. filelist->end();
  3261.       else
  3262. filedetails->end();
  3264.       redraw();
  3265.       ok.deactivate();
  3266.       return;
  3267.     }
  3268.   // check for the current directory
  3269.   else if( streq( path, "." ) || streq( path, "./" ) || streq( path, ".\" ) )
  3270.     {
  3271.       // do nothing. just rescan this directory
  3272.     }
  3273.   // check for parent directory
  3274.   else if( streq( path, ".." ) || streq( path, "../" ) || streq( path, "..\" ) )
  3275.     {
  3276.       // if we are viewing the favorites and want to go back a directory, go to the previous directory
  3277.       if( currentDir == FAVORITES_UNIQUE_STRING )
  3278. {
  3279.   backCB();
  3280.   return;
  3281. }
  3282. #ifdef WIN32
  3283.       // if we are at the desktop already, then we cannot go back any further
  3284.       if( currentDir == "/Desktop/" || currentDir == "/Desktop" )
  3285. {
  3286.   // do nothing
  3287. }
  3288.       else if( currentDir == userHome+"Desktop" || currentDir == userHome+"Desktop/" )
  3289. currentDir = userHome;
  3290.       // if we are viewing "My Computer" and want to go back a directory, go to the desktop
  3291.       else if( currentDir == "/" )
  3292. currentDir = userHome + "Desktop";
  3293.       // if we are at a top level drive, go to "My Computer" (i.e. "/")
  3294.       else if( currentDir[1] == ':' && currentDir[3] == '' )
  3295. currentDir = "/";
  3296.       else
  3297. #else
  3298. // if the current directory is already as far back as we can go, ignore
  3299. if( currentDir != "/" )
  3300. #endif
  3301.   {
  3302.     // strip everything off the end to the next "/"
  3303.     int end = currentDir.size()-1;
  3304.     currentDir[end] = '';
  3305.     while( currentDir[end] != '/' )
  3306.       {
  3307. currentDir[end] = '';
  3308. end--;
  3309.       }
  3310.   }
  3311.     }
  3312.   // check for absolute path
  3313. #ifdef WIN32
  3314.   else if( path[1] == ':' || path[0] == '/' )
  3315. #else
  3316.   else if( path[0] == '/' )
  3317. #endif
  3318.     {
  3319.       currentDir = path;
  3320.     }
  3321.   // else relative path
  3322.   else
  3323.     {
  3324.       // concatenate currentDir with path to make an absolute path
  3325.       currentDir += path;
  3326.     }
  3328.   int numDirs = 0, numFiles = 0;
  3329.   filelist->clear();
  3330.   filedetails->clear();
  3332.   cleanupPath( currentDir );
  3334. #ifdef WIN32
  3335.   bool isTopDesktop = ( currentDir == "/Desktop" || currentDir == "/Desktop/" );
  3336.   bool isDesktop = correctPath( currentDir );
  3337.   if( isTopDesktop )
  3338.     upDirBtn->deactivate();
  3339. #else
  3340.   correctPath( currentDir );
  3341.   if( currentDir == "/" )
  3342.     upDirBtn->deactivate();
  3343. #endif
  3345. #ifdef WIN32
  3346.   bool root = false;
  3347.   // check for my computer
  3348.   if( currentDir == "/" )
  3349.     {
  3350.       ok.deactivate();
  3351.       root = true;
  3352.       if( listMode )
  3353. filelist->begin();
  3354.       else
  3355. filedetails->begin();
  3356.       for( int i = 0; i < 26; i++ )
  3357. {
  3358.   if( drives[i][0] != '' )
  3359.     {
  3360.       char drive[] = "A:/";
  3361.       drive[0] = 'A' + i;
  3362.       entry = new Entry( drive, ENTRY_DRIVE, fileDetailsBtn->value(), this );
  3363.       switch( driveTypes[i] )
  3364. {
  3365. case DRIVE_REMOVABLE: entry->description = "Floppy Disk"; break;
  3366. case DRIVE_FIXED: entry->description = "Local Disk"; break;
  3367. case DRIVE_CDROM: entry->description = "Compact Disk"; break;
  3368. case DRIVE_REMOTE: entry->description = "Network Disk"; break;
  3369. case DRIVE_RAMDISK: entry->description = "RAM Disk"; break;
  3370. }
  3371.       entry->icon = driveIcons[i];
  3372.       entry->altname = drives[i];
  3373.       entry->updateSize();
  3374.       entry->updateIcon();
  3375.     }
  3376. }
  3377.       if( listMode )
  3378. filelist->end();
  3379.       else
  3380. filedetails->end();
  3382.       redraw();
  3383.     }
  3384.   // check for desktop. if so, add My Computer and My Documents
  3385.   else if( isDesktop )
  3386.     {
  3387.       if( listMode )
  3388. filelist->begin();
  3389.       else
  3390. filedetails->begin();
  3391.       entry = new Entry( "My Documents", ENTRY_MYDOCUMENTS, fileDetailsBtn->value(), this );
  3392.       entry->updateSize();     
  3393.       entry->updateIcon();
  3394.       entry = new Entry( "My Computer", ENTRY_MYCOMPUTER, fileDetailsBtn->value(), this );
  3395.       entry->updateSize();     
  3396.       entry->updateIcon();
  3397.       if( listMode )
  3398. filelist->end();
  3399.       else
  3400. filedetails->end();
  3401.       numDirs += 2;
  3402.     }
  3403. #endif
  3405.   // see if currentDir is in fact a directory
  3406.   // if so, make sure there is a trailing "/" and we're done
  3407.   if( fl_filename_isdir( currentDir.c_str() ) || currentDir=="/" )
  3408.     {
  3409.       if( currentDir[strlen(currentDir.c_str())-1] != '/' )
  3410. currentDir += "/";
  3411. #ifdef WIN32
  3412.       if( filename.value()[1] != ':' )
  3413. #else
  3414.       if( filename.value()[0] != '/' )
  3415. #endif
  3416. filename.value( "" );
  3417.       currentFile = "";
  3418.     }
  3420.   // now we have the current directory and possibly a file at the end
  3421.   // try to split into path and file
  3422.   if( currentDir[currentDir.size()-1] != '/' )
  3423.     {
  3424.       char *lastSlash = (char*)strrchr( currentDir.c_str(), '/' );
  3425.       if( lastSlash )
  3426. {
  3427.   currentFile = lastSlash+1;
  3428.   lastSlash[1] = '';
  3429. }
  3430.     }
  3431.   // make sure currentDir ends in '/'
  3432.   if( currentDir[currentDir.size()-1] != '/' )
  3433.     currentDir += "/";
  3435. #ifdef WIN32
  3436.   {
  3437.     FluSimpleString tmp = currentDir;
  3438.     if( isTopDesktop )
  3439.       currentDir = "/Desktop/";
  3440.     addToHistory();
  3441.     if( isTopDesktop )
  3442.       currentDir = tmp;
  3443.   }
  3444. #else
  3445.   addToHistory();
  3446. #endif
  3448.   delayedCd = "./";
  3450. #ifdef WIN32
  3451.   // set the filesystems input value
  3452.   // check for drives
  3453.   if( currentDir[1] == ':' && currentDir[3] == '' )
  3454.     {
  3455.       filesystems->input.value( currentDir.c_str() );
  3456.     }
  3457.   else if( currentDir == "/" )
  3458.     filesystems->input.value( "My Computer" );
  3459.   else
  3460. #endif
  3461.     {
  3462.       filesystems->input.value( currentDir.c_str() );
  3463. #ifdef WIN32
  3464.       FluSimpleString treePath = "/Desktop/My Computer/" + currentDir;
  3465.       Flu_Tree_Browser::Node *n = filesystems->tree.add( treePath.c_str() );
  3466.       if( currentDir == userHome + "Desktop/" )
  3467. n->branch_icon( &little_desktop );
  3468.       if( currentDir == userHome + "My Documents/" )
  3469. n->branch_icon( &documents );
  3470. #else
  3471.       filesystems->tree.add( currentDir.c_str() );
  3472. #endif
  3473.     }
  3475. #ifdef WIN32
  3476.   if( root )
  3477.     return;
  3478. #endif
  3480.   FluSimpleString pathbase, fullpath;
  3481.   bool isDir, isCurrentFile = false;
  3482.   const char *lastAddedFile = NULL, *lastAddedDir = NULL;
  3484.   pathbase = currentDir;
  3486.   // take the current pattern and make a list of filter pattern strings
  3487.   StringVector currentPatterns;
  3488.   {
  3489.     FluSimpleString pat = patterns[filePattern->list.value()-1];
  3490.     while( pat.size() )
  3491.       {
  3492. int p = pat.find( ',' );
  3493. if( p == -1 )
  3494.   {
  3495.     if( pat != "*" )
  3496.       pat = "*." + pat;
  3497.     currentPatterns.add( pat );
  3498.     break;
  3499.   }
  3500. else
  3501.   {
  3502.     FluSimpleString s = pat.c_str() + p + 1;
  3503.     pat[p] = '';
  3504.     if( pat != "*" )
  3505.       pat = "*." + pat;
  3506.     currentPatterns.add( pat );
  3507.     pat = s;
  3508.   }
  3509.       }
  3510.   }
  3512.   // add any user-defined patterns
  3513.   StringVector userPatterns;
  3514.   // if the user just hit <Tab> but the filename input area is empty,
  3515.   // then use the current patterns
  3516.   if( !filenameTabCallback || currentFile != "*" )
  3517.     stripPatterns( currentFile, &userPatterns );
  3519.   // read the directory
  3520.   dirent **e;
  3521.   char *name;
  3522.   int num = fl_filename_list( pathbase.c_str(), &e );
  3523.   if( num > 0 )
  3524.     {
  3525.       int i;
  3526.       for( i = 0; i < num; i++ )
  3527. {
  3528.   name = e[i]->d_name;
  3530.   // ignore the "." and ".." names
  3531.   if( strcmp( name, "." ) == 0 || strcmp( name, ".." ) == 0 ||
  3532.       strcmp( name, "./" ) == 0 || strcmp( name, "../" ) == 0 ||
  3533.       strcmp( name, ".\" ) == 0 || strcmp( name, "..\" ) == 0 )
  3534.     continue;
  3536.   // if 'name' ends in '/', remove it
  3537.   if( name[strlen(name)-1] == '/' )
  3538.     name[strlen(name)-1] = '';
  3540.   // file or directory?
  3541.   fullpath = pathbase + name;
  3542.   isDir = ( fl_filename_isdir( fullpath.c_str() ) != 0 );
  3544.   // was this file specified explicitly?
  3545.   isCurrentFile = ( currentFile == name );
  3547. #ifndef WIN32
  3548.   // filter hidden files
  3549.   if( !isCurrentFile && !hiddenFiles->value() && ( name[0] == '.' ) )
  3550.     continue;
  3551. #endif
  3553.   // only directories?
  3554.   if( (selectionType & DIRECTORY) && !isDir )
  3555.     continue;
  3557.   //if( !isDir /*!isCurrentFile*/ )
  3558.     {
  3559.       // filter according to the user pattern in the filename input
  3560.       if( userPatterns.size() )
  3561. {
  3562.   bool cull = true;
  3563.   for( unsigned int i = 0; i < userPatterns.size(); i++ )
  3564.     {
  3565.       if( flu_filename_match( name, userPatterns[i].c_str() ) != 0 )
  3566. {
  3567.   cull = false;
  3568.   break;
  3569. }
  3570.     }
  3571.   if( cull )
  3572.     {
  3573.       // only filter directories if someone just hit <TAB>
  3574.       if( !isDir || ( isDir && filenameTabCallback ) )
  3575. continue;
  3576.     }
  3577. }
  3578.       // filter files according to the current pattern
  3579.       else
  3580. {
  3581.   bool cull = true;
  3582.   for( unsigned int i = 0; i < currentPatterns.size(); i++ )
  3583.     {
  3584.       if( flu_filename_match( name, currentPatterns[i].c_str() ) != 0 )
  3585. {
  3586.   cull = false;
  3587.   break;
  3588. }
  3589.     }
  3590.   if( cull )
  3591.     {
  3592.       // only filter directories if someone just hit <TAB>
  3593.       if( !isDir || ( isDir && filenameTabCallback ) )
  3594. continue;
  3595.     }
  3596. }
  3597.     }
  3599.   // add directories at the beginning, and files at the end
  3600.   entry = new Entry( name, isDir?ENTRY_DIR:ENTRY_FILE, fileDetailsBtn->value(), this );
  3601.   if( isDir )
  3602.     {
  3603.       if( listMode )
  3604. filelist->insert( *entry, 0 );
  3605.       else
  3606. filedetails->insert( *entry, 0 );
  3607.       numDirs++;
  3608.       lastAddedDir = entry->filename.c_str();
  3609.     }
  3610.   else
  3611.     {
  3612.       if( listMode )
  3613. filelist->add( entry );
  3614.       else
  3615. filedetails->add( entry );
  3616.       numFiles++;
  3617.       lastAddedFile = entry->filename.c_str();
  3618.     }
  3620.   // get some information about the file
  3621.   struct stat s;
  3622.   ::stat( fullpath.c_str(), &s );
  3624.   // store size as human readable and sortable integer
  3625.   entry->isize = s.st_size;
  3626.   if( isDir && entry->isize == 0 )
  3627.     entry->filesize = "";
  3628.   else
  3629.     {
  3630.       char buf[32];
  3631.       /*
  3632. if( (entry->isize >> 40) > 0 ) // terrabytes
  3633. {
  3634. double TB = double(entry->isize)/double(1<<40);
  3635. sprintf( buf, "%.1f TB", TB );
  3636. }
  3637.       */
  3638.       if( (entry->isize >> 30) > 0 ) // gigabytes
  3639. {
  3640.   double GB = double(entry->isize)/double(1<<30);
  3641.   sprintf( buf, "%.1f GB", GB );
  3642. }
  3643.       else if( (entry->isize >> 20) > 0 ) // megabytes
  3644. {
  3645.   double MB = double(entry->isize)/double(1<<20);
  3646.   sprintf( buf, "%.1f MB", MB );
  3647. }
  3648.       else if( (entry->isize >> 10) > 0 ) // kilabytes
  3649. {
  3650.   double KB = double(entry->isize)/double(1<<10);
  3651.   sprintf( buf, "%.1f KB", KB );
  3652. }
  3653.       else // bytes
  3654. {
  3655.   sprintf( buf, "%d bytes", (int)entry->isize );
  3656. }
  3657.       entry->filesize = buf;
  3658.     }
  3660.   // store date as human readable and sortable integer
  3661.   entry->date = formatDate( ctime( &s.st_mtime ) );//ctime( &s.st_mtime );
  3662.   entry->idate = s.st_mtime;
  3664.   // convert the permissions into UNIX style rwx-rwx-rwx (user-group-others)
  3665.   /*
  3666.     unsigned int p = s.st_mode;
  3667.     entry->pU = bool(p&S_IRUSR)<<2 | bool(p&S_IWUSR)<<1 | bool(p&S_IXUSR);
  3668.     entry->pG = bool(p&S_IRGRP)<<2 | bool(p&S_IWGRP)<<1 | bool(p&S_IXGRP);
  3669.     entry->pO = bool(p&S_IROTH)<<2 | bool(p&S_IWOTH)<<1 | bool(p&S_IXOTH);
  3670.     char* perms[8] = { "---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx" };
  3671.     entry->permissions = perms[entry->pU];
  3672.     entry->permissions += perms[entry->pG];
  3673.     entry->permissions += perms[entry->pO];
  3674.   */
  3676.   entry->updateSize();
  3677.   entry->updateIcon();
  3679.   if( isCurrentFile )
  3680.     {
  3681.       filename.value( name );
  3682.       entry->selected = true;
  3683.       lastSelected = entry;
  3684.       if( entry->type == ENTRY_FILE )
  3685. previewGroup->file = currentDir + name;
  3686.       previewGroup->redraw();
  3687.       filelist->scroll_to( entry );
  3688.       filedetails->scroll_to( entry );
  3689.       //break;
  3690.     }
  3691. }
  3693.       for( i = 0; i < num; i++ )
  3694. free((void*)(e[i]));
  3695.       free((void*)e);
  3696.     }
  3698.   // sort the files: directories first, then files
  3699.   if( listMode )
  3700.     filelist->sort( numDirs );
  3701.   else
  3702.     filedetails->sort( numDirs );
  3704.   // see if the user pushed <Tab> in the filename input field
  3705.   if( filenameTabCallback )
  3706.     {
  3707.       filenameTabCallback = false;
  3709.       FluSimpleString prefix = commonStr();
  3711.       if( numDirs == 1 && 
  3712.   currentFile == (FluSimpleString(lastAddedDir)+"*") )
  3713. {
  3714.   delayedCd = lastAddedDir;
  3715.   Fl::add_timeout( 0.0f, Flu_File_Chooser::delayedCdCB, this );
  3716. }
  3718.       if( numDirs == 1 && numFiles == 0 )
  3719. {
  3720. #ifdef WIN32
  3721.   if( filename.value()[1] == ':' )
  3722. #else
  3723.   if( filename.value()[0] == '/' )
  3724. #endif
  3725.     {
  3726.       FluSimpleString s = currentDir + lastAddedDir + "/";
  3727.       filename.value( s.c_str() );
  3728.     }
  3729.   else
  3730.     filename.value( lastAddedDir );
  3731. }
  3732.       else if( numFiles == 1 && numDirs == 0 )
  3733. {
  3734. #ifdef WIN32
  3735.   if( filename.value()[1] == ':' )
  3736. #else
  3737.   if( filename.value()[0] == '/' )
  3738. #endif
  3739.     {
  3740.       FluSimpleString s = currentDir + lastAddedFile;
  3741.       filename.value( s.c_str() );
  3742.     }
  3743.   else
  3744.     filename.value( lastAddedFile );
  3745. }
  3746.       else if( prefix.size() >= currentFile.size() )
  3747. {
  3748. #ifdef WIN32
  3749.   if( filename.value()[1] == ':' )
  3750. #else
  3751.   if( filename.value()[0] == '/' )
  3752. #endif
  3753.     {
  3754.       FluSimpleString s = currentDir + prefix;
  3755.       filename.value( s.c_str() );
  3756.     }
  3757.   else
  3758.     filename.value( prefix.c_str() );
  3759. }
  3761.       if( currentFile == "*" && 
  3762. #ifdef WIN32
  3763.   filename.value()[1] != ':' )
  3764. #else
  3765.   filename.value()[0] != '/' )
  3766. #endif
  3767.         {
  3768.   filename.value( "" );
  3769. }
  3770.     }
  3772.   // see if the user pushed <Enter> in the filename input field
  3773.   if( filenameEnterCallback )
  3774.     {
  3775.       filenameEnterCallback = false;
  3777. #ifdef WIN32
  3778.       if( filename.value()[1] == ':' )
  3779. #else
  3780.       if( filename.value()[0] == '/' )
  3781. #endif
  3782. filename.value( "" );
  3784.       //if( isCurrentFile && numFiles == 1 )
  3785.       if( !_isProbablyAPattern( filename.value() ) )
  3786. okCB();
  3787.     }
  3789.   if( _isProbablyAPattern( filename.value() ) )
  3790.     filename.position( 0, filename.size() );
  3791.   else
  3792.     filename.position( filename.size(), filename.size() );
  3793.   filename.take_focus();
  3795.   redraw();
  3796. }
  3798. // find the prefix string that is common to all entries in the list
  3799. FluSimpleString Flu_File_Chooser :: commonStr()
  3800. {
  3801.   FluSimpleString common;
  3802.   int index = 0;
  3803.   const char* name;
  3804.   int len, i;
  3805.   Fl_Group *g = getEntryGroup();
  3806.   for(;;)
  3807.     {
  3808.       bool allSkipped = true;
  3809.       for( i = 0; i < g->children(); i++ )
  3810. {
  3811.   name = ((Entry*)g->child(i))->filename.c_str();
  3812.   len = strlen( name );
  3813.   if( index >= len )
  3814.     continue;
  3815.   allSkipped = false;
  3816.   if( i == 0 )
  3817.     common.push_back( name[index] );
  3818.   else if( toupper(common[index]) != toupper(name[index]) )
  3819.     {
  3820.       common[index] = '';
  3821.       return common;
  3822.     }
  3823. }
  3824.       if( allSkipped )
  3825. break;
  3826.       index++;
  3827.     }
  3828.   return common;
  3829. }
  3831. static const char* _flu_file_chooser( const char *message, const char *pattern, const char *filename, int type )
  3832. {
  3833.   static Flu_File_Chooser *fc = NULL;
  3834.   static FluSimpleString retname;
  3836.   if( !fc )
  3837.     {
  3838.       fc = new Flu_File_Chooser( filename, pattern, type, message );
  3839.     }
  3840.   else
  3841.     {
  3842.       fc->clear_history();
  3843.       fc->label( message );
  3844.       if( !filename || filename[0] == '' )
  3845. {
  3846.   if( (!pattern || !fc->filter() || strcmp(pattern,fc->filter())) && fc->value() )
  3847.     {
  3848.       // if pattern is different, remove name but leave old directory:
  3849.       retname = fc->value();
  3850.       char *p = (char*)strrchr( retname.c_str(), '/' );
  3851.       if( p )
  3852. {
  3853.   // If the filename is "/foo", then the directory will be "/", not ""
  3854.   if( p == retname.c_str() )
  3855.     retname[1] = '';
  3856.   else
  3857.     p[1] = '';
  3858. }
  3859.     }
  3860.   fc->filter( pattern );
  3861.   fc->value( retname.c_str() );
  3862. }
  3863.       else
  3864. {
  3865.   fc->filter( pattern );
  3866.   fc->value( filename );
  3867. }
  3868.     }
  3870.   fc->set_modal();
  3871.   fc->show();
  3873.   while( fc->shown() )
  3874.     Fl::wait( 0.01 );
  3876.   if( fc->value() )
  3877.     {
  3878.       retname = fc->value();
  3879.       return retname.c_str();
  3880.     }
  3881.   else
  3882.     return 0;
  3883. }
  3885. const char* flu_file_chooser( const char *message, const char *pattern, const char *filename )
  3886. {
  3887.   return _flu_file_chooser( message, pattern, filename, Flu_File_Chooser::SINGLE );
  3888. }
  3890. const char* flu_dir_chooser( const char *message, const char *filename )
  3891. {
  3892.   return _flu_file_chooser( message, "*", filename, Flu_File_Chooser::DIRECTORY );
  3893. }