filestreeview.cc

About: Paco (pacKAGE oRGANIZER) is a simple, yet powerful tool to aid package management when insta

			setLabelText("Uncompressing files");
			break;
		case GZIP:
			argv[0] = "gzip";
			argv[1] = "--force";
			setLabelText("Compressing files with gzip");
			break;
		case BZIP2:
			argv[0] = "bzip2";
			argv[1] = "--force";
			setLabelText("Compressing files with bzip2");
			break;
		default:
			g_assert_not_reached();
	}

	gfloat cnt = 0.0;
	int status;
	bool update = false;
	string err, cwd = Glib::get_current_dir();

	for (Pkg::iterator f = files.begin(); f != files.end(); ++f) {
		
		CHECK_PKG_WINDOW;
		progressBar.set_fraction(++cnt / files.size());
		refreshMainLoop();

		// skip symlinks and missing files
		if (!isRegular((*f)->name()))
			continue;
		else if (action == UNCOMPRESS) {
			if (isBzip2((*f)->name()))
				argv[0] = "bunzip2";
			else if (isGzip((*f)->name()))
				argv[0] = "gunzip";
			else
				continue;
		}
		else if (isBzip2((*f)->name()) || isGzip((*f)->name()))
			continue;

		argv[2] = (*f)->name();
		
		Glib::spawn_sync(cwd, argv, Glib::SPAWN_SEARCH_PATH, slot<void>(),
			NULL, &err, &status);

		if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS) {
			if (mPkg.window()) {
				errorDialog(mPkg.window(), "Error while running the " + argv[0]
					+ " process:\n\n" + err);
			}
			break;
		}
		update = true;

		switch (action) {
			case UNCOMPRESS:
				if (isBzip2((*f)->name()))
					(*f)->name().erase((*f)->name().size() - 4);
				else if (isGzip((*f)->name()))
					(*f)->name().erase((*f)->name().size() - 3);
				break;
			case GZIP:
				(*f)->name() += ".gz";
				break;
			case BZIP2:
				(*f)->name() += ".bz2";
		}

		Pkg::getSize((*f)->size(), (*f)->name());

	}

	if (update) {
		refresh();
		mPkg.update(false);
	}

	progressBar.remove_modal_grab();
	progressBar.hide();
	writeLabel();
}


void FilesTreeView::setLabelText(ustring const& text) const
{
	CHECK_PKG_WINDOW;
	mPkg.window()->filesTab().setLabelText(text);
}


void FilesTreeView::onRemove()
{
	Lock lock;

	if (!Config::logdirWritable())
		return;

	// get the selected files
	vector<File*> files;
	g_return_if_fail(getSelected(files) > 0L);

	// ask the user
	std::ostringstream msg;
	msg << "Remove " << files.size() << " file"
		<< (files.size() > 1 ? "s" : "") << " ?\n";
	if (!questionDialog(mPkg.window(), msg.str()))
		return;

	// discard missing files
	files.erase(remove_if(files.begin(), files.end(), isMissing), files.end());
	if (files.empty())
		return;

	// show the progress bar
	Gtk::ProgressBar& progressBar = mPkg.window()->filesTab().progressBar();
	progressBar.show();
	progressBar.add_modal_grab();

	// start removing
	gfloat err = 0.0, cnt = 0.0;
	bool stopMsg = false;
	ustring errmsg("Error while removing files:\n\n");

	for (Pkg::iterator f = files.begin(); f != files.end(); ++f) {
		if (!unlink((*f)->name().c_str())) {
			(*f)->missing(true);
			iterator it;
			CHECK_PKG_WINDOW;
			getIter(*f, mpModelInst, it);
			mpModelInst->erase(it);
			(*mpModelMiss->append())[mColumns.mFile] = *f;
			++cnt;
		}
		else if (++err < 16)
			errmsg += "' " + (*f)->name() + "': " + Glib::strerror(errno) + "\n";
		else if (!stopMsg) {
			errmsg += " ...";
			stopMsg = true;
		}

		CHECK_PKG_WINDOW;
		progressBar.set_fraction((cnt + err) / files.size());
		refreshMainLoop();
	}

	if (err)
		errorDialog(mPkg.window(), errmsg);
	if (cnt)
		mPkg.update();
	
	progressBar.remove_modal_grab();
	progressBar.hide();
}


bool FilesTreeView::getIter(File const* file, Glib::RefPtr<Gtk::ListStore> model,
	iterator& it) const
{
	Gtk::TreeModel::Children child = model->children();

	for (it = child.begin(); it != child.end(); ++it) {
		if (file == (*it)[mColumns.mFile])
			return true;
	}

	return false;
}


void FilesTreeView::onUnselectAll()
{
	(get_selection())->unselect_all();
	writeLabel();
}


void FilesTreeView::onSelectAll()
{
	(get_selection())->select_all();
	writeLabel();
}


void FilesTreeView::popupMenu(int button /* = 0 */, int time /* = 0 */)
{
	bool empty = (*mppModel)->children().empty();
	bool sensitive = Config::logdirWritable() && !empty && !Lock::locked();

	mpActionStrip->set_sensitive(sensitive);
	mpActionCompress->set_sensitive(sensitive);
	mpActionUncompress->set_sensitive(sensitive);
	mpActionRemove->set_sensitive(sensitive);
	mpActionSelectAll->set_sensitive(!empty);
	mpActionUnselectAll->set_sensitive(!empty);

	mpMenu->popup(button, time);
}


// [virtual]
bool FilesTreeView::on_button_press_event(GdkEventButton* e)
{
	bool ret = true;

	// Handle only clicks on the right mouse button
	if (e->type == GDK_BUTTON_PRESS && e->button == 3) {
		if (!(get_selection())->count_selected_rows())
			Gtk::TreeView::on_button_press_event(e);
		popupMenu(e->button, e->time);
	}
	else
		ret = Gtk::TreeView::on_button_press_event(e);

	writeLabel();
	return ret;
}


// [virtual]
bool FilesTreeView::on_key_press_event(GdkEventKey* e)
{
	bool done = false;

	switch (e->keyval) {
		case GDK_Delete:
			onRemove();
			done = true;
			break;
		case GDK_Menu:
			popupMenu();
			done = true;
	}
	
	bool ret = done ? done : Gtk::TreeView::on_key_press_event(e);
	writeLabel();

	return ret;
}


bool FilesTreeView::rowChanged(Gtk::TreeModel::Path const& path, iterator const& iter)
{
	(*mppModel)->row_changed(path, iter);
	return false;
}


void FilesTreeView::statusCellFunc(Gtk::CellRenderer* pCell, iterator const& it)
{
	File* file = (*it)[mColumns.mFile];
	g_assert(file != NULL);

	Gtk::CellRendererPixbuf* pCellPixbuf =
		dynamic_cast<Gtk::CellRendererPixbuf*>(pCell);
	g_assert(pCellPixbuf != NULL);

	pCellPixbuf->property_pixbuf() = render_icon(
		file->missing() ? Gtk::Stock::NO : Gtk::Stock::YES,
		Gtk::ICON_SIZE_SMALL_TOOLBAR);
}


void FilesTreeView::nameCellFunc(Gtk::CellRenderer* pCell, iterator const& it)
{
	File* file = (*it)[mColumns.mFile];
	g_assert(file != NULL);

	Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCell);
	g_assert(pCellText != NULL);

	pCellText->property_text() = file->name();
}


void FilesTreeView::sizeCellFunc(Gtk::CellRenderer* pCell, iterator const& it)
{
	File* file = (*it)[mColumns.mFile];
	g_assert(file != NULL);

	ustring txt(Paco::sizeStr(Config::sizeUnit(), file->size()));
	switch (Config::sizeUnit()) {
		case Paco::KILOBYTE: txt += 'k'; break;
		case Paco::MEGABYTE: txt += 'M';
	}

	Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCell);
	g_assert(pCellText != NULL);

	pCellText->property_text() = txt;
}


int FilesTreeView::statusSortFunc(iterator const& a, iterator const&)
{
	File* fa = (*a)[mColumns.mFile];
	g_assert(fa != NULL);
	return fa->missing() ? -1 : 1;
}


int FilesTreeView::sizeSortFunc(iterator const& a, iterator const& b)
{
	File* fa = (*a)[mColumns.mFile];
	File* fb = (*b)[mColumns.mFile];
	g_assert(fa != NULL && fb != NULL);
	return fa->size() < fb->size() ? -1 : 1;
}


int FilesTreeView::nameSortFunc(iterator const& a, iterator const& b)
{
	File* fa = (*a)[mColumns.mFile];
	File* fb = (*b)[mColumns.mFile];
	g_assert(fa != NULL && fb != NULL);
	return fa->name() < fb->name() ? -1 : 1;
}


//-----------------------------------//
// class FilesTreeView::ModelColumns //
//-----------------------------------//


FilesTreeView::ModelColumns::ModelColumns()
{
	add(mFile);
	add(mStatus);
	add(mName);
	add(mSize);
}


//-------------------//
// static free funcs //
//-------------------//


static bool isMissing(File* file)
{
	return !Glib::file_test(file->name(), Glib::FILE_TEST_EXISTS
		| Glib::FILE_TEST_IS_SYMLINK);
}


static bool isGzip(string const& path)
{
	return Glib::str_has_suffix(path, ".gz") || Glib::str_has_suffix(path, ".tgz");
}


static bool isBzip2(string const& path)
{
	return Glib::str_has_suffix(path, ".bz2");
}


static bool isRegular(string const& path)
{
	return Glib::file_test(path, Glib::FILE_TEST_IS_REGULAR) &&
		!Glib::file_test(path, Glib::FILE_TEST_IS_SYMLINK);
}