home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / filedlg.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  18KB  |  764 lines
  1. // -*- C++ -*-
  2. /* This file is part of
  3. * ======================================================
  4. * 
  5. *           LyX, The Document Processor
  6. *        
  7. *           Copyright (C) 1995 Matthias Ettrich
  8. *           Copyright (C) 1995-1998 The LyX Team.
  9. *
  10. *======================================================*/
  11.  
  12. #include <config.h>
  13.  
  14. //     $Id: filedlg.C,v 1.1.1.1 1998/04/23 16:02:49 larsbj Exp $    
  15.  
  16. #if !defined(lint) && !defined(WITH_WARNINGS)
  17. static char vcid[] = "$Id: filedlg.C,v 1.1.1.1 1998/04/23 16:02:49 larsbj Exp $";
  18. #endif /* lint */
  19.  
  20. #include <unistd.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <pwd.h>
  24. #include <grp.h>
  25. #include <string.h>
  26.  
  27. #include "lyx_gui_misc.h" // CancelCloseCB
  28. #include "FileInfo.h"
  29. #include "gettext.h"
  30.  
  31. #ifdef HAVE_ERRNO_H
  32. #include <errno.h>
  33. #endif
  34.  
  35. #if HAVE_DIRENT_H
  36. # include <dirent.h>
  37. # define NAMLEN(dirent) strlen((dirent)->d_name)
  38. #else
  39. # define dirent direct
  40. # define NAMLEN(dirent) (dirent)->d_namlen
  41. # if HAVE_SYS_NDIR_H
  42. #  include <sys/ndir.h>
  43. # endif
  44. # if HAVE_SYS_DIR_H
  45. #  include <sys/dir.h>
  46. # endif
  47. # if HAVE_NDIR_H
  48. #  include <ndir.h>
  49. # endif
  50. #endif
  51.  
  52. #if TIME_WITH_SYS_TIME
  53. # include <sys/time.h>
  54. # include <time.h>
  55. #else
  56. # if HAVE_SYS_TIME_H
  57. #  include <sys/time.h>
  58. # else
  59. #  include <time.h>
  60. # endif
  61. #endif
  62.  
  63. #ifdef BROKEN_HEADERS
  64. extern "C" int gettimeofday(struct timeval *,struct timezone *);
  65. #define remove(a) unlink(a)      
  66. #endif
  67.  
  68. #ifdef __GNUG__
  69. #pragma implementation
  70. #endif
  71.  
  72. #include "filetools.h"
  73. #include "filedlg.h"
  74. #include "definitions.h"
  75.  
  76. static const long SIX_MONTH_SEC = 6L * 30L * 24L * 60L * 60L; // six months, in seconds
  77. static const long ONE_HOUR_SEC = 60L * 60L;
  78.  
  79. // *** User cache class implementation
  80.  
  81. // global instance (user cache root)
  82. UserCache lyxUserCache = UserCache(LString(),0,0);
  83.  
  84.  
  85. // Add: creates a new user entry
  86. UserCache *UserCache::Add(uid_t ID)
  87. {
  88.     LString pszNewName;
  89.     struct passwd *pEntry;
  90.  
  91.     // gets user name
  92.     if ((pEntry = getpwuid(ID)))
  93.         pszNewName = pEntry->pw_name;
  94.     else {
  95.         pszNewName = LString() + int(ID); // We don't have int cast to LString
  96.     }
  97.  
  98.     // adds new node
  99.     return new UserCache(pszNewName, ID, pRoot);
  100. }
  101.  
  102.  
  103. UserCache::UserCache(LString const & pszName, uid_t ID, UserCache *pRoot)
  104. {
  105.     // links node
  106.     if (pRoot) {
  107.         this->pRoot = pRoot;
  108.         pNext = pRoot->pNext;
  109.         pRoot->pNext = this;
  110.     } else {
  111.         this->pRoot = this;
  112.         pNext = NULL;
  113.     }
  114.  
  115.     // stores data
  116.     this->pszName = pszName;
  117.     this->ID = ID;
  118. }
  119.  
  120.  
  121. UserCache::~UserCache()
  122. {
  123.     if (pNext) delete pNext;
  124. }
  125.  
  126.  
  127. // Find: seeks user name from user ID
  128. LString UserCache::Find(uid_t ID)
  129. {
  130.     if ((!pszName.empty()) && (this->ID == ID)) return pszName; 
  131.     if (pNext) return pNext->Find(ID);
  132.  
  133.     return pRoot->Add(ID)->pszName;
  134. }
  135.  
  136.  
  137. // *** Group cache class implementation
  138.  
  139. // global instance (group cache root)
  140. GroupCache lyxGroupCache = GroupCache(LString(),0,0);
  141.  
  142. // Add: creates a new group entry
  143. GroupCache *GroupCache::Add(gid_t ID)
  144. {
  145.     LString pszNewName;
  146.     struct group *pEntry;
  147.  
  148.     // gets user name
  149.     if ((pEntry = getgrgid(ID))) pszNewName = pEntry->gr_name;
  150.     else {
  151.         pszNewName = LString() + int(ID); // We don't have int cast to LString
  152.     }
  153.  
  154.     // adds new node
  155.     return new GroupCache(pszNewName, ID, pRoot);
  156. }
  157.  
  158.  
  159. GroupCache::GroupCache(LString const & pszName, gid_t ID, GroupCache *pRoot)
  160. {
  161.     // links node
  162.     if (pRoot) {
  163.         this->pRoot = pRoot;
  164.         pNext = pRoot->pNext;
  165.         pRoot->pNext = this;
  166.     } else {
  167.         this->pRoot = this;
  168.         pNext = NULL;
  169.     }
  170.  
  171.     // stores data
  172.     this->pszName = pszName;
  173.     this->ID = ID;
  174. }
  175.  
  176.  
  177. GroupCache::~GroupCache()
  178. {
  179.     if (pNext) delete pNext;
  180. }
  181.  
  182.  
  183. // Find: seeks group name from group ID
  184. LString GroupCache::Find(gid_t ID)
  185. {
  186.     if ((!pszName.empty()) && (this->ID == ID)) return pszName; 
  187.     if (pNext) return pNext->Find(ID);
  188.  
  189.     return pRoot->Add(ID)->pszName;
  190. }
  191.  
  192. // *** LyXDirEntry internal structure implementation
  193.  
  194. // ldeCompProc: compares two LyXDirEntry objects content (used for qsort)
  195. int LyXDirEntry::ldeCompProc(const LyXDirEntry *r1, 
  196.                  const LyXDirEntry *r2)
  197. {
  198.     bool r1d = r1->pszName.suffixIs('/'); 
  199.     bool r2d = r2->pszName.suffixIs('/');
  200.     if (r1d && !r2d) return -1;
  201.     if (!r1d && r2d) return 1;
  202.     return strcmp(r1->pszName.c_str(), r2->pszName.c_str());
  203. }
  204.  
  205. // *** LyXFileDlg class implementation
  206.  
  207. // static members
  208. FD_FileDlg *LyXFileDlg::pFileDlgForm = NULL;
  209. LyXFileDlg *LyXFileDlg::pCurrentDlg = NULL;
  210.  
  211.  
  212. // Reread: updates dialog list to match class directory
  213. void LyXFileDlg::Reread()
  214. {
  215.     int i;
  216.     DIR *pDirectory;
  217.     struct dirent *pDirEntry;
  218.     LString szFile;
  219.     char szBuffer[256], szMode[15], szTime[40];
  220.     FileInfo fileInfo;
  221.     
  222.     // Opens directory
  223.     pDirectory = opendir(pszDirectory.c_str());
  224.     if (!pDirectory) {
  225.         WriteFSAlert(_("Warning! Couldn't open directory."), 
  226.                  pszDirectory);
  227.         pszDirectory = GetCWD();
  228.         pDirectory = opendir(pszDirectory.c_str());
  229.     }
  230.  
  231.     // Clear the present namelist
  232.     if (pCurrentNames) {
  233.         delete [] pCurrentNames;
  234.         pCurrentNames = 0;
  235.     }
  236.  
  237.     // Updates display
  238.     fl_hide_object(pFileDlgForm->List);
  239.     fl_clear_browser(pFileDlgForm->List);
  240.     fl_set_input(pFileDlgForm->DirBox, pszDirectory.c_str());
  241.  
  242.     // Splits complete directory name into directories and compute depth
  243.     iDepth = 0;
  244.     LString line, Temp;
  245.     szFile = pszDirectory;
  246.     if (szFile != "/") {
  247.         szFile.split(Temp, '/');
  248.     }
  249.     while (!szFile.empty() || !Temp.empty()) {
  250.         LString dline = "@b"+line + Temp + '/';        
  251.         fl_add_browser_line(pFileDlgForm->List, dline.c_str());
  252.         szFile.split(Temp, '/');
  253.         line += ' ';
  254.         iDepth++;
  255.     }
  256.  
  257.     // Allocate names array
  258.     iNumNames = 0;
  259.     rewinddir(pDirectory);
  260.     while ((readdir(pDirectory))) ++iNumNames;
  261.     pCurrentNames = new LyXDirEntry[iNumNames];
  262.  
  263.     // Parses all entries of the given subdirectory
  264.     iNumNames = 0;
  265.     time_t curTime = time(NULL);
  266.     rewinddir(pDirectory);
  267.     while ((pDirEntry = readdir(pDirectory))) {
  268.  
  269.         bool isLink = false, isDir = false;
  270.  
  271.         // If the pattern doesn't start with a dot, skip hidden files
  272.         if (!pszMask.empty() && pszMask[0] != '.' && 
  273.             pDirEntry->d_name[0] == '.')
  274.                         continue;
  275.  
  276.         // Gets filename
  277.         LString fname = pDirEntry->d_name;
  278.  
  279.         // Under all circumstances, "." and ".." are not wanted
  280.         if (fname == "." || fname == "..")
  281.             continue;
  282.  
  283.         // gets file status
  284.         szFile = AddName(pszDirectory, fname);
  285.  
  286.         fileInfo.newFile(szFile, true);
  287.  
  288.         fileInfo.modeString(szMode);
  289.         unsigned int nlink = fileInfo.getNumberOfLinks();
  290.         LString user =    lyxUserCache.Find(fileInfo.getUid());
  291.         LString group = lyxGroupCache.Find(fileInfo.getGid());
  292.  
  293.         strcpy(szTime, ctime(&(fileInfo.getModificationTime())));
  294.         
  295.         if (curTime > fileInfo.getModificationTime() + SIX_MONTH_SEC
  296.             || curTime < fileInfo.getModificationTime()
  297.             + ONE_HOUR_SEC) {
  298.             // The file is fairly old or in the future. POSIX says
  299.             // the cutoff is 6 months old. Allow a 1 hour slop
  300.             // factor for what is considered "the future", to
  301.             // allow for NFS server/client clock disagreement.
  302.             // Show the year instead of the time of day.
  303.             strcpy(szTime+10, szTime+19);
  304.             szTime[15] = 0;
  305.         } else
  306.             szTime[16] = 0;
  307.         
  308.         sprintf(szBuffer, "%s %u %s %s %s ", szMode, 
  309.             nlink,
  310.             user.c_str(),
  311.             group.c_str(),
  312.             szTime + 4);
  313.  
  314.         strcat(szBuffer, pDirEntry->d_name);
  315.         strcat(szBuffer, fileInfo.typeIndicator());
  316.  
  317.         if ((isLink = fileInfo.isLink())) {
  318.             char *pszLinkBuffer;
  319.             char szTempLink[512];
  320.             int nRead;
  321.  
  322.             fileInfo.newFile(szFile);
  323.             
  324.             nRead = readlink(szFile.c_str(), 
  325.                      szTempLink, sizeof(szTempLink));
  326.             pszLinkBuffer = new char[nRead + 10];
  327.             strcat (szBuffer, " -> ");
  328.  
  329.             if (nRead > 0) strncpy(pszLinkBuffer, 
  330.                            szTempLink, nRead);
  331.             pszLinkBuffer[nRead] = 0;
  332.  
  333.             strcat(pszLinkBuffer, fileInfo.typeIndicator());
  334.             strcat(szBuffer, pszLinkBuffer);
  335.             
  336.             // frees link buffer
  337.             delete [] pszLinkBuffer;
  338.         }
  339.  
  340.         // filters files according to pattern and type
  341.         if (fileInfo.isRegular()
  342.             || fileInfo.isChar()
  343.             || fileInfo.isBlock()
  344.             || fileInfo.isFifo()) {
  345.             if (!fname.regexMatch(pszMask))
  346.                 continue;
  347.         } else if (!(isDir = fileInfo.isDir()))
  348.             continue;
  349.         
  350.         pCurrentNames[iNumNames].pszLsEntry = szBuffer;
  351.  
  352.         // creates used name
  353.         LString temp = fname;
  354.         if (isDir) temp += '/';
  355.         pCurrentNames[iNumNames].pszName = temp;
  356.  
  357.         // creates displayed name
  358.         temp = pDirEntry->d_name;
  359.         if (isLink)
  360.             temp += '@';
  361.         else
  362.             temp += fileInfo.typeIndicator();
  363.         
  364.         pCurrentNames[iNumNames++].pszDisplayed = temp;
  365.     }
  366.  
  367.     closedir(pDirectory);
  368.  
  369.     // Sort the names
  370.     qsort(pCurrentNames, iNumNames, sizeof(LyXDirEntry), 
  371.           (int (*)(const void *, const void *))LyXDirEntry::ldeCompProc);
  372.  
  373.     // Add them to directory box
  374.     for (i = 0; i < iNumNames; ++i) {
  375.         LString temp = line + pCurrentNames[i].pszDisplayed;
  376.         fl_add_browser_line(pFileDlgForm->List, temp.c_str());
  377.     }
  378.     fl_set_browser_topline(pFileDlgForm->List,iDepth);
  379.     fl_show_object(pFileDlgForm->List);
  380.     iLastSel = -1;
  381. }
  382.  
  383.  
  384. // SetDirectory: sets dialog current directory
  385. void LyXFileDlg::SetDirectory(LString const & Path)
  386. {
  387.     if (!pszDirectory.empty()) {
  388.         LString TempPath = ExpandPath(Path); // Expand ~/
  389.         TempPath = MakeAbsPath(TempPath, pszDirectory);
  390.         pszDirectory = MakeAbsPath(TempPath);
  391.     } else pszDirectory = MakeAbsPath(Path);
  392. }
  393.  
  394.  
  395. // SetMask: sets dialog file mask
  396. void LyXFileDlg::SetMask(LString const & NewMask)
  397. {
  398.     pszMask = NewMask;
  399.     fl_set_input(pFileDlgForm->PatBox, pszMask.c_str());
  400. }
  401.  
  402.  
  403. // SetInfoLine: sets dialog information line
  404. void LyXFileDlg::SetInfoLine(LString const & Line)
  405. {
  406.     pszInfoLine = Line;
  407.     fl_set_object_label(pFileDlgForm->FileInfo, pszInfoLine.c_str());
  408. }
  409.  
  410.  
  411. LyXFileDlg::LyXFileDlg()
  412. {
  413.     pCurrentNames = 0;
  414.     pszDirectory = MakeAbsPath(LString("."));
  415.     pszMask = '*';
  416.  
  417.     // Creates form if necessary. 
  418.     if (!pFileDlgForm) {
  419.         pFileDlgForm = create_form_FileDlg();
  420.         // Set callbacks. This means that we don't need a patch file
  421.         fl_set_object_callback(pFileDlgForm->DirBox,
  422.                        LyXFileDlg::FileDlgCB,0);
  423.         fl_set_object_callback(pFileDlgForm->PatBox,
  424.                        LyXFileDlg::FileDlgCB,1);
  425.         fl_set_object_callback(pFileDlgForm->List,
  426.                        LyXFileDlg::FileDlgCB,2);
  427.         fl_set_object_callback(pFileDlgForm->Filename,
  428.                        LyXFileDlg::FileDlgCB,3);
  429.         fl_set_object_callback(pFileDlgForm->Rescan,
  430.                        LyXFileDlg::FileDlgCB,10);
  431.         fl_set_object_callback(pFileDlgForm->Home,
  432.                        LyXFileDlg::FileDlgCB,11);
  433.         fl_set_object_callback(pFileDlgForm->User1,
  434.                        LyXFileDlg::FileDlgCB,12);
  435.         fl_set_object_callback(pFileDlgForm->User2,
  436.                        LyXFileDlg::FileDlgCB,13);
  437.         
  438.         // Make sure pressing the close box doesn't crash LyX. (RvdK)
  439.         fl_set_form_atclose(pFileDlgForm->FileDlg, CancelCB, NULL);
  440.            // Register doubleclick callback
  441.         fl_set_browser_dblclick_callback(pFileDlgForm->List,
  442.                          DoubleClickCB,0);
  443.     }
  444.     fl_hide_object(pFileDlgForm->User1);
  445.     fl_hide_object(pFileDlgForm->User2);
  446. }
  447.  
  448.  
  449. LyXFileDlg::~LyXFileDlg()
  450. {
  451.     // frees directory entries
  452.     if (pCurrentNames) {
  453.         delete [] pCurrentNames;
  454.     }
  455. }
  456.  
  457.  
  458. // SetButton: sets file selector user button action
  459. void LyXFileDlg::SetButton(int iIndex, LString const & pszName, 
  460.                LString const & pszPath)
  461. {
  462.     FL_OBJECT *pObject;
  463.     LString *pTemp;
  464.  
  465.     if (iIndex == 0) {
  466.         pObject = pFileDlgForm->User1;
  467.         pTemp = &pszUserPath1;
  468.     } else if (iIndex == 1) {            
  469.         pObject = pFileDlgForm->User2;
  470.         pTemp = &pszUserPath2;
  471.     } else return;
  472.  
  473.     if (!pszName.empty() && !pszPath.empty()) {
  474.         fl_set_object_label(pObject, pszName.c_str());
  475.         fl_show_object(pObject);
  476.         *pTemp = pszPath;
  477.     } else {
  478.         fl_hide_object(pObject);
  479.         *pTemp = LString();
  480.     }
  481. }
  482.  
  483.  
  484. // GetDirectory: gets last dialog directory
  485. LString LyXFileDlg::GetDirectory() 
  486. {
  487.     if (!pszDirectory.empty())
  488.         return pszDirectory;
  489.     else
  490.         return LString(".");
  491. }
  492.  
  493.  
  494. // RunDialog: handle dialog during file selection
  495. bool LyXFileDlg::RunDialog()
  496. {
  497.     force_cancel = false;
  498.     force_ok = false;
  499.     
  500.         // event loop
  501.         while(true) {
  502.  
  503.                 FL_OBJECT * pObject = fl_do_forms();
  504.  
  505.                 if (pObject == pFileDlgForm->Ready) {
  506.             if (HandleOK())
  507.                 return true;
  508.         } else if (pObject == pFileDlgForm->Cancel 
  509.                || force_cancel) 
  510.             return false;
  511.         else if (force_ok)
  512.             return true;
  513.     }
  514. }
  515.  
  516.  
  517. // XForms objects callback (static)
  518. void LyXFileDlg::FileDlgCB(FL_OBJECT *, long lArgument)
  519. {
  520.     if (!pCurrentDlg) return;
  521.  
  522.     switch (lArgument) {
  523.  
  524.     case 0: // get directory
  525.         pCurrentDlg->SetDirectory(fl_get_input(pFileDlgForm->DirBox));
  526.         pCurrentDlg->Reread();
  527.         break;
  528.  
  529.     case 1: // get mask
  530.         pCurrentDlg->SetMask(fl_get_input(pFileDlgForm->PatBox));
  531.         pCurrentDlg->Reread();
  532.         break;
  533.  
  534.     case 2: // list
  535.         pCurrentDlg->HandleListHit();
  536.         break;    
  537.  
  538.     case 10: // rescan
  539.         pCurrentDlg->SetDirectory(fl_get_input(pFileDlgForm->DirBox));
  540.         pCurrentDlg->SetMask(fl_get_input(pFileDlgForm->PatBox));
  541.         pCurrentDlg->Reread();
  542.         break;
  543.  
  544.     case 11: // home
  545.         pCurrentDlg->SetDirectory(getEnvPath("HOME"));
  546.         pCurrentDlg->SetMask(fl_get_input(pFileDlgForm->PatBox));
  547.         pCurrentDlg->Reread();
  548.         break;
  549.  
  550.     case 12: // user button 1
  551.         if (!pCurrentDlg->pszUserPath1.empty()) {
  552.             pCurrentDlg->SetDirectory(pCurrentDlg->pszUserPath1);
  553.             pCurrentDlg->SetMask(fl_get_input(pFileDlgForm->PatBox));
  554.             pCurrentDlg->Reread();
  555.         }
  556.         break;
  557.  
  558.     case 13: // user button 2
  559.         if (!pCurrentDlg->pszUserPath2.empty()) {
  560.             pCurrentDlg->SetDirectory(pCurrentDlg->pszUserPath2);
  561.             pCurrentDlg->SetMask(fl_get_input(pFileDlgForm->PatBox));
  562.             pCurrentDlg->Reread();
  563.         }
  564.         break;
  565.  
  566.     }
  567. }
  568.  
  569.  
  570. // Handle callback from list
  571. void LyXFileDlg::HandleListHit()
  572. {
  573.     // set info line
  574.     int iSelect = fl_get_browser(pFileDlgForm->List);
  575.     if (iSelect > iDepth)  {
  576.         SetInfoLine(pCurrentNames[iSelect - iDepth - 1].pszLsEntry);
  577.     } else {
  578.         SetInfoLine(LString());
  579.     }
  580. }
  581.  
  582.  
  583. // Callback for double click in list
  584. void LyXFileDlg::DoubleClickCB(FL_OBJECT *, long)
  585. {
  586.     if (pCurrentDlg->HandleDoubleClick())
  587.         // Simulate click on OK button
  588.         pCurrentDlg->Force(false);
  589. }
  590.  
  591.  
  592. // Handle double click from list
  593. bool LyXFileDlg::HandleDoubleClick()
  594. {
  595.     bool isDir;
  596.     LString pszTemp;
  597.     int iSelect;  
  598.  
  599.     // set info line
  600.     isDir = true;
  601.     iSelect = fl_get_browser(pFileDlgForm->List);
  602.     if (iSelect > iDepth)  {
  603.         pszTemp = pCurrentNames[iSelect - iDepth - 1].pszName;
  604.         SetInfoLine(pCurrentNames[iSelect - iDepth - 1].pszLsEntry);
  605.         if (!pszTemp.suffixIs('/')) {
  606.             isDir = false;
  607.             fl_set_input(pFileDlgForm->Filename, pszTemp.c_str());
  608.         }
  609.     } else if (iSelect !=0) {
  610.         SetInfoLine(LString());
  611.     } else
  612.         return true;
  613.  
  614.     // executes action
  615.     if (isDir) {
  616.  
  617.         int i;
  618.         LString Temp;
  619.  
  620.         // builds new directory name
  621.         if (iSelect > iDepth) {
  622.             // Directory deeper down
  623.             // First, get directory with trailing /
  624.             Temp = fl_get_input(pFileDlgForm->DirBox);
  625.             if (!Temp.suffixIs('/'))
  626.                 Temp += '/';
  627.             Temp += pszTemp;
  628.         } else {
  629.             // Directory higher up
  630.             Temp.erase();
  631.             for (i = 0; i < iSelect; ++i) {
  632.                 LString piece = fl_get_browser_line(pFileDlgForm->List, i+1);
  633.                 // The '+2' is here to count the '@b' (JMarc)
  634.                 Temp += piece.substring(i+2, piece.length()-1);
  635.             }
  636.         }
  637.  
  638.         // assigns it
  639.         SetDirectory(Temp);
  640.         Reread();
  641.         return false;
  642.     }
  643.     return true;
  644. }
  645.  
  646.  
  647. // Handle OK button call
  648. bool LyXFileDlg::HandleOK()
  649. {
  650.     LString pszTemp;
  651.  
  652.     // mask was changed
  653.     pszTemp = fl_get_input(pFileDlgForm->PatBox);
  654.     if (pszTemp!=pszMask) {
  655.         SetMask(pszTemp);
  656.         Reread();
  657.         return false;
  658.     }
  659.  
  660.     // directory was changed
  661.     pszTemp = fl_get_input(pFileDlgForm->DirBox);
  662.     if (pszTemp!=pszDirectory) {
  663.         SetDirectory(pszTemp);
  664.         Reread();
  665.         return false;
  666.     }
  667.     
  668.     // Handle return from list
  669.     int select = fl_get_browser(pFileDlgForm->List);
  670.     if (select > iDepth) {
  671.         LString temp = pCurrentNames[select - iDepth - 1].pszName;
  672.         if (!temp.suffixIs('/')) {
  673.             // If user didn't type anything, use browser
  674.             LString name = fl_get_input(pFileDlgForm->Filename);
  675.             if (name.empty()) {
  676.                 fl_set_input(pFileDlgForm->Filename, temp.c_str());
  677.             }
  678.             return true;
  679.         }
  680.     }
  681.     
  682.     // Emulate a doubleclick
  683.     return HandleDoubleClick();
  684. }
  685.  
  686.  
  687. // Handle Cancel CB from WM close
  688. int LyXFileDlg::CancelCB(FL_FORM *, void *)
  689. {
  690.     // Simulate a click on the cancel button
  691.     pCurrentDlg->Force(true);
  692.       return FL_IGNORE;
  693. }
  694.  
  695.  
  696. // Simulates a click on OK/Cancel
  697. void LyXFileDlg::Force(bool cancel)
  698. {
  699.     if (cancel) {
  700.         force_cancel = true;
  701.         fl_set_button(pFileDlgForm->Cancel, 1);
  702.     } else {
  703.         force_ok = true;
  704.         fl_set_button(pFileDlgForm->Ready, 1);
  705.     }
  706.     // Start timer to break fl_do_forms loop soon
  707.     fl_set_timer(pFileDlgForm->timer, 0.1);
  708. }
  709.  
  710.  
  711. // Select: launches dialog and returns selected file
  712. LString LyXFileDlg::Select(LString const & title, LString const & path, 
  713.                LString const & mask, LString const & suggested)
  714. {
  715.     bool isOk;
  716.  
  717.     // handles new mask and path
  718.     isOk = true;
  719.     if (!mask.empty()) {
  720.         SetMask(mask);
  721.         isOk = false;
  722.     }
  723.     if (!path.empty()) {
  724.         SetDirectory(path);
  725.         isOk = false;
  726.     }
  727.     if (!isOk) Reread();
  728.     else {
  729.         fl_select_browser_line(pFileDlgForm->List, 1);
  730.         fl_set_browser_topline(pFileDlgForm->List, 1);
  731.     }
  732.  
  733.     // checks whether dialog can be started
  734.     if (pCurrentDlg) return LString();
  735.     pCurrentDlg = this;
  736.  
  737.     // runs dialog
  738.     SetInfoLine (LString());
  739.     fl_set_input(pFileDlgForm->Filename, suggested.c_str());
  740.     fl_set_button(pFileDlgForm->Cancel, 0);
  741.     fl_set_button(pFileDlgForm->Ready, 0);
  742.     fl_set_focus_object(pFileDlgForm->FileDlg, pFileDlgForm->Filename);
  743.     fl_deactivate_all_forms();
  744.     fl_show_form(pFileDlgForm->FileDlg, FL_PLACE_MOUSE | FL_FREE_SIZE,
  745.              FL_FULLBORDER, title.c_str());
  746.  
  747.     isOk = RunDialog();
  748.  
  749.     fl_hide_form(pFileDlgForm->FileDlg);
  750.     fl_activate_all_forms();
  751.     pCurrentDlg = NULL;
  752.  
  753.     // Returns filename or LString() if no valid selection was made
  754.     if (!isOk || !fl_get_input(pFileDlgForm->Filename)[0]) return LString();
  755.  
  756.     pszFileName = fl_get_input(pFileDlgForm->Filename);
  757.  
  758.     if (!AbsolutePath(pszFileName)) {
  759.         pszFileName = AddName(fl_get_input(pFileDlgForm->DirBox), 
  760.                       pszFileName);
  761.     }
  762.     return pszFileName;
  763. }
  764.