Flu_File_Chooser.h

// $Id: Flu_File_Chooser.h,v 1.65 2005/07/29 14:32:09 jbryan Exp $

/***************************************************************
 *                FLU - FLTK Utility Widgets 
 *  Copyright (C) 2002 Ohio Supercomputer Center, Ohio State University
 *
 * This file and its content is protected by a software license.
 * You should have received a copy of this license with this file.
 * If not, please contact the Ohio Supercomputer Center immediately:
 * Attn: Jason Bryan Re: FLU 1224 Kinnear Rd, Columbus, Ohio 43212
 * 
 ***************************************************************/



#ifndef _FLU_FILE_CHOOSER_H
#define _FLU_FILE_CHOOSER_H

#include <FL/Fl_Double_Window.H>
#include <FL/Fl_Input.H>
#include <FL/Fl_Menu_Button.H>
#include <FL/Fl_Tile.H>
#include <FL/Fl_Pack.H>
#include <FL/Fl_Scroll.H>
#include <FL/Fl_Check_Button.H>

#include "FLU/Flu_Button.h"
#include "FLU/Flu_Return_Button.h"
#include "FLU/Flu_Wrap_Group.h"
#include "FLU/Flu_Combo_Tree.h"
#include "FLU/Flu_Combo_List.h"
#include "FLU/flu_export.h"
#include "FLU/FluSimpleString.h"
#include "FLU/FluVectorClass.h"

FluMakeVectorClass( FluSimpleString, FluStringVector );

FLU_EXPORT const char* flu_file_chooser( const char *message, const char *pattern, const char *filename );
FLU_EXPORT int flu_multi_file_chooser( const char *message, const char *pattern, const char *filename, FluStringVector *filelist );
FLU_EXPORT const char* flu_save_chooser( const char *message, const char *pattern, const char *filename );
FLU_EXPORT const char* flu_dir_chooser( const char *message, const char *filename );
FLU_EXPORT const char* flu_dir_chooser( const char *message, const char *filename, bool showFiles );
FLU_EXPORT const char* flu_file_and_dir_chooser( const char *message, const char *filename );

class FLU_EXPORT Flu_File_Chooser : public Fl_Double_Window
{

  friend class FileInput;
  class FileInput : public Fl_Input
    {
    public:
      FileInput( int x, int y, int w, int h, const char *l, Flu_File_Chooser *c );
      ~FileInput();

      int handle( int event );
    protected:
      Flu_File_Chooser *chooser;
    };

 public:


  static FluSimpleString favoritesTxt;
  static FluSimpleString desktopTxt;
  static FluSimpleString myComputerTxt;
  static FluSimpleString myDocumentsTxt;

  static FluSimpleString filenameTxt;
  static FluSimpleString okTxt;
  static FluSimpleString cancelTxt;
  static FluSimpleString locationTxt;
  static FluSimpleString showHiddenTxt;
  static FluSimpleString fileTypesTxt;
  static FluSimpleString directoryTxt;
  static FluSimpleString allFilesTxt;
  static FluSimpleString defaultFolderNameTxt;

  static FluSimpleString backTTxt;
  static FluSimpleString forwardTTxt;
  static FluSimpleString upTTxt;
  static FluSimpleString reloadTTxt;
  static FluSimpleString trashTTxt;
  static FluSimpleString newDirTTxt;
  static FluSimpleString addFavoriteTTxt;
  static FluSimpleString previewTTxt;
  static FluSimpleString listTTxt;
  static FluSimpleString wideListTTxt;
  static FluSimpleString detailTTxt;

  static FluSimpleString detailTxt[4];
  static FluSimpleString contextMenuTxt[3];
  static FluSimpleString diskTypesTxt[6];

  static FluSimpleString createFolderErrTxt;
  static FluSimpleString deleteFileErrTxt;
  static FluSimpleString fileExistsErrTxt;
  static FluSimpleString renameErrTxt;


  class FLU_EXPORT PreviewWidgetBase : public Fl_Group
    {
    public:
      PreviewWidgetBase();
      virtual ~PreviewWidgetBase();
      virtual int preview( const char *filename ) = 0;
    };

  enum { 
    ENTRY_NONE = 1,         
    ENTRY_DIR = 2,          
    ENTRY_FILE = 4,         
    ENTRY_FAVORITE = 8,     
    ENTRY_DRIVE = 16,       
    ENTRY_MYDOCUMENTS = 32, 
    ENTRY_MYCOMPUTER = 64   
  };

  enum { 
    SINGLE = 0,            
    MULTI = 1,             
    DIRECTORY = 4,         
    DEACTIVATE_FILES = 8,  
    SAVING = 16,           
    STDFILE = 32           
  };

  struct FileTypeInfo
  {
    Fl_Image *icon;
    FluSimpleString extensions;
    FluSimpleString type, shortType;
  };

  Flu_File_Chooser( const char *path, const char *pattern, int type, const char *title );

  ~Flu_File_Chooser();


  static void add_context_handler( int type, const char *ext, const char *name,
                                   void (*cb)(const char*,int,void*), void *cbd );

  static void add_preview_handler( PreviewWidgetBase *w );


  static void add_type( const char *extensions, const char *short_description, Fl_Image *icon = NULL );

  inline void allow_file_editing( bool b )
    { fileEditing = b; }

  inline bool allow_file_editing() const
    { return fileEditing; }

  inline void case_insensitive_sort( bool b )
    { caseSort = !b; }

  inline bool case_insensitive_sort() const
    { return !caseSort; }

  void cd( const char *path );

  void clear_history();

  int count();

  inline void default_file_icon( Fl_Image* i )
    { defaultFileIcon = i; }

  inline void directory( const char *d )
    { cd( d ); }

  inline void filter( const char *p )
    { pattern( p ); }

  inline const char* filter() const
    { return pattern(); }

  static FileTypeInfo *find_type( const char *extension );

  inline const char* get_current_directory() const
    { return currentDir.c_str(); }

  int handle( int event );

  void pattern( const char *p );

  inline const char* pattern() const
    { return rawPattern.c_str(); }

  inline void preview( bool b )
    { previewBtn->value(b); previewBtn->do_callback(); }

  inline int preview() const
    { return previewBtn->value(); }

  inline void rescan() { reloadCB(); }

  void resize( int x, int y, int w, int h );

  void select_all();

  inline void set_sort_function( int (*cb)(const char*,const char*) )
    { customSort = cb; rescan(); }

  inline void type( int t )
    { selectionType = t; rescan(); }

  inline int type( int t ) const
    { return selectionType; }

  void unselect_all();

  void value( const char *v );

  const char *value();

  const char *value( int n );

  FileInput filename;
  // the <Enter> key behavior is not correct for versions before 1.1.4rc2
#if FL_MAJOR_VERSION >= 1 && FL_MINOR_VERSION >= 1 && FL_PATCH_VERSION >= 4
  Flu_Return_Button ok;
#else
  Flu_Button ok;
#endif
  Flu_Button cancel;

  // apparently there is a bug in VC6 that prevents friend classes from accessing
  // non-public members. stupid windows
  // several other compilers were reported to have a problem with this too, so 
  // i'm just making the whole class public to eliminate potential problems.
  // bad c++ - i know...
  //#ifndef WIN32
  //protected:
  //#endif

  class ContextHandler
    {
    public:
      FluSimpleString ext, name;
      int type;
      void (*callback)(const char*,int,void*);
      void *callbackData;
      inline ContextHandler& operator =( const ContextHandler &c )
      { ext = c.ext; name = c.name; type = c.type; callback = c.callback; callbackData = c.callbackData; return *this; }
    };
  FluMakeVectorClass( ContextHandler, ContextHandlerVector );
  static ContextHandlerVector contextHandlers;

  typedef PreviewWidgetBase* pPreviewWidgetBase;
  FluMakeVectorClass( pPreviewWidgetBase, PreviewHandlerVector );
  static PreviewHandlerVector previewHandlers;

  Fl_Check_Button *hiddenFiles;
  Flu_Combo_Tree *location;

  inline static void _backCB( Fl_Widget *w, void *arg )
    { ((Flu_File_Chooser*)arg)->backCB(); }
  void backCB();

  inline static void _forwardCB( Fl_Widget *w, void *arg )
    { ((Flu_File_Chooser*)arg)->forwardCB(); }
  void forwardCB();

  inline static void _sortCB( Fl_Widget *w, void *arg )
    { ((Flu_File_Chooser*)arg)->sortCB( w ); }
  void sortCB( Fl_Widget *w );

  inline static void _previewCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->previewCB(); }
  void previewCB();

  inline static void _listModeCB( Fl_Widget *w, void *arg )
    { ((Flu_File_Chooser*)arg)->listModeCB(); }
  void listModeCB();

  inline static void _filenameCB( Fl_Widget *w, void *arg )
    { ((Flu_File_Chooser*)arg)->filenameCB(); }
  void filenameCB();

  inline static void _locationCB( Fl_Widget *w, void *arg )
    { ((Flu_File_Chooser*)arg)->locationCB( ((Flu_Combo_Tree*)w)->value() ); }
  void locationCB( const char *path );

  inline static void _locationQJCB( Fl_Widget *w, void *arg )
    { ((Flu_File_Chooser*)arg)->delay_cd( ((Fl_Button*)w)->label() ); }

  void delay_cd( FluSimpleString path );

  inline static void delayedCdCB( void *arg )
    { ((Flu_File_Chooser*)arg)->cd( ((Flu_File_Chooser*)arg)->delayedCd.c_str() ); }

  inline static void selectCB( void *arg )
    { ((Flu_File_Chooser*)arg)->okCB(); }

  inline static void _cancelCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->cancelCB(); }
  void cancelCB();

  inline static void _okCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->okCB(); }
  void okCB();

  inline static void _trashCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->trashCB(); }
  void trashCB( bool recycle = true );

  inline static void _newFolderCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->newFolderCB(); }
  void newFolderCB();

  inline static void upDirCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->cd( "../" ); }

  inline static void reloadCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->reloadCB(); }
  void reloadCB();

  inline static void _homeCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->homeCB(); }
  void homeCB();

  inline static void _desktopCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->desktopCB(); }
  void desktopCB();

  inline static void _favoritesCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->favoritesCB(); }
  void favoritesCB();

  inline static void _myComputerCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->myComputerCB(); }
  void myComputerCB();

  inline static void _addToFavoritesCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->addToFavoritesCB(); }
  void addToFavoritesCB();

  inline static void _documentsCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->documentsCB(); }
  void documentsCB();

  inline static void _hideCB( Fl_Widget*, void *arg )
    { ((Flu_File_Chooser*)arg)->hideCB(); }
  void hideCB();
  void do_callback();

  enum {
    SORT_NAME = 1,
    SORT_SIZE = 2,
    SORT_TYPE = 4,
    SORT_DATE = 8,
    SORT_REVERSE = 16 
  };
  static void _qSort( int how, bool caseSort, Fl_Widget **array, int low, int high );

  friend class Entry;
  class Entry : public Fl_Input
    {
    public:
      Entry( const char* name, int t, bool d, Flu_File_Chooser *c );
      ~Entry();

      int handle( int event );
      void draw();

      void updateSize();
      void updateIcon();

      FluSimpleString filename, date, filesize, shortname, 
        description, shortDescription, toolTip, altname;
      //FluSimpleString permissions;
      //unsigned char pU, pG, pO; // 3-bit unix style permissions
      unsigned int type, idate;
      unsigned long isize;
      bool selected;
      int editMode;
      Flu_File_Chooser *chooser;
      Fl_Image *icon;

      int nameW, typeW, sizeW, dateW;
      bool details;

      inline static void _inputCB( Fl_Widget *w, void *arg )
        { ((Entry*)arg)->inputCB(); }
      void inputCB();

      inline static void _editCB( void *arg )
        { ((Entry*)arg)->editCB(); }
      void editCB();
    };

  friend class FileList;
  class FileList : public Flu_Wrap_Group
    {
    public:
      FileList( int x, int y, int w, int h, Flu_File_Chooser *c );
      ~FileList();

      int handle( int event );
      void sort( int numDirs = -1 );

      inline Fl_Widget *child(int n) const
        { return Flu_Wrap_Group::child(n); }

      inline int children() const
        { return Flu_Wrap_Group::children(); }

      int numDirs;
      Flu_File_Chooser *chooser;
    };

  friend class FileDetails;
  class FileDetails : public Fl_Pack
    {
    public:
      FileDetails( int x, int y, int w, int h, Flu_File_Chooser *c );
      ~FileDetails();

      int handle( int event );
      void sort( int numDirs = -1 );

      void scroll_to( Fl_Widget *w );
      Fl_Widget* next( Fl_Widget* w );
      Fl_Widget* previous( Fl_Widget* w );

      int numDirs;
      Flu_File_Chooser *chooser;
    };

  friend class CBTile;
  class CBTile : public Fl_Tile
    {
    public:
      CBTile( int x, int y, int w, int h, Flu_File_Chooser *c );
      int handle( int event );
      Flu_File_Chooser *chooser;
    };

  friend class FileColumns;
  class FileColumns : public Fl_Tile
    {
    public:
      FileColumns( int x, int y, int w, int h, Flu_File_Chooser *c );
      ~FileColumns();

      int handle( int event );
      void resize( int x, int y, int w, int h );
      Flu_File_Chooser *chooser;
      int W1, W2, W3, W4;
    };

  friend class PreviewTile;
  class PreviewTile : public Fl_Tile
    {
    public:
      PreviewTile( int x, int y, int w, int h, Flu_File_Chooser *c );
      int handle( int event );
      Flu_File_Chooser *chooser;
      int last;
    };

  class ImgTxtPreview : public PreviewWidgetBase
    {
    public:
      int preview( const char *filename );
      unsigned char previewTxt[1024];
    };

  friend class PreviewGroup;
  class PreviewGroup : public Fl_Group
    {
    public:
      PreviewGroup( int x, int y, int w, int h, Flu_File_Chooser *c );
      void draw();
      Flu_File_Chooser *chooser;
      FluSimpleString lastFile, file;
      PreviewWidgetBase* handled;
    };

  Fl_Group *getEntryGroup();
  Fl_Group *getEntryContainer();

  void win2unix( FluSimpleString &s );

  void cleanupPath( FluSimpleString &s );

  bool correctPath( FluSimpleString &path );

  void updateEntrySizes();

  void buildLocationCombo();

  void updateLocationQJ();

  void addToHistory();

  FluSimpleString formatDate( const char *d );

  void recursiveScan( const char *dir, FluStringVector *files );

  bool stripPatterns( FluSimpleString s, FluStringVector* patterns );

  int popupContextMenu( Entry *entry );

  FluSimpleString commonStr();

  static ImgTxtPreview *imgTxtPreview;

  static int (*customSort)(const char*,const char*);

  PreviewGroup *previewGroup;
  PreviewTile *previewTile;
  Fl_Group *fileGroup, *locationQuickJump;
  Fl_Menu_Button entryPopup;
  Fl_Image *defaultFileIcon;
  Entry *lastSelected;
  FileList *filelist;
  FileColumns *filecolumns;
  Fl_Group *fileDetailsGroup;
  Fl_Scroll *filescroll;
  FileDetails *filedetails;
  Flu_Button *detailNameBtn, *detailTypeBtn, *detailSizeBtn, *detailDateBtn;
  FluSimpleString currentDir, delayedCd, rawPattern;
  FluSimpleString configFilename;
  FluSimpleString userHome, userDesktop, userDocs;
  FluSimpleString drives[26];
  Fl_Pixmap* driveIcons[26];
  Flu_Button *fileListBtn, *fileListWideBtn, *fileDetailsBtn, *backBtn, *forwardBtn, *upDirBtn, *trashBtn,
    *newDirBtn, *addFavoriteBtn, *reloadBtn, *previewBtn;
  Fl_Browser *favoritesList;
  Flu_Combo_List *filePattern;
  int selectionType;
  bool filenameEnterCallback, filenameTabCallback, walkingHistory, caseSort, fileEditing;
  int sortMethod;

  FluStringVector patterns;

  static FileTypeInfo *types;
  static int numTypes;
  static int typeArraySize;

  static FluSimpleString dArrow[4];
  static FluSimpleString uArrow[4];

#ifdef WIN32
  unsigned int driveMask;
  unsigned int driveTypes[26];
  FluSimpleString volumeNames[26];
  bool refreshDrives;
#endif

  class History
  {
  public:
    History() { last = next = NULL; }
    FluSimpleString path;
    History *last, *next;
  };

  History *history, *currentHist;

  Fl_Callback *_callback;
  void *_userdata;

};

#endif

---