FmPathList* fm_folder_view_get_selected_file_paths(FmFolderView* fv)
{
FmFileInfoList* files = fm_folder_view_get_selected_files(fv);
FmPathList* list;
if(files)
{
list = fm_path_list_new_from_file_info_list(files);
fm_list_unref(files);
}
else
list = NULL;
return list;
}
gboolean fm_dnd_dest_files_dropped(FmDndDest* dd, GdkDragAction action,
int info_type, FmList* files)
{
FmPath* dest;
GtkWidget* parent;
dest = fm_dnd_dest_get_dest_path(dd);
if(!dest)
return FALSE;
g_debug("%d files-dropped!, info_type: %d", fm_list_get_length(files), info_type);
if(fm_list_is_file_info_list(files))
files = fm_path_list_new_from_file_info_list(files);
else
fm_list_ref(files);
parent = gtk_widget_get_toplevel(dd->widget);
switch(action)
{
case GDK_ACTION_MOVE:
if(fm_path_is_trash_root(fm_dnd_dest_get_dest_path(dd)))
fm_trash_files(GTK_WINDOW(parent), files);
else
fm_move_files(GTK_WINDOW(parent), files, fm_dnd_dest_get_dest_path(dd));
break;
case GDK_ACTION_COPY:
fm_copy_files(GTK_WINDOW(parent), files, fm_dnd_dest_get_dest_path(dd));
break;
case GDK_ACTION_LINK:
// fm_link_files(parent, files, fm_dnd_dest_get_dest_path(dd));
break;
case GDK_ACTION_ASK:
g_debug("TODO: GDK_ACTION_ASK");
break;
}
fm_list_unref(files);
return TRUE;
}
FilePropsDialog::FilePropsDialog(FmFileInfoList* files, QWidget* parent, Qt::WindowFlags f):
QDialog(parent, f),
fileInfos_(fm_file_info_list_ref(files)),
singleType(fm_file_info_list_is_same_type(files)),
singleFile(fm_file_info_list_get_length(files) == 1 ? true:false),
fileInfo(fm_file_info_list_peek_head(files)),
mimeType(NULL) {
setAttribute(Qt::WA_DeleteOnClose);
ui = new Ui::FilePropsDialog();
ui->setupUi(this);
if(singleType) {
mimeType = fm_mime_type_ref(fm_file_info_get_mime_type(fileInfo));
}
FmPathList* paths = fm_path_list_new_from_file_info_list(files);
deepCountJob = fm_deep_count_job_new(paths, FM_DC_JOB_DEFAULT);
fm_path_list_unref(paths);
initGeneralPage();
initPermissionsPage();
}
void on_dnd_dest_files_dropped(FmDndDest* dd, GdkDragAction action,
int info_type, FmList* files, FmPlacesView* view)
{
FmPath* dest;
GList* l;
dest = fm_dnd_dest_get_dest_path(dd);
g_debug("action= %d, %d files-dropped!, info_type: %d", action, fm_list_get_length(files), info_type);
if(action != GDK_ACTION_LINK)
{
if(fm_list_is_file_info_list(files))
files = fm_path_list_new_from_file_info_list(files);
else
fm_list_ref(files);
}
switch(action)
{
case GDK_ACTION_MOVE:
if(fm_path_is_trash_root(dest))
fm_trash_files(files);
else
fm_move_files(files, dest);
break;
case GDK_ACTION_COPY:
fm_copy_files(files, dest);
break;
case GDK_ACTION_LINK:
{
GtkTreePath* tp = view->dest_row;
if(tp)
{
GtkTreePath* sep = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &sep_it);
int idx = gtk_tree_path_get_indices(tp)[0] - gtk_tree_path_get_indices(sep)[0];
gtk_tree_path_free(sep);
if(view->dest_pos == GTK_TREE_VIEW_DROP_BEFORE)
--idx;
for( l=fm_list_peek_head_link(files); l; l=l->next, ++idx )
{
FmBookmarkItem* item;
if(fm_list_is_file_info_list(files))
{
FmFileInfo* fi = (FmFileInfo*)l->data;
item = fm_bookmarks_insert( bookmarks, fi->path, fi->disp_name, idx);
}
else
{
FmPath* path = (FmPath*)l->data;
char* disp_name = g_filename_display_name(path->name);
item = fm_bookmarks_insert( bookmarks, path, disp_name, idx);
g_free(disp_name);
}
/* we don't need to add item to places view. Later the bookmarks will be reloaded. */
}
}
}
break;
}
fm_list_unref(files);
if(view->dest_row)
{
gtk_tree_path_free(view->dest_row);
view->dest_row = NULL;
}
}
void FilePropsDialog::accept() {
// applications
if(mimeType && ui->openWith->isChanged()) {
GAppInfo* currentApp = ui->openWith->selectedApp();
g_app_info_set_as_default_for_type(currentApp, fm_mime_type_get_type(mimeType), NULL);
}
// check if chown or chmod is needed
guint32 newUid = uidFromName(ui->owner->text());
guint32 newGid = gidFromName(ui->ownerGroup->text());
bool needChown = (newUid != -1 && newUid != uid) || (newGid != -1 && newGid != gid);
int newOwnerPermSel = ui->ownerPerm->currentIndex();
int newGroupPermSel = ui->groupPerm->currentIndex();
int newOtherPermSel = ui->otherPerm->currentIndex();
Qt::CheckState newExecCheckState = ui->executable->checkState();
bool needChmod = ((newOwnerPermSel != ownerPermSel) ||
(newGroupPermSel != groupPermSel) ||
(newOtherPermSel != otherPermSel) ||
(newExecCheckState != execCheckState));
if(needChmod || needChown) {
FmPathList* paths = fm_path_list_new_from_file_info_list(fileInfos_);
FileOperation* op = new FileOperation(FileOperation::ChangeAttr, paths);
fm_path_list_unref(paths);
if(needChown) {
// don't do chown if new uid/gid and the original ones are actually the same.
if(newUid == uid)
newUid = -1;
if(newGid == gid)
newGid = -1;
op->setChown(newUid, newGid);
}
if(needChmod) {
mode_t newMode = 0;
mode_t newModeMask = 0;
// FIXME: we need to make sure that folders with "r" permission also have "x"
// at the same time. Otherwise, it's not able to browse the folder later.
if(newOwnerPermSel != ownerPermSel && newOwnerPermSel != ACCESS_NO_CHANGE) {
// owner permission changed
newModeMask |= (S_IRUSR|S_IWUSR); // affect user bits
if(newOwnerPermSel == ACCESS_READ_ONLY)
newMode |= S_IRUSR;
else if(newOwnerPermSel == ACCESS_READ_WRITE)
newMode |= (S_IRUSR|S_IWUSR);
}
if(newGroupPermSel != groupPermSel && newGroupPermSel != ACCESS_NO_CHANGE) {
qDebug("newGroupPermSel: %d", newGroupPermSel);
// group permission changed
newModeMask |= (S_IRGRP|S_IWGRP); // affect group bits
if(newGroupPermSel == ACCESS_READ_ONLY)
newMode |= S_IRGRP;
else if(newGroupPermSel == ACCESS_READ_WRITE)
newMode |= (S_IRGRP|S_IWGRP);
}
if(newOtherPermSel != otherPermSel && newOtherPermSel != ACCESS_NO_CHANGE) {
// other permission changed
newModeMask |= (S_IROTH|S_IWOTH); // affect other bits
if(newOtherPermSel == ACCESS_READ_ONLY)
newMode |= S_IROTH;
else if(newOtherPermSel == ACCESS_READ_WRITE)
newMode |= (S_IROTH|S_IWOTH);
}
if(newExecCheckState != execCheckState && newExecCheckState != Qt::PartiallyChecked) {
// executable state changed
newModeMask |= (S_IXUSR|S_IXGRP|S_IXOTH);
if(newExecCheckState == Qt::Checked)
newMode |= (S_IXUSR|S_IXGRP|S_IXOTH);
}
op->setChmod(newMode, newModeMask);
if(hasDir) { // if there are some dirs in our selected files
QMessageBox::StandardButton r = QMessageBox::question(this,
tr("Apply changes"),
tr("Do you want to recursively apply these changes to all files and sub-folders?"),
QMessageBox::Yes|QMessageBox::No);
if(r == QMessageBox::Yes)
op->setRecursiveChattr(true);
}
}
op->setAutoDestroy(true);
op->run();
}
QDialog::accept();
}
GtkWidget *fm_file_properties_widget_new (FmFileInfoList *files, gboolean toplevel)
{
GtkBuilder *builder=gtk_builder_new ();
GtkWidget *dlg, *total_size;
FmFilePropData *data;
FmPathList *paths;
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
data = g_slice_new0 (FmFilePropData);
data->files = fm_list_ref (files);
data->single_type = fm_file_info_list_is_same_type (files);
data->single_file = (fm_list_get_length (files) == 1);
data->file_info = fm_list_peek_head (files);
FmMimeType *fi_mime_type = fm_file_info_get_mime_type (data->file_info, FALSE);
if (data->single_type)
data->mime_type = fi_mime_type; // FIXME_pcm: do we need ref counting here?
paths = fm_path_list_new_from_file_info_list (files);
data->dc_job = fm_deep_count_job_new (paths, FM_DC_JOB_DEFAULT);
fm_list_unref (paths);
if (toplevel)
{
gtk_builder_add_from_string (builder, PROPERTIES_DLG, -1, NULL);
GET_WIDGET (dlg);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (data->dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
}
else
{
#if 0
// FIXME_pcm: is this really useful?
const char *names[]= {"notebook", NULL};
gtk_builder_add_objects_from_file (builder, UI_FILE, names, NULL);
data->dlg = (GtkWidget*)gtk_builder_get_object (builder, "notebook");
#endif
}
dlg = data->dlg;
GET_WIDGET (icon);
GET_WIDGET (name);
GET_WIDGET (dir);
GET_WIDGET (target);
GET_WIDGET (target_label);
GET_WIDGET (type);
GET_WIDGET (open_with_label);
GET_WIDGET (open_with);
GET_WIDGET (total_size);
GET_WIDGET (size_on_disk);
GET_WIDGET (mtime);
GET_WIDGET (atime);
GET_WIDGET (owner);
GET_WIDGET (group);
GET_WIDGET (owner_perm);
GET_WIDGET (group_perm);
GET_WIDGET (other_perm);
GET_WIDGET (exec);
g_object_unref (builder);
init_application_list (data);
data->timeout = g_timeout_add (600, (GSourceFunc)on_timeout, data);
g_signal_connect (dlg, "response", G_CALLBACK (on_response), data);
g_signal_connect_swapped (dlg, "destroy", G_CALLBACK (fm_file_prop_data_free), data);
g_signal_connect (data->dc_job, "finished", G_CALLBACK (on_finished), data);
fm_job_run_async (data->dc_job);
update_ui (data);
return dlg;
}
static void on_response (GtkDialog *dlg, int response, FmFilePropData *data)
{
if ( response == GTK_RESPONSE_OK )
{
int sel;
const char *new_owner = gtk_entry_get_text (GTK_ENTRY (data->owner));
const char *new_group = gtk_entry_get_text (GTK_ENTRY (data->group));
guint32 uid = -1, gid = -1;
mode_t new_mode = 0, new_mode_mask = 0;
if (!ensure_valid_owner (data) || !ensure_valid_group (data))
{
g_signal_stop_emission_by_name (dlg, "response");
return;
}
/* FIXME_pcm: if all files are native, it's possible to check
* if the names are legal user and group names on the local
* machine prior to chown. */
if (new_owner && *new_owner && g_strcmp0 (data->orig_owner, new_owner))
{
// change owner
g_debug ("change owner to: %d", data->uid);
}
else
data->uid = -1;
if (new_group && *new_group && g_strcmp0 (data->orig_group, new_group))
{
// change group
g_debug ("change group to: %d", data->gid);
}
else
data->gid = -1;
// check if chmod is needed here.
sel = gtk_combo_box_get_active (GTK_COMBO_BOX (data->owner_perm));
if ( sel != NO_CHANGE ) // need to change owner permission
{
if (data->owner_perm_sel != sel) // new value is different from original
{
new_mode_mask |= S_IRUSR|S_IWUSR;
data->owner_perm_sel = sel;
switch (sel)
{
case READ_WRITE:
new_mode |= S_IRUSR|S_IWUSR;
break;
case READ_ONLY:
new_mode |= S_IRUSR;
break;
case WRITE_ONLY:
new_mode |= S_IWUSR;
break;
}
}
else // otherwise, no change
data->owner_perm_sel = NO_CHANGE;
}
else
data->owner_perm_sel = NO_CHANGE;
sel = gtk_combo_box_get_active (GTK_COMBO_BOX (data->group_perm));
if ( sel != NO_CHANGE ) // need to change group permission
{
if (data->group_perm_sel != sel) // new value is different from original
{
new_mode_mask |= S_IRGRP|S_IWGRP;
data->group_perm_sel = sel;
switch (sel)
{
case READ_WRITE:
new_mode |= S_IRGRP|S_IWGRP;
break;
case READ_ONLY:
new_mode |= S_IRGRP;
break;
case WRITE_ONLY:
new_mode |= S_IWGRP;
break;
}
}
else // otherwise, no change
data->group_perm_sel = NO_CHANGE;
}
else
data->group_perm_sel = NO_CHANGE;
#if 0
sel = gtk_combo_box_get_active (GTK_COMBO_BOX (data->other_perm));
if ( sel != NO_CHANGE ) // need to change other permission
{
if (data->other_perm_sel != sel) // new value is different from original
{
new_mode_mask |= S_IROTH|S_IWOTH;
switch (sel)
{
case READ_WRITE:
new_mode |= S_IROTH|S_IWOTH;
break;
case READ_ONLY:
new_mode |= S_IROTH;
break;
case WRITE_ONLY:
new_mode |= S_IWOTH;
break;
}
data->other_perm_sel = sel;
}
else // otherwise, no change
data->other_perm_sel = NO_CHANGE;
}
else
data->other_perm_sel = NO_CHANGE;
if (!data->has_dir
&& !gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (data->exec))
&& gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->exec)) != data->exec_state)
{
new_mode_mask |= (S_IXUSR|S_IXGRP|S_IXOTH);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->exec)))
new_mode |= (S_IXUSR|S_IXGRP|S_IXOTH);
}
if (new_mode_mask || data->uid != -1 || data->gid != -1)
{
FmPathList *paths = fm_path_list_new_from_file_info_list (data->files);
FmFileOpsJob *job = (FmFileOpsJob*) fm_file_ops_job_new (FM_FILE_OP_CHANGE_ATTR, paths);
// need to chown
if (data->uid != -1 || data->gid != -1)
fm_file_ops_job_set_chown (job, data->uid, data->gid);
// need to do chmod
if (new_mode_mask)
fm_file_ops_job_set_chmod (job, new_mode, new_mode_mask);
if (data->has_dir)
{
if (fm_yes_no (GTK_WINDOW (data->dlg), NULL, _( "Do you want to recursively apply these changes to all files and sub-folders?" ), TRUE))
fm_file_ops_job_set_recursive (job, TRUE);
}
// show progress dialog
fm_file_ops_job_run_with_progress (GTK_WINDOW (data->dlg), job);
fm_list_unref (paths);
}
// change default application for the mime-type if needed
if (data->mime_type && fm_mime_type_get_type (data->mime_type) && data->open_with)
{
GAppInfo *app;
gboolean default_app_changed = FALSE;
GError *err = NULL;
app = fm_app_chooser_combo_box_get_selected (GTK_COMBO_BOX (data->open_with), &default_app_changed);
if (app)
{
if (default_app_changed)
{
g_app_info_set_as_default_for_type (app, fm_mime_type_get_type (data->mime_type), &err);
if (err)
{
fm_show_error (GTK_WINDOW (dlg), NULL, err->message);
g_error_free (err);
}
}
g_object_unref (app);
}
}
if (data->single_file) // when only one file is shown
{
// if the user has changed its name
if ( g_strcmp0 (data->file_info->disp_name, gtk_entry_get_text (GTK_ENTRY (data->name))) )
{
// FIXME_pcm: rename the file or set display name for it.
}
}
#endif
}
gtk_widget_destroy (GTK_WIDGET (dlg));
}
