ExecFileDialog::ExecFileDialog(FmFileInfo* file, QWidget* parent, Qt::WindowFlags f): QDialog (parent, f), fileInfo_(fm_file_info_ref(file)), result_(FM_FILE_LAUNCHER_EXEC_CANCEL), ui(new Ui::ExecFileDialog()) { ui->setupUi(this); // show file icon FmIcon* icon = fm_file_info_get_icon(fileInfo_); ui->icon->setPixmap(IconTheme::icon(icon).pixmap(QSize(48, 48))); QString msg; if(fm_file_info_is_text(file)) { msg = tr("This text file '%1' seems to be an executable script.\nWhat do you want to do with it?") .arg(QString::fromUtf8(fm_file_info_get_disp_name(file))); ui->execTerm->setDefault(true); } else { msg= tr("This file '%1' is executable. Do you want to execute it?") .arg(QString::fromUtf8(fm_file_info_get_disp_name(file))); ui->exec->setDefault(true); ui->open->hide(); } ui->msg->setText(msg); }
static void on_sel_changed(FmFolderView* fv, FmFileInfoList* files, FmMainWin* win) { /* popup previous message if there is any */ gtk_statusbar_pop(GTK_STATUSBAR(win->statusbar), win->statusbar_ctx2); if(files) { char* msg; /* FIXME: display total size of all selected files. */ if(fm_list_get_length(files) == 1) /* only one file is selected */ { FmFileInfo* fi = fm_list_peek_head(files); const char* size_str = fm_file_info_get_disp_size(fi); if(size_str) { msg = g_strdup_printf("\"%s\" (%s) %s", fm_file_info_get_disp_name(fi), size_str ? size_str : "", fm_file_info_get_desc(fi)); } else { msg = g_strdup_printf("\"%s\" %s", fm_file_info_get_disp_name(fi), fm_file_info_get_desc(fi)); } } else msg = g_strdup_printf("%d items selected", fm_list_get_length(files)); gtk_statusbar_push(GTK_STATUSBAR(win->statusbar), win->statusbar_ctx2, msg); g_free(msg); } }
// when the current selection in the folder view is changed void TabPage::onSelChanged(int numSel) { QString msg; if(numSel > 0) { /* FIXME: display total size of all selected files. */ if(numSel == 1) { /* only one file is selected */ FmFileInfoList* files = folderView_->selectedFiles(); FmFileInfo* fi = fm_file_info_list_peek_head(files); const char* size_str = fm_file_info_get_disp_size(fi); if(size_str) { msg = QString("\"%1\" (%2) %3") .arg(QString::fromUtf8(fm_file_info_get_disp_name(fi))) .arg(QString::fromUtf8(size_str ? size_str : "")) .arg(QString::fromUtf8(fm_file_info_get_desc(fi))); } else { msg = QString("\"%1\" %2") .arg(QString::fromUtf8(fm_file_info_get_disp_name(fi))) .arg(QString::fromUtf8(fm_file_info_get_desc(fi))); } /* FIXME: should we support statusbar plugins as in the gtk+ version? */ fm_file_info_list_unref(files); } else { goffset sum; GList* l; msg = tr("%1 item(s) selected", NULL, numSel).arg(numSel); /* don't count if too many files are selected, that isn't lightweight */ if(numSel < 1000) { sum = 0; FmFileInfoList* files = folderView_->selectedFiles(); for(l = fm_file_info_list_peek_head_link(files); l; l = l->next) { if(fm_file_info_is_dir(FM_FILE_INFO(l->data))) { /* if we got a directory then we cannot tell it's size unless we do deep count but we cannot afford it */ sum = -1; break; } sum += fm_file_info_get_size(FM_FILE_INFO(l->data)); } if(sum >= 0) { char size_str[128]; fm_file_size_to_str(size_str, sizeof(size_str), sum, fm_config->si_unit); msg += QString(" (%1)").arg(QString::fromUtf8(size_str)); } /* FIXME: should we support statusbar plugins as in the gtk+ version? */ fm_file_info_list_unref(files); } /* FIXME: can we show some more info on selection? that isn't lightweight if a lot of files are selected */ } } statusText_[StatusTextSelectedFiles] = msg; Q_EMIT statusChanged(StatusTextSelectedFiles, msg); }
bool FileLauncher::openFolder(GAppLaunchContext* ctx, GList* folder_infos, GError** err) { for(GList* l = folder_infos; l; l = l->next) { FmFileInfo* fi = FM_FILE_INFO(l->data); qDebug() << " folder:" << QString::fromUtf8(fm_file_info_get_disp_name(fi)); } return false; }
static gboolean subdir_check_remove_place_holder (FmDirTreeModel *dir_tree_model) { GList *item_list = dir_tree_model->current_subdir_check; if (!g_cancellable_is_cancelled (dir_tree_model->subdir_cancellable) && item_list) { FmDirTreeItem *dir_tree_item = (FmDirTreeItem*) item_list->data; // remove existing subdirs or place holder item if needed. if (dir_tree_item->children) { // Remove the place holder... JOB_DEBUG ("JOB_DEBUG: subdir_check_remove_place_holder: remove place holder for %s\n\n", fm_file_info_get_disp_name (dir_tree_item->file_info)); GtkTreePath *tree_path = fm_dir_tree_model_item_to_tree_path (dir_tree_model, item_list); fm_dir_tree_model_remove_all_children (dir_tree_model, item_list, tree_path); gtk_tree_path_free (tree_path); // why i added this ??? doesn't seem needed... //~ fm_dir_tree_model_remove_item (dir_tree_model, item_list); } } return subdir_check_finish (dir_tree_model); }
static void fm_dir_tree_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value) { FmDirTreeModel *dir_tree_model = FM_DIR_TREE_MODEL(tree_model); GList *item_list; FmDirTreeItem *dir_tree_item; g_return_if_fail (iter->stamp == dir_tree_model->stamp); g_value_init (value, column_types[column]); item_list = (GList*) iter->user_data; g_return_if_fail (item_list); dir_tree_item = (FmDirTreeItem*) item_list->data; g_return_if_fail (dir_tree_item); switch (column) { case FM_DIR_TREE_MODEL_COL_ICON: { if (dir_tree_item->file_info && fm_file_info_get_fm_icon (dir_tree_item->file_info)) { g_value_set_object (value, fm_dir_tree_item_get_pixbuf (dir_tree_item, dir_tree_model->icon_size)); } else { g_value_set_object (value, NULL); } } break; case FM_DIR_TREE_MODEL_COL_DISP_NAME: { if (dir_tree_item->file_info) g_value_set_string (value, fm_file_info_get_disp_name (dir_tree_item->file_info)); } break; case FM_DIR_TREE_MODEL_COL_INFO: g_value_set_pointer (value, dir_tree_item->file_info); break; case FM_DIR_TREE_MODEL_COL_PATH: g_value_set_pointer (value, dir_tree_item->file_info ? dir_tree_item->file_info->path : NULL); break; case FM_DIR_TREE_MODEL_COL_FOLDER: // ???? //~ g_value_set_pointer (value, dir_tree_item->folder ? dir_tree_item->folder : //~ dir_tree_item->file_info->folder); g_value_set_pointer (value, dir_tree_item->folder); break; } }
static void on_folder_view_sel_changed(FmFolderView* fv, gint n_sel, FmTabPage* page) { char* msg = page->status_text[FM_STATUS_TEXT_SELECTED_FILES]; g_free(msg); if(n_sel > 0) { /* FIXME: display total size of all selected files. */ if(n_sel == 1) /* only one file is selected */ { FmFileInfoList* files = fm_folder_view_dup_selected_files(fv); FmFileInfo* fi = fm_file_info_list_peek_head(files); const char* size_str = fm_file_info_get_disp_size(fi); if(size_str) { msg = g_strdup_printf("\"%s\" (%s) %s", fm_file_info_get_disp_name(fi), size_str ? size_str : "", fm_file_info_get_desc(fi)); } else { msg = g_strdup_printf("\"%s\" %s", fm_file_info_get_disp_name(fi), fm_file_info_get_desc(fi)); } fm_file_info_list_unref(files); } else { msg = g_strdup_printf(ngettext("%d item selected", "%d items selected", n_sel), n_sel); } } else msg = NULL; page->status_text[FM_STATUS_TEXT_SELECTED_FILES] = msg; g_signal_emit(page, signals[STATUS], 0, (guint)FM_STATUS_TEXT_SELECTED_FILES, msg); }
/*static*/ void TabPage::onFolderFinishLoading(FmFolder* _folder, TabPage* pThis) { // FIXME: is this needed? FmFileInfo* fi = fm_folder_get_info(_folder); if(fi) { // if loading of the folder fails, it's possible that we don't have FmFileInfo. pThis->title_ = QString::fromUtf8(fm_file_info_get_disp_name(fi)); Q_EMIT pThis->titleChanged(pThis->title_); } fm_folder_query_filesystem_info(_folder); // FIXME: is this needed? #if 0 FmFolderView* fv = folder_view; const FmNavHistoryItem* item; GtkScrolledWindow* scroll = GTK_SCROLLED_WINDOW(fv); /* Note: most of the time, we delay the creation of the * folder model and do it after the whole folder is loaded. * That is because adding rows into model is much faster when no handlers * are connected to its signals. So we detach the model from folder view * and create the model again when it's fully loaded. * This optimization, however, is not used for FmFolder objects * with incremental loading (search://) */ if(fm_folder_view_get_model(fv) == NULL) { /* create a model for the folder and set it to the view */ FmFolderModel* model = fm_folder_model_new(folder, app_config->show_hidden); fm_folder_view_set_model(fv, model); #if FM_CHECK_VERSION(1, 0, 2) /* since 1.0.2 sorting should be applied on model instead of view */ fm_folder_model_set_sort(model, app_config->sort_by, (app_config->sort_type == GTK_SORT_ASCENDING) ? FM_SORT_ASCENDING : FM_SORT_DESCENDING); #endif g_object_unref(model); } #endif // update status text QString& text = pThis->statusText_[StatusTextNormal]; text = pThis->formatStatusText(); Q_EMIT pThis->statusChanged(StatusTextNormal, text); if(pThis->overrideCursor_) { QApplication::restoreOverrideCursor(); // remove busy cursor pThis->overrideCursor_ = false; } // After finishing loading the folder, the model is updated, but Qt delays the UI update // for performance reasons. Therefore at this point the UI is not up to date. // Of course, the scrollbar ranges are not updated yet. We solve this by installing an Qt timeout handler. QTimer::singleShot(10, pThis, SLOT(restoreScrollPos())); }
static gint on_ask_rename(FmFileOpsJob* job, FmFileInfo* src, FmFileInfo* dest, char** new_name, FmProgressDisplay* data) { int res; GtkBuilder* builder; GtkDialog *dlg; GtkImage *src_icon, *dest_icon; GtkLabel *src_fi, *dest_fi; GtkEntry *filename; GtkToggleButton *apply_all; char* tmp; const char* disp_size; FmPath* path; FmIcon* icon; /* return default operation if the user has set it */ if(data->default_opt) return data->default_opt; builder = gtk_builder_new(); path = fm_file_info_get_path(dest); icon = fm_file_info_get_icon(src); if(data->timer) g_timer_stop(data->timer); gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE); ensure_dlg(data); gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/ask-rename.ui", NULL); dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg")); src_icon = GTK_IMAGE(gtk_builder_get_object(builder, "src_icon")); src_fi = GTK_LABEL(gtk_builder_get_object(builder, "src_fi")); dest_icon = GTK_IMAGE(gtk_builder_get_object(builder, "dest_icon")); dest_fi = GTK_LABEL(gtk_builder_get_object(builder, "dest_fi")); filename = GTK_ENTRY(gtk_builder_get_object(builder, "filename")); apply_all = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "apply_all")); gtk_window_set_transient_for(GTK_WINDOW(dlg), GTK_WINDOW(data->dlg)); gtk_image_set_from_gicon(src_icon, icon->gicon, GTK_ICON_SIZE_DIALOG); disp_size = fm_file_info_get_disp_size(src); if(disp_size) { tmp = g_strdup_printf(_("Type: %s\nSize: %s\nModified: %s"), fm_file_info_get_desc(src), disp_size, fm_file_info_get_disp_mtime(src)); } else { tmp = g_strdup_printf(_("Type: %s\nModified: %s"), fm_file_info_get_desc(src), fm_file_info_get_disp_mtime(src)); } gtk_label_set_text(src_fi, tmp); g_free(tmp); gtk_image_set_from_gicon(dest_icon, icon->gicon, GTK_ICON_SIZE_DIALOG); disp_size = fm_file_info_get_disp_size(dest); if(disp_size) { tmp = g_strdup_printf(_("Type: %s\nSize: %s\nModified: %s"), fm_file_info_get_desc(dest), fm_file_info_get_disp_size(dest), fm_file_info_get_disp_mtime(dest)); } else { tmp = g_strdup_printf(_("Type: %s\nModified: %s"), fm_file_info_get_desc(dest), fm_file_info_get_disp_mtime(dest)); } gtk_label_set_text(dest_fi, tmp); g_free(tmp); tmp = g_filename_display_name(fm_path_get_basename(path)); gtk_entry_set_text(filename, tmp); g_free(tmp); tmp = (char*)fm_file_info_get_disp_name(dest); /* FIXME: cast const to char */ g_object_set_data(G_OBJECT(filename), "old_name", tmp); g_signal_connect(filename, "changed", G_CALLBACK(on_filename_changed), gtk_builder_get_object(builder, "rename")); g_object_unref(builder); res = gtk_dialog_run(dlg); switch(res) { case RESPONSE_RENAME: *new_name = g_strdup(gtk_entry_get_text(filename)); res = FM_FILE_OP_RENAME; break; case RESPONSE_OVERWRITE: res = FM_FILE_OP_OVERWRITE; break; case RESPONSE_SKIP: res = FM_FILE_OP_SKIP; break; default: res = FM_FILE_OP_CANCEL; } if(gtk_toggle_button_get_active(apply_all)) { if(res == RESPONSE_OVERWRITE || res == FM_FILE_OP_SKIP) data->default_opt = res; } gtk_widget_destroy(GTK_WIDGET(dlg)); if(data->timer) g_timer_continue(data->timer); return res; }
/* NOTE: Sticking to natural behavior of returning a list with the unchanged input_string, incase nothing can be substituted, however, this is expensive. A better way would be to return NULL incase of no changes, and let the caller handle the NULL case, which implies that there is no change in the input_string */ GPtrArray* substitute_parameters(gchar *input_string, FmFileInfoList *file_info_list) { //printf("Input string is %s\n", input_string); GPtrArray *out_string_array = g_ptr_array_new(); if(strchr(input_string, '%') == NULL){ //printf("Found nothing to expand. Returning input_string.\n"); g_ptr_array_add(out_string_array, g_string_new(input_string)); return out_string_array; } gsize i, j; gsize len_file_list = fm_list_get_length(file_info_list); GString *out_string = g_string_new(NULL); gsize first_pos = strcspn(input_string, "%"); gchar *pos = input_string + first_pos; g_string_append_len(out_string, input_string, first_pos); GString *g_string_i = NULL; gchar *base_name = NULL, *base_dir = NULL, *file_name = NULL, *host_name = NULL, *user_name = NULL, *port = NULL, *scheme = NULL, *uri = NULL, *file_name_wo_ext = NULL, *ext_pos = NULL; gboolean array_is_init = FALSE; FmFileInfo *file_info_i = NULL, *file_info_j = NULL; char temp[256]; gboolean curr_dir_flag; while((pos = strchr(pos, '%')) != NULL){ switch(pos[1]){ case 'b': /* Works */ if(array_is_init == FALSE){ for(i=0; i<len_file_list; ++i){ g_string_i = g_string_new(out_string->str); file_info_i = fm_list_peek_nth(file_info_list, i); base_name = (gchar *)fm_file_info_get_disp_name(file_info_i); g_string_append(g_string_i, base_name); g_string_append_c(g_string_i, ' '); g_ptr_array_add(out_string_array, g_string_new(g_string_i->str)); g_string_free(g_string_i, TRUE); } break; } file_info_i = fm_list_peek_head(file_info_list); base_name = (gchar *)fm_file_info_get_disp_name(file_info_i); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); g_string_append(g_string_i, base_name); g_string_append_c(g_string_i, ' '); } break; case 'B': /* Works */ if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); for(j=0; j<len_file_list; ++j){ file_info_j= fm_list_peek_nth(file_info_list, j); base_name = (gchar *)fm_file_info_get_disp_name(file_info_j); g_string_append(g_string_i, base_name); g_string_append_c(g_string_i, ' '); } } break; case 'c': /* Works */ memset(temp, 256, 0); if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); sprintf(temp, "%u", len_file_list); g_string_append(g_string_i, temp); g_string_append_c(g_string_i, ' '); } break; case 'd': /* Works */ curr_dir_flag = FALSE; if(array_is_init == FALSE){ for(i=0; i<len_file_list; ++i){ g_string_i = g_string_new(out_string->str); file_info_i = fm_list_peek_nth(file_info_list, i); if(fm_file_info_is_dir(file_info_i) == TRUE){ base_dir = fm_path_to_str(fm_file_info_get_path(file_info_i)); } else { if(curr_dir_flag == FALSE){ base_dir = g_get_current_dir(); curr_dir_flag = TRUE; } else { continue; } } g_string_append(g_string_i, base_dir); g_string_append_c(g_string_i, ' '); g_ptr_array_add(out_string_array, g_string_new(g_string_i->str)); g_free(base_dir); g_string_free(g_string_i, TRUE); } break; } file_info_i = fm_list_peek_head(file_info_list); if(fm_file_info_is_dir(file_info_i) == TRUE){ base_dir = fm_path_to_str(fm_file_info_get_path(file_info_i)); } else { if(curr_dir_flag == FALSE){ base_dir = g_get_current_dir(); curr_dir_flag = TRUE; } else { continue; } } for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); g_string_append(g_string_i, base_dir); g_string_append_c(g_string_i, ' '); } g_free(base_dir); break; case 'D': /* Works */ if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ curr_dir_flag = FALSE; g_string_i = (GString *)g_ptr_array_index(out_string_array, i); for(j=0; j<len_file_list; ++j){ file_info_j= fm_list_peek_nth(file_info_list, j); if(fm_file_info_is_dir(file_info_j) == TRUE){ base_dir = fm_path_to_str(fm_file_info_get_path(file_info_j)); } else { if(curr_dir_flag == FALSE){ base_dir = g_get_current_dir(); curr_dir_flag = TRUE; } else { continue; } } g_string_append(g_string_i, base_dir); g_string_append_c(g_string_i, ' '); g_free(base_dir); } } break; case 'f': /* Works */ if(array_is_init == FALSE){ for(i=0; i<len_file_list; ++i){ g_string_i = g_string_new(out_string->str); file_info_i = fm_list_peek_nth(file_info_list, i); file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_i)); g_string_append(g_string_i, file_name); g_string_append_c(g_string_i, ' '); g_ptr_array_add(out_string_array, g_string_new(g_string_i->str)); g_free(file_name); g_string_free(g_string_i, TRUE); } break; } file_info_i = fm_list_peek_head(file_info_list); file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_i)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); g_string_append(g_string_i, file_name); g_string_append_c(g_string_i, ' '); } g_free(file_name); break; case 'F': /* Works */ if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); for(j=0; j<len_file_list; ++j){ file_info_j= fm_list_peek_nth(file_info_list, j); file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_j)); g_string_append(g_string_i, file_name); g_string_append_c(g_string_i, ' '); g_free(file_name); } } break; case 'h': if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); file_info_i = fm_list_peek_nth(file_info_list, i); host_name = get_host_name(file_info_i); g_string_append(g_string_i, host_name); g_string_append_c(g_string_i, ' '); } break; case 'n': if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); file_info_i = fm_list_peek_nth(file_info_list, i); user_name = get_user_name(file_info_i); g_string_append(g_string_i, user_name); g_string_append_c(g_string_i, ' '); } break; case 'p': if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); file_info_i = fm_list_peek_nth(file_info_list, i); port = get_port(file_info_i); g_string_append(g_string_i, port); g_string_append_c(g_string_i, ' '); } break; case 's': if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); file_info_i = fm_list_peek_nth(file_info_list, i); scheme = get_scheme(file_info_i); g_string_append(g_string_i, scheme); g_string_append_c(g_string_i, ' '); } break; case 'u': /* Works */ if(array_is_init == FALSE){ for(i=0; i<len_file_list; ++i){ g_string_i = g_string_new(out_string->str); file_info_i = fm_list_peek_nth(file_info_list, i); uri = fm_path_to_uri(fm_file_info_get_path(file_info_i)); g_string_append(g_string_i, uri); g_string_append_c(g_string_i, ' '); g_ptr_array_add(out_string_array, g_string_new(g_string_i->str)); g_string_free(g_string_i, TRUE); } break; } file_info_i = fm_list_peek_head(file_info_list); uri = fm_path_to_uri(fm_file_info_get_path(file_info_i)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); g_string_append(g_string_i, uri); g_string_append_c(g_string_i, ' '); } break; case 'U': /* Works */ if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); for(j=0; j<len_file_list; ++j){ file_info_j= fm_list_peek_nth(file_info_list, j); uri = fm_path_to_uri(fm_file_info_get_path(file_info_j)); g_string_append(g_string_i, uri); g_string_append_c(g_string_i, ' '); } } break; case 'w': /* Works */ if(array_is_init == FALSE){ for(i=0; i<len_file_list; ++i){ g_string_i = g_string_new(out_string->str); file_info_i = fm_list_peek_nth(file_info_list, i); file_name = (gchar *)fm_file_info_get_disp_name(file_info_i); //printf("%s\n", file_name); ext_pos = g_strrstr(fm_file_info_get_disp_name(fm_list_peek_nth(file_info_list, i)), "."); if(ext_pos != NULL) file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos)); else file_name_wo_ext = g_strdup(file_name); g_string_append(g_string_i, file_name_wo_ext); g_string_append_c(g_string_i, ' '); g_ptr_array_add(out_string_array, g_string_new(g_string_i->str)); g_free(file_name_wo_ext); g_string_free(g_string_i, TRUE); } break; } file_info_i = fm_list_peek_head(file_info_list); file_name = (gchar *)fm_file_info_get_disp_name(file_info_i); ext_pos = g_strrstr(file_name, "."); if(ext_pos != NULL) file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos)); else file_name_wo_ext = g_strdup(file_name); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); g_string_append(g_string_i, file_name_wo_ext); g_string_append_c(g_string_i, ' '); } g_free(file_name_wo_ext); break; case 'W': /* Works */ if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); for(j=0; j<len_file_list; ++j){ file_info_j= fm_list_peek_nth(file_info_list, j); file_name = (gchar *)fm_file_info_get_disp_name(file_info_j); ext_pos = g_strrstr(file_name, "."); if(ext_pos != NULL) file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos)); else file_name_wo_ext = g_strdup(file_name); g_string_append(g_string_i, file_name_wo_ext); g_string_append_c(g_string_i, ' '); g_free(file_name_wo_ext); } } break; case 'x': /* Works */ if(array_is_init == FALSE){ for(i=0; i<len_file_list; ++i){ file_info_i = fm_list_peek_nth(file_info_list, i); file_name = (gchar *)fm_file_info_get_disp_name(file_info_i); ext_pos = g_strrstr(file_name, "."); if(ext_pos != NULL){ g_string_i = g_string_new(out_string->str); g_string_append(g_string_i, ext_pos); g_string_append_c(g_string_i, ' '); g_ptr_array_add(out_string_array, g_string_new(g_string_i->str)); g_free(file_name_wo_ext); g_string_free(g_string_i, TRUE); } } break; } file_info_i = fm_list_peek_head(file_info_list); file_name = (gchar *)fm_file_info_get_disp_name(file_info_i); ext_pos = g_strrstr(file_name, "."); if(ext_pos == NULL) break; for(i=0; i<out_string_array->len;++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); g_string_append(g_string_i, ext_pos); g_string_append_c(g_string_i, ' '); } break; case 'X': /* Works */ if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); for(j=0; j<len_file_list; ++j){ file_info_j= fm_list_peek_nth(file_info_list, j); file_name = (gchar *)fm_file_info_get_disp_name(file_info_j); ext_pos = g_strrstr(file_name, "."); if(ext_pos != NULL){ g_string_append(g_string_i, ext_pos); g_string_append_c(g_string_i, ' '); } } } break; case '%': /* Works */ if(array_is_init == FALSE) g_ptr_array_add(out_string_array, g_string_new(out_string->str)); for(i=0; i<out_string_array->len; ++i){ g_string_i = (GString *)g_ptr_array_index(out_string_array, i); g_string_append(g_string_i, "% "); } break; default: return NULL; } pos += 2; (array_is_init == FALSE)?array_is_init = TRUE:0; } return out_string_array; }
static void on_folder_view_sel_changed(FmFolderView* fv, FmFileInfoList* files, FmTabPage* page) { char* msg = page->status_text[FM_STATUS_TEXT_SELECTED_FILES]; g_free(msg); msg = NULL; // use SI metric by default static gboolean use_si_prefix = TRUE ; unsigned items_num = 0; if (files) items_num = fm_list_get_length(files) ; if (items_num > 1) // multiple items are selected { goffset items_totalsize = 0 ; // whether selected items contain dir gboolean items_contain_dir = FALSE ; GList* l; for (l=fm_list_peek_head_link(files);l;l=l->next) { FmFileInfo* fi = (FmFileInfo*)l->data; // ignore dir when calculating total size. because that // may take a long long time, not suitable for updating // statusbar in real time. if (fm_file_info_is_dir(fi) ) { items_contain_dir = TRUE; } else { // Non-dir items are regard as files // Should extra logic be added for different kinds of files? // hardlink, symlink, pipe, socket ? items_totalsize += fm_file_info_get_size(fi) ; } } // when the selected items contain dir, do not show size info on the // statusbar, because the calculated total size counts for files only // and showing it would be misleading to the user. if (items_contain_dir) { msg = g_strdup_printf("%d items selected", items_num); } else { char items_totalsize_str[ 64 ]; fm_file_size_to_str( items_totalsize_str, items_totalsize, use_si_prefix ); msg = g_strdup_printf("%d items selected, total size: %s", \ items_num, items_totalsize_str); } } else if (items_num == 1) { FmFileInfo* fi = fm_list_peek_head(files); const char* size_str = fm_file_info_get_disp_size(fi); gboolean is_link = fm_file_info_is_symlink(fi); if (is_link && size_str) { msg = g_strdup_printf("\"%s\" link to \"%s\" (%s)", fm_file_info_get_disp_name(fi), fm_file_info_get_target(fi), size_str); } else if (is_link) { msg = g_strdup_printf("\"%s\" link to \"%s\"", fm_file_info_get_disp_name(fi), fm_file_info_get_target(fi)); } else if (size_str) { msg = g_strdup_printf("\"%s\" (%s) %s", fm_file_info_get_disp_name(fi), size_str, fm_file_info_get_desc(fi)); } else { msg = g_strdup_printf("\"%s\" %s", fm_file_info_get_disp_name(fi), fm_file_info_get_desc(fi)); } } page->status_text[FM_STATUS_TEXT_SELECTED_FILES] = msg; g_signal_emit(page, signals[STATUS], 0, (guint)FM_STATUS_TEXT_SELECTED_FILES, msg); }
void FilePropsDialog::initGeneralPage() { // update UI if(singleType) { // all files are of the same mime-type FmIcon* icon = NULL; // FIXME: handle custom icons for some files // FIXME: display special property pages for special files or // some specified mime-types. if(singleFile) { // only one file is selected. icon = fm_file_info_get_icon(fileInfo); } if(mimeType) { if(!icon) // get an icon from mime type if needed icon = fm_mime_type_get_icon(mimeType); ui->fileType->setText(QString::fromUtf8(fm_mime_type_get_desc(mimeType))); ui->mimeType->setText(QString::fromUtf8(fm_mime_type_get_type(mimeType))); } if(icon) { ui->iconButton->setIcon(IconTheme::icon(icon)); } if(singleFile && fm_file_info_is_symlink(fileInfo)) { ui->target->setText(QString::fromUtf8(fm_file_info_get_target(fileInfo))); } else { ui->target->hide(); ui->targetLabel->hide(); } } // end if(singleType) else { // not singleType, multiple files are selected at the same time ui->fileType->setText(tr("Files of different types")); ui->target->hide(); ui->targetLabel->hide(); } // FIXME: check if all files has the same parent dir, mtime, or atime if(singleFile) { // only one file is selected FmPath* parent_path = fm_path_get_parent(fm_file_info_get_path(fileInfo)); char* parent_str = parent_path ? fm_path_display_name(parent_path, true) : NULL; ui->fileName->setText(QString::fromUtf8(fm_file_info_get_disp_name(fileInfo))); if(parent_str) { ui->location->setText(QString::fromUtf8(parent_str)); g_free(parent_str); } else ui->location->clear(); ui->lastModified->setText(QString::fromUtf8(fm_file_info_get_disp_mtime(fileInfo))); // FIXME: need to encapsulate this in an libfm API. time_t atime; struct tm tm; atime = fm_file_info_get_atime(fileInfo); localtime_r(&atime, &tm); char buf[128]; strftime(buf, sizeof(buf), "%x %R", &tm); ui->lastAccessed->setText(QString::fromUtf8(buf)); } else { ui->fileName->setText(tr("Multiple Files")); ui->fileName->setEnabled(false); } initApplications(); // init applications combo box // calculate total file sizes fileSizeTimer = new QTimer(this); connect(fileSizeTimer, &QTimer::timeout, this, &FilePropsDialog::onFileSizeTimerTimeout); fileSizeTimer->start(600); g_signal_connect(deepCountJob, "finished", G_CALLBACK(onDeepCountJobFinished), this); gboolean ret = fm_job_run_async(FM_JOB(deepCountJob)); }
/** * fm_launch_files * @ctx: (allow-none): a launch context * @file_infos: (element-type FmFileInfo): files to launch * @launcher: #FmFileLauncher with callbacks * @user_data: data supplied for callbacks * * Launches files using callbacks in @launcher. * * Returns: %TRUE in case of success. * * Since: 0.1.0 */ gboolean fm_launch_files(GAppLaunchContext* ctx, GList* file_infos, FmFileLauncher* launcher, gpointer user_data) { GList* l; GHashTable* hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL); GList *folders = NULL; FmFileInfo* fi; GList *targets = NULL; GError* err = NULL; GAppInfo* app; const char* type; for(l = file_infos; l; l=l->next) { GList* fis; char *filename, *scheme; const char *target = NULL; fi = (FmFileInfo*)l->data; /* special handling for shortcuts */ if (!fm_file_info_is_symlink(fi)) /* symlinks also has fi->target, but we only handle shortcuts here. */ target = fm_file_info_get_target(fi); if (launcher->open_folder && fm_file_info_is_dir(fi)) { /* special handling for shortcuts */ if(target) { fi = _fetch_file_info_for_shortcut(fm_file_info_get_target(fi), ctx, launcher, user_data); if (fi == NULL) /* error was shown by job already */ continue; targets = g_list_prepend(targets, fi); } folders = g_list_prepend(folders, fi); } else if (fm_file_info_is_desktop_entry(fi)) { _launch_desktop_entry: if (!target) filename = fm_path_to_str(fm_file_info_get_path(fi)); fm_launch_desktop_entry(ctx, target ? target : filename, NULL, launcher, user_data); if (!target) g_free(filename); continue; } else { FmPath* path = fm_file_info_get_path(fi); FmMimeType* mime_type = NULL; if(fm_path_is_native(path)) { /* special handling for shortcuts */ if (target) { if (fm_file_info_get_mime_type(fi) == _fm_mime_type_get_inode_x_shortcut()) /* if we already know MIME type then use it instead */ { scheme = g_uri_parse_scheme(target); if (scheme) { /* FIXME: this is rough! */ if (strcmp(scheme, "file") != 0 && strcmp(scheme, "trash") != 0 && strcmp(scheme, "network") != 0 && strcmp(scheme, "computer") != 0 && strcmp(scheme, "menu") != 0) { /* we don't support this URI internally, try GIO */ app = g_app_info_get_default_for_uri_scheme(scheme); if (app) { fis = g_list_prepend(NULL, (char *)target); fm_app_info_launch_uris(app, fis, ctx, &err); g_list_free(fis); g_object_unref(app); } else if (launcher->error) g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED, _("No default application is set to launch URIs %s://"), scheme); if (err) { launcher->error(ctx, err, NULL, user_data); g_clear_error(&err); } g_free(scheme); continue; } g_free(scheme); } } else mime_type = fm_file_info_get_mime_type(fi); /* retrieve file info for target otherwise and handle it */ fi = _fetch_file_info_for_shortcut(target, ctx, launcher, user_data); if (fi == NULL) /* error was shown by job already */ continue; targets = g_list_prepend(targets, fi); path = fm_file_info_get_path(fi); /* special handling for desktop entries */ if (fm_file_info_is_desktop_entry(fi)) goto _launch_desktop_entry; } if(fm_file_info_is_executable_type(fi)) { /* if it's an executable file, directly execute it. */ filename = fm_path_to_str(path); /* FIXME: we need to use eaccess/euidaccess here. */ if(g_file_test(filename, G_FILE_TEST_IS_EXECUTABLE)) { if(launcher->exec_file) { FmFileLauncherExecAction act = launcher->exec_file(fi, user_data); GAppInfoCreateFlags flags = 0; switch(act) { case FM_FILE_LAUNCHER_EXEC_IN_TERMINAL: flags |= G_APP_INFO_CREATE_NEEDS_TERMINAL; /* NOTE: no break here */ case FM_FILE_LAUNCHER_EXEC: { /* filename may contain spaces. Fix #3143296 */ char* quoted = g_shell_quote(filename); app = fm_app_info_create_from_commandline(quoted, NULL, flags, NULL); g_free(quoted); if(app) { char* run_path = g_path_get_dirname(filename); char* cwd = NULL; /* bug #3589641: scripts are ran from $HOME. since GIO launcher is kinda ugly - it has no means to set running directory so we do workaround - change directory to it */ if(run_path && strcmp(run_path, ".")) { cwd = g_get_current_dir(); if(chdir(run_path) != 0) { g_free(cwd); cwd = NULL; if (launcher->error) { g_set_error(&err, G_IO_ERROR, g_io_error_from_errno(errno), _("Cannot set working directory to '%s': %s"), run_path, g_strerror(errno)); launcher->error(ctx, err, NULL, user_data); g_clear_error(&err); } } } g_free(run_path); if(!fm_app_info_launch(app, NULL, ctx, &err)) { if(launcher->error) launcher->error(ctx, err, NULL, user_data); g_error_free(err); err = NULL; } if(cwd) /* return back */ { if(chdir(cwd) != 0) g_warning("fm_launch_files(): chdir() failed"); g_free(cwd); } g_object_unref(app); continue; } break; } case FM_FILE_LAUNCHER_EXEC_OPEN: break; case FM_FILE_LAUNCHER_EXEC_CANCEL: continue; } } } g_free(filename); } } if (mime_type == NULL) mime_type = fm_file_info_get_mime_type(fi); if(mime_type && (type = fm_mime_type_get_type(mime_type))) { fis = g_hash_table_lookup(hash, type); fis = g_list_prepend(fis, fi); g_hash_table_insert(hash, (gpointer)type, fis); } else if (launcher->error) { g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED, _("Could not determine content type of file '%s' to launch it"), fm_file_info_get_disp_name(fi)); launcher->error(ctx, err, NULL, user_data); g_clear_error(&err); } } } if(g_hash_table_size(hash) > 0) { GHashTableIter it; GList* fis; g_hash_table_iter_init(&it, hash); while(g_hash_table_iter_next(&it, (void**)&type, (void**)&fis)) { GAppInfo* app = g_app_info_get_default_for_type(type, FALSE); if(!app) { if(launcher->get_app) { FmMimeType* mime_type = fm_file_info_get_mime_type((FmFileInfo*)fis->data); app = launcher->get_app(fis, mime_type, user_data, NULL); } } if(app) { for(l=fis; l; l=l->next) { char* uri; fi = (FmFileInfo*)l->data; /* special handling for shortcuts */ if (fm_file_info_is_shortcut(fi)) uri = g_strdup(fm_file_info_get_target(fi)); else uri = fm_path_to_uri(fm_file_info_get_path(fi)); l->data = uri; } fis = g_list_reverse(fis); fm_app_info_launch_uris(app, fis, ctx, &err); /* free URI strings */ g_list_foreach(fis, (GFunc)g_free, NULL); g_object_unref(app); } else if (launcher->error) g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED, _("No default application is set for MIME type %s"), type); if (err) { launcher->error(ctx, err, NULL, user_data); g_clear_error(&err); } g_list_free(fis); } } g_hash_table_destroy(hash); if(folders) { folders = g_list_reverse(folders); if(launcher->open_folder) { launcher->open_folder(ctx, folders, user_data, &err); if(err) { if(launcher->error) launcher->error(ctx, err, NULL, user_data); g_error_free(err); err = NULL; } } g_list_free(folders); } g_list_free_full(targets, (GDestroyNotify)fm_file_info_unref); return TRUE; }
static void update_ui (FmFilePropData *data) { GtkImage *img = (GtkImage*) data->icon; if ( data->single_type ) // all files are of the same mime-type { GIcon *icon = NULL; // FIXME_pcm: handle custom icons for some files /* FIXME_pcm: display special property pages for special files or * some specified mime-types. */ if ( data->single_file ) // only one file is selected. { FmFileInfo *file_info = (FmFileInfo*)fm_list_peek_head (data->files); icon = fm_file_info_get_gicon (file_info); } if (data->mime_type) { if (!icon) { FmIcon *ficon = fm_mime_type_get_icon (data->mime_type); if (ficon) icon = ficon->gicon; } gtk_label_set_text (GTK_LABEL (data->type), fm_mime_type_get_desc (data->mime_type)); } if (icon) gtk_image_set_from_gicon (img, icon, GTK_ICON_SIZE_DIALOG); if ( data->single_file && fm_file_info_is_symlink (data->file_info) ) { gtk_widget_show (data->target_label); gtk_widget_show (data->target); gtk_label_set_text (GTK_LABEL (data->target), fm_file_info_get_target (data->file_info)); // gtk_label_set_text (data->type, fm_mime_type_get_desc (data->mime_type)); } else { gtk_widget_destroy (data->target_label); gtk_widget_destroy (data->target); } } else { gtk_image_set_from_stock (img, GTK_STOCK_DND_MULTIPLE, GTK_ICON_SIZE_DIALOG); gtk_widget_set_sensitive (data->name, FALSE); gtk_label_set_text (GTK_LABEL (data->type), _("Files of different types")); gtk_widget_destroy (data->target_label); gtk_widget_destroy (data->target); gtk_widget_destroy (data->open_with_label); gtk_widget_destroy (data->open_with); data->open_with = data->open_with_label = NULL; } // FIXME_pcm: check if all files has the same parent dir, mtime, or atime if ( data->single_file ) { char buf[128]; FmPath *parent = fm_path_get_parent (fm_file_info_get_path (data->file_info)); char *parent_str = parent ? fm_path_display_name (parent, TRUE) : NULL; gtk_entry_set_text (GTK_ENTRY (data->name), fm_file_info_get_disp_name (data->file_info)); if (parent_str) { gtk_label_set_text (GTK_LABEL (data->dir), parent_str); g_free (parent_str); } else gtk_label_set_text (GTK_LABEL (data->dir), ""); gtk_label_set_text (GTK_LABEL (data->mtime), fm_file_info_get_disp_mtime (data->file_info)); // FIXME_pcm: need to encapsulate this in an libfm API. strftime ( buf, sizeof ( buf ), "%x %R", localtime ( &data->file_info->atime ) ); gtk_label_set_text (GTK_LABEL (data->atime), buf); } else { gtk_entry_set_text (GTK_ENTRY (data->name), _("Multiple Files")); gtk_widget_set_sensitive (data->name, FALSE); } update_permissions (data); on_timeout (data); }