860 lines
22 KiB
C++
860 lines
22 KiB
C++
/***********************************************************************
|
|
* ffiledialog.cpp - Widget FFileDialog (a file chooser dialog) *
|
|
* *
|
|
* This file is part of the Final Cut widget toolkit *
|
|
* *
|
|
* Copyright 2014-2019 Markus Gans *
|
|
* *
|
|
* The Final Cut is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Lesser General Public License *
|
|
* as published by the Free Software Foundation; either version 3 of *
|
|
* the License, or (at your option) any later version. *
|
|
* *
|
|
* The Final Cut is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Lesser General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Lesser General Public *
|
|
* License along with this program. If not, see *
|
|
* <http://www.gnu.org/licenses/>. *
|
|
***********************************************************************/
|
|
|
|
#if defined(__CYGWIN__)
|
|
#undef __STRICT_ANSI__ // need for strdup
|
|
#include <strings.h> // need for strcasecmp
|
|
#endif
|
|
|
|
#include <vector>
|
|
|
|
#include "final/fevent.h"
|
|
#include "final/fsystem.h"
|
|
#include "final/ffiledialog.h"
|
|
|
|
namespace finalcut
|
|
{
|
|
|
|
// non-member functions
|
|
//----------------------------------------------------------------------
|
|
bool sortByName ( const FFileDialog::dir_entry& lhs
|
|
, const FFileDialog::dir_entry& rhs )
|
|
{
|
|
// lhs < rhs
|
|
return bool( strcasecmp(lhs.name, rhs.name) < 0 );
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool sortDirFirst ( const FFileDialog::dir_entry& lhs
|
|
, const FFileDialog::dir_entry& rhs )
|
|
{
|
|
// sort directories first
|
|
if ( lhs.directory && ! rhs.directory )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString fileChooser ( FWidget* parent
|
|
, const FString& dirname
|
|
, const FString& filter
|
|
, FFileDialog::DialogType type )
|
|
{
|
|
FString ret{};
|
|
FString path(dirname);
|
|
FString file_filter(filter);
|
|
|
|
if ( path.isNull() || path.isEmpty() )
|
|
{
|
|
path.setString(FFileDialog::getHomeDir());
|
|
|
|
if ( path.isNull() || path.isEmpty() )
|
|
path.setString("/");
|
|
}
|
|
|
|
if ( file_filter.isNull() || file_filter.isEmpty() )
|
|
file_filter.setString("*");
|
|
|
|
FFileDialog fileopen ( path
|
|
, file_filter
|
|
, type
|
|
, parent );
|
|
|
|
if ( fileopen.exec() == FDialog::Accept )
|
|
ret = fileopen.getPath() + fileopen.getSelectedFile();
|
|
else
|
|
ret = FString();
|
|
|
|
return ret;
|
|
}
|
|
|
|
// static class attributes
|
|
FSystem* FFileDialog::fsystem{nullptr};
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// class FFileDialog
|
|
//----------------------------------------------------------------------
|
|
|
|
// constructors and destructor
|
|
//----------------------------------------------------------------------
|
|
FFileDialog::FFileDialog (FWidget* parent)
|
|
: FDialog(parent)
|
|
{
|
|
init();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FFileDialog::FFileDialog (const FFileDialog& fdlg)
|
|
: FDialog(fdlg.getParentWidget())
|
|
{
|
|
if ( fdlg.directory )
|
|
setPath(fdlg.directory);
|
|
|
|
init();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FFileDialog::FFileDialog ( const FString& dirname
|
|
, const FString& filter
|
|
, DialogType type
|
|
, FWidget* parent )
|
|
: FDialog(parent)
|
|
, filter_pattern(filter)
|
|
, dlg_type(type)
|
|
{
|
|
if ( ! dirname.isNull() )
|
|
setPath(dirname);
|
|
|
|
init();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FFileDialog::~FFileDialog() // destructor
|
|
{
|
|
clear();
|
|
}
|
|
|
|
|
|
// public methods of FFileDialog
|
|
//----------------------------------------------------------------------
|
|
FFileDialog& FFileDialog::operator = (const FFileDialog& fdlg)
|
|
{
|
|
if ( &fdlg == this )
|
|
{
|
|
return *this;
|
|
}
|
|
else
|
|
{
|
|
clear();
|
|
|
|
if ( fdlg.getParentWidget() )
|
|
fdlg.getParentWidget()->addChild (this);
|
|
|
|
directory = fdlg.directory;
|
|
filter_pattern = fdlg.filter_pattern;
|
|
dlg_type = fdlg.dlg_type;
|
|
show_hidden = fdlg.show_hidden;
|
|
|
|
if ( directory )
|
|
setPath(directory);
|
|
|
|
init();
|
|
return *this;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FFileDialog::getSelectedFile() const
|
|
{
|
|
uLong n = uLong(filebrowser.currentItem() - 1);
|
|
|
|
if ( dir_entries[n].directory )
|
|
return FString("");
|
|
else
|
|
return FString(dir_entries[n].name);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::setPath (const FString& dir)
|
|
{
|
|
const char* const dirname = dir.c_str();
|
|
char resolved_path[MAXPATHLEN]{};
|
|
FString r_dir{};
|
|
struct stat sb{};
|
|
|
|
if ( stat(dirname, &sb) != 0 )
|
|
{
|
|
directory = '/';
|
|
return;
|
|
}
|
|
|
|
if ( S_ISLNK(sb.st_mode) )
|
|
{
|
|
if ( lstat(dirname, &sb) != 0 )
|
|
{
|
|
directory = '/';
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( ! S_ISDIR(sb.st_mode) )
|
|
{
|
|
directory = '/';
|
|
return;
|
|
}
|
|
|
|
if ( fsystem->realpath(dir.c_str(), resolved_path) != 0 )
|
|
r_dir.setString(resolved_path);
|
|
else
|
|
r_dir.setString(dir);
|
|
|
|
if ( r_dir[r_dir.getLength() - 1] != '/' )
|
|
directory = r_dir + "/";
|
|
else
|
|
directory = r_dir;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::setFilter (const FString& filter)
|
|
{
|
|
filter_pattern = filter;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FFileDialog::setShowHiddenFiles (bool enable)
|
|
{
|
|
if ( show_hidden == enable )
|
|
return show_hidden;
|
|
|
|
show_hidden = enable;
|
|
readDir();
|
|
filebrowser.redraw();
|
|
return show_hidden;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::onKeyPress (FKeyEvent* ev)
|
|
{
|
|
if ( ! isEnabled() )
|
|
return;
|
|
|
|
FDialog::onKeyPress (ev);
|
|
|
|
if ( ! filebrowser.hasFocus() )
|
|
return;
|
|
|
|
FKey key = ev->key();
|
|
|
|
switch ( key )
|
|
{
|
|
case fc::Fkey_erase:
|
|
case fc::Fkey_backspace:
|
|
changeDir("..");
|
|
ev->accept();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FFileDialog::fileOpenChooser ( FWidget* parent
|
|
, const FString& dirname
|
|
, const FString& filter )
|
|
{
|
|
return fileChooser (parent, dirname, filter, FFileDialog::Open);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FFileDialog::fileSaveChooser ( FWidget* parent
|
|
, const FString& dirname
|
|
, const FString& filter )
|
|
{
|
|
return fileChooser (parent, dirname, filter, FFileDialog::Save);
|
|
}
|
|
|
|
|
|
// protected methods of FFileDialog
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::adjustSize()
|
|
{
|
|
std::size_t max_width{}, max_height{};
|
|
auto root_widget = getRootWidget();
|
|
|
|
if ( root_widget )
|
|
{
|
|
max_width = root_widget->getClientWidth();
|
|
max_height = root_widget->getClientHeight();
|
|
}
|
|
else
|
|
{
|
|
// fallback to xterm default size
|
|
max_width = 80;
|
|
max_height = 24;
|
|
}
|
|
|
|
std::size_t h = max_height - 6;
|
|
|
|
if ( h < 15 ) // minimum
|
|
h = 15;
|
|
|
|
if ( h > 30 ) // maximum
|
|
h = 30;
|
|
|
|
setHeight (h, false);
|
|
int X = 1 + int((max_width - getWidth()) / 2);
|
|
int Y = 1 + int((max_height - getHeight()) / 3);
|
|
setPos(FPoint(X, Y), false);
|
|
filebrowser.setHeight (h - 8, false);
|
|
hidden_check.setY (int(h) - 4, false);
|
|
cancel_btn.setY (int(h) - 4, false);
|
|
open_btn.setY (int(h) - 4, false);
|
|
FDialog::adjustSize();
|
|
printPath(directory);
|
|
}
|
|
|
|
|
|
// private methods of FFileDialog
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::init()
|
|
{
|
|
static constexpr std::size_t w = 42;
|
|
static constexpr std::size_t h = 15;
|
|
int x{}, y{};
|
|
|
|
if ( ! fsystem )
|
|
fsystem = FTerm::getFSystem();
|
|
|
|
setGeometry(FPoint(1, 1), FSize(w, h), false);
|
|
auto parent_widget = getParentWidget();
|
|
|
|
if ( parent_widget )
|
|
{
|
|
x = 1 + int((parent_widget->getWidth() - w) / 2);
|
|
y = 1 + int((parent_widget->getHeight() - h) / 3);
|
|
}
|
|
else
|
|
x = y = 1;
|
|
|
|
if ( dlg_type == FFileDialog::Save )
|
|
FDialog::setText("Save file");
|
|
else
|
|
FDialog::setText("Open file");
|
|
|
|
widgetSettings (FPoint(x, y)); // Create widgets
|
|
initCallbacks();
|
|
setModal();
|
|
readDir();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline void FFileDialog::widgetSettings (const FPoint& pos)
|
|
{
|
|
filename.setLabelText ("File&name");
|
|
filename.setText (filter_pattern);
|
|
filename.setGeometry (FPoint(11, 1), FSize(28, 1));
|
|
filename.setFocus();
|
|
|
|
filebrowser.setGeometry (FPoint(2, 3), FSize(38, 6));
|
|
printPath (directory);
|
|
|
|
hidden_check.setText ("&hidden files");
|
|
hidden_check.setGeometry (FPoint(2, 10), FSize(16, 1));
|
|
|
|
cancel_btn.setText ("&Cancel");
|
|
cancel_btn.setGeometry(FPoint(19, 10), FSize(9, 1));
|
|
|
|
if ( dlg_type == FFileDialog::Save )
|
|
open_btn.setText ("&Save");
|
|
else
|
|
open_btn.setText ("&Open");
|
|
|
|
open_btn.setGeometry(FPoint(30, 10), FSize(9, 1));
|
|
setGeometry (pos, getSize());
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::initCallbacks()
|
|
{
|
|
filename.addCallback
|
|
(
|
|
"activate",
|
|
F_METHOD_CALLBACK (this, &FFileDialog::cb_processActivate)
|
|
);
|
|
|
|
filebrowser.addCallback
|
|
(
|
|
"row-changed",
|
|
F_METHOD_CALLBACK (this, &FFileDialog::cb_processRowChanged)
|
|
);
|
|
|
|
filebrowser.addCallback
|
|
(
|
|
"clicked",
|
|
F_METHOD_CALLBACK (this, &FFileDialog::cb_processClicked)
|
|
);
|
|
|
|
hidden_check.addCallback
|
|
(
|
|
"toggled",
|
|
F_METHOD_CALLBACK (this, &FFileDialog::cb_processShowHidden)
|
|
);
|
|
|
|
cancel_btn.addCallback
|
|
(
|
|
"clicked",
|
|
F_METHOD_CALLBACK (this, &FFileDialog::cb_processCancel)
|
|
);
|
|
|
|
open_btn.addCallback
|
|
(
|
|
"clicked",
|
|
F_METHOD_CALLBACK (this, &FFileDialog::cb_processOpen)
|
|
);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline bool FFileDialog::pattern_match ( const char* const pattern
|
|
, char fname[] )
|
|
{
|
|
char search[128]{};
|
|
|
|
if ( show_hidden && fname[0] == '.' && fname[1] != '\0' ) // hidden files
|
|
{
|
|
search[0] = '.';
|
|
search[1] = '\0';
|
|
std::strncat(search, pattern, sizeof(search) - std::strlen(search) - 1);
|
|
}
|
|
else
|
|
std::strncpy(search, pattern, sizeof(search));
|
|
|
|
search[sizeof(search) - 1] = '\0';
|
|
|
|
if ( fnmatch (search, fname, FNM_PERIOD) == 0 )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::clear()
|
|
{
|
|
if ( dir_entries.empty() )
|
|
return;
|
|
|
|
// delete all directory entries;
|
|
for (auto&& entry : dir_entries)
|
|
std::free (entry.name);
|
|
|
|
dir_entries.clear();
|
|
dir_entries.shrink_to_fit();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
sInt64 FFileDialog::numOfDirs()
|
|
{
|
|
if ( dir_entries.empty() )
|
|
return 0;
|
|
|
|
sInt64 n = std::count_if ( std::begin(dir_entries)
|
|
, std::end(dir_entries)
|
|
, [] (dir_entry& entry)
|
|
{
|
|
return entry.directory
|
|
&& std::strcmp(entry.name, ".") != 0;
|
|
}
|
|
);
|
|
return n;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::sortDir()
|
|
{
|
|
sInt64 start{};
|
|
|
|
if ( std::strcmp((*dir_entries.begin()).name, "..") == 0 )
|
|
start = 1;
|
|
else
|
|
start = 0;
|
|
|
|
sInt64 dir_num = numOfDirs();
|
|
// directories first
|
|
std::sort ( dir_entries.begin() + start
|
|
, dir_entries.end()
|
|
, sortDirFirst );
|
|
// sort directories by name
|
|
std::sort ( dir_entries.begin() + start
|
|
, dir_entries.begin() + dir_num
|
|
, sortByName );
|
|
// sort files by name
|
|
std::sort ( dir_entries.begin() + dir_num
|
|
, dir_entries.end()
|
|
, sortByName );
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int FFileDialog::readDir()
|
|
{
|
|
const char* const dir = directory.c_str();
|
|
directory_stream = opendir(dir);
|
|
|
|
if ( ! directory_stream )
|
|
{
|
|
FMessageBox::error (this, "Can't open directory\n" + directory);
|
|
return -1;
|
|
}
|
|
|
|
clear();
|
|
|
|
while ( true )
|
|
{
|
|
errno = 0;
|
|
struct dirent* next = readdir(directory_stream);
|
|
|
|
if ( next )
|
|
{
|
|
// Continue if name = "." (current directory)
|
|
if ( next->d_name[0] == '.' && next->d_name[1] == '\0' )
|
|
continue;
|
|
|
|
// Skip hidden entries
|
|
if ( ! show_hidden
|
|
&& next->d_name[0] == '.'
|
|
&& next->d_name[1] != '\0'
|
|
&& next->d_name[1] != '.' )
|
|
continue;
|
|
|
|
// Skip ".." for the root directory
|
|
if ( dir[0] == '/' && dir[1] == '\0'
|
|
&& std::strcmp(next->d_name, "..") == 0 )
|
|
continue;
|
|
|
|
getEntry(dir, next);
|
|
}
|
|
else if ( errno != 0 )
|
|
{
|
|
FMessageBox::error (this, "Reading directory\n" + directory);
|
|
|
|
if ( errno == EOVERFLOW ) // Value too large to be stored in data type
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
} // end while
|
|
|
|
if ( closedir(directory_stream) != 0 )
|
|
{
|
|
FMessageBox::error (this, "Closing directory\n" + directory);
|
|
return -2;
|
|
}
|
|
|
|
sortDir();
|
|
|
|
// Insert directory entries into the list
|
|
dirEntriesToList();
|
|
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::getEntry (const char* const dir, struct dirent* d_entry)
|
|
{
|
|
const char* const filter = filter_pattern.c_str();
|
|
dir_entry entry{};
|
|
|
|
entry.name = strdup(d_entry->d_name);
|
|
|
|
#if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
|
|
entry.fifo = (d_entry->d_type & DT_FIFO) == DT_FIFO;
|
|
entry.character_device = (d_entry->d_type & DT_CHR ) == DT_CHR;
|
|
entry.directory = (d_entry->d_type & DT_DIR ) == DT_DIR;
|
|
entry.block_device = (d_entry->d_type & DT_BLK ) == DT_BLK;
|
|
entry.regular_file = (d_entry->d_type & DT_REG ) == DT_REG;
|
|
entry.symbolic_link = (d_entry->d_type & DT_LNK ) == DT_LNK;
|
|
entry.socket = (d_entry->d_type & DT_SOCK) == DT_SOCK;
|
|
#else
|
|
struct stat s{};
|
|
stat (entry.name, &s);
|
|
entry.fifo = S_ISFIFO (s.st_mode);
|
|
entry.character_device = S_ISCHR (s.st_mode);
|
|
entry.directory = S_ISDIR (s.st_mode);
|
|
entry.block_device = S_ISBLK (s.st_mode);
|
|
entry.regular_file = S_ISREG (s.st_mode);
|
|
entry.symbolic_link = S_ISLNK (s.st_mode);
|
|
entry.socket = S_ISSOCK (s.st_mode);
|
|
#endif
|
|
|
|
followSymLink (dir, entry);
|
|
|
|
if ( entry.directory )
|
|
dir_entries.push_back (entry);
|
|
else if ( pattern_match(filter, entry.name) )
|
|
dir_entries.push_back (entry);
|
|
else
|
|
std::free(entry.name);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::followSymLink (const char* const dir, dir_entry& entry)
|
|
{
|
|
if ( ! entry.symbolic_link )
|
|
return; // No symbolic link
|
|
|
|
char resolved_path[MAXPATHLEN]{};
|
|
char symLink[MAXPATHLEN]{};
|
|
struct stat sb{};
|
|
|
|
if ( ! fsystem )
|
|
fsystem = FTerm::getFSystem();
|
|
|
|
std::strncpy (symLink, dir, sizeof(symLink));
|
|
symLink[sizeof(symLink) - 1] = '\0';
|
|
std::strncat ( symLink
|
|
, entry.name
|
|
, sizeof(symLink) - std::strlen(symLink) - 1);
|
|
symLink[sizeof(symLink) - 1] = '\0';
|
|
|
|
if ( fsystem->realpath(symLink, resolved_path) == 0 )
|
|
return; // Cannot follow the symlink
|
|
|
|
if ( lstat(resolved_path, &sb) == -1 )
|
|
return; // Cannot get file status
|
|
|
|
if ( S_ISDIR(sb.st_mode) )
|
|
entry.directory = true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::dirEntriesToList()
|
|
{
|
|
// Fill list with directory entries
|
|
|
|
filebrowser.clear();
|
|
|
|
if ( dir_entries.empty() )
|
|
return;
|
|
|
|
for (auto&& entry : dir_entries)
|
|
{
|
|
if ( entry.directory )
|
|
filebrowser.insert(FString(entry.name), fc::SquareBrackets);
|
|
else
|
|
filebrowser.insert(FString(entry.name));
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::selectDirectoryEntry (const char* const name)
|
|
{
|
|
if ( dir_entries.empty() )
|
|
return;
|
|
|
|
std::size_t i{1};
|
|
|
|
for (auto&& entry : dir_entries)
|
|
{
|
|
if ( std::strcmp(entry.name, name) == 0 )
|
|
{
|
|
filebrowser.setCurrentItem(i);
|
|
filename.setText(FString(name) + '/');
|
|
break;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int FFileDialog::changeDir (const FString& dirname)
|
|
{
|
|
FString lastdir(directory);
|
|
FString newdir(dirname);
|
|
|
|
if ( ! fsystem )
|
|
fsystem = FTerm::getFSystem();
|
|
|
|
if ( newdir.includes('~') )
|
|
newdir = newdir.replace('~', getHomeDir());
|
|
|
|
if ( newdir[0] == '/' )
|
|
setPath(newdir);
|
|
else
|
|
setPath(directory + newdir);
|
|
|
|
switch ( readDir() )
|
|
{
|
|
case -1:
|
|
setPath(lastdir);
|
|
return -1;
|
|
|
|
case -2:
|
|
setPath(lastdir);
|
|
readDir();
|
|
return -2;
|
|
|
|
case 0:
|
|
if ( newdir == FString("..") )
|
|
{
|
|
if ( lastdir == FString('/') )
|
|
filename.setText('/');
|
|
else
|
|
{
|
|
auto baseName = basename(lastdir.c_str());
|
|
selectDirectoryEntry (baseName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FString firstname(dir_entries[0].name);
|
|
|
|
if ( dir_entries[0].directory )
|
|
filename.setText(firstname + '/');
|
|
else
|
|
filename.setText(firstname);
|
|
}
|
|
|
|
printPath(directory);
|
|
filename.redraw();
|
|
filebrowser.redraw();
|
|
// fall through
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::printPath (const FString& txt)
|
|
{
|
|
const auto& path = txt;
|
|
const std::size_t max_width = filebrowser.getWidth() - 4;
|
|
std::size_t column_width = getColumnWidth(path);
|
|
|
|
if ( column_width > max_width )
|
|
{
|
|
const std::size_t width = max_width - 2;
|
|
std::size_t first = column_width + 1 - width;
|
|
FString sub_str(getColumnSubString (path, first, width));
|
|
filebrowser.setText(".." + sub_str);
|
|
}
|
|
else
|
|
filebrowser.setText(path);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FFileDialog::getHomeDir()
|
|
{
|
|
struct passwd pwd{};
|
|
struct passwd* pwd_ptr{};
|
|
char buf[1024]{};
|
|
|
|
if ( ! fsystem )
|
|
fsystem = FTerm::getFSystem();
|
|
|
|
uid_t euid = fsystem->geteuid();
|
|
|
|
if ( fsystem->getpwuid_r(euid, &pwd, buf, sizeof(buf), &pwd_ptr) )
|
|
return FString("");
|
|
else
|
|
return FString(pwd.pw_dir);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::cb_processActivate (FWidget*, FDataPtr)
|
|
{
|
|
if ( filename.getText().includes('*')
|
|
|| filename.getText().includes('?') )
|
|
{
|
|
setFilter(filename.getText());
|
|
readDir();
|
|
filebrowser.redraw();
|
|
}
|
|
else if ( filename.getText().getLength() == 0 )
|
|
{
|
|
setFilter("*");
|
|
readDir();
|
|
filebrowser.redraw();
|
|
}
|
|
else if ( filename.getText().trim() == FString("..")
|
|
|| filename.getText().includes('/')
|
|
|| filename.getText().includes('~') )
|
|
{
|
|
changeDir(filename.getText().trim());
|
|
}
|
|
else
|
|
{
|
|
bool found{false};
|
|
const auto& input = filename.getText().trim();
|
|
|
|
if ( ! dir_entries.empty() )
|
|
{
|
|
found = std::any_of ( std::begin(dir_entries)
|
|
, std::end(dir_entries)
|
|
, [&input] (dir_entry& entry)
|
|
{
|
|
return entry.name
|
|
&& input
|
|
&& ! input.isNull()
|
|
&& std::strcmp(entry.name, input) == 0
|
|
&& entry.directory;
|
|
}
|
|
);
|
|
}
|
|
|
|
if ( found )
|
|
changeDir(input);
|
|
else
|
|
done (FDialog::Accept);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::cb_processRowChanged (FWidget*, FDataPtr)
|
|
{
|
|
const std::size_t n = filebrowser.currentItem();
|
|
|
|
if ( n == 0 )
|
|
return;
|
|
|
|
const auto& name = FString(dir_entries[n - 1].name);
|
|
|
|
if ( dir_entries[n - 1].directory )
|
|
filename.setText(name + '/');
|
|
else
|
|
filename.setText(name);
|
|
|
|
filename.redraw();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::cb_processClicked (FWidget*, FDataPtr)
|
|
{
|
|
const uLong n = uLong(filebrowser.currentItem() - 1);
|
|
|
|
if ( dir_entries[n].directory )
|
|
changeDir(dir_entries[n].name);
|
|
else
|
|
done (FDialog::Accept);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::cb_processCancel (FWidget*, FDataPtr)
|
|
{
|
|
done (FDialog::Reject);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::cb_processOpen (FWidget*, FDataPtr)
|
|
{
|
|
done (FDialog::Accept);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void FFileDialog::cb_processShowHidden (FWidget*, FDataPtr)
|
|
{
|
|
setShowHiddenFiles(! show_hidden);
|
|
}
|
|
|
|
} // namespace finalcut
|