hierbox.c

一个很有名的浏览器

	struct listbox_context *context = data_;

	if (item->marked) {
		struct session *ses = context->dlg_data->dlg->udata;
		struct listbox_data *box = context->box;
		struct uri *uri;

		if (item->type == BI_FOLDER) {
			recursively_goto_listbox(ses, item, box);
			return 0;
		}

		uri = box->ops->get_uri(item);
		if (!uri) return 0;

		open_uri_in_new_tab(ses, uri, 1, 0);
		done_uri(uri);
	}

	return 0;
}

t_handler_event_status
push_hierbox_goto_button(struct dialog_data *dlg_data,
			 struct widget_data *button)
{
	struct listbox_data *box = get_dlg_listbox_data(dlg_data);
	struct session *ses = dlg_data->dlg->udata;
	struct terminal *term = dlg_data->win->term;
	struct listbox_context *context;

	/* Do nothing with a folder */
	if (!box->sel) return EVENT_PROCESSED;

	context = init_listbox_context(box, term, box->sel, scan_for_marks);
	if (!context) return EVENT_PROCESSED;

	if (!context->item) {
		context->dlg_data = dlg_data;
		traverse_listbox_items_list(context->box->items->next,
					    context->box, 0, 0,
					    goto_marked, context);

	} else if (box->sel->type == BI_FOLDER) {
		recursively_goto_listbox(ses, box->sel, box);

	} else {
		struct uri *uri = box->ops->get_uri(box->sel);

		if (uri) {
			goto_uri(ses, uri);
			done_uri(uri);
		}
	}

	mem_free(context);

	/* Close the dialog */
	delete_window(dlg_data->win);
	return EVENT_PROCESSED;
}


/* Delete action */

enum delete_error {
	DELETE_IMPOSSIBLE = 0,
	DELETE_LOCKED,
	DELETE_ERRORS,
};

unsigned char *delete_messages[2][DELETE_ERRORS] = {
	{
		N_("Sorry, but the item \"%s\" cannot be deleted."),
		N_("Sorry, but the item \"%s\" is being used by something else."),
	},
	{
		N_("Sorry, but the folder \"%s\" cannot be deleted."),
		N_("Sorry, but the folder \"%s\" is being used by something else."),
	},
};

static void
print_delete_error(struct listbox_item *item, struct terminal *term,
		   struct listbox_ops *ops, enum delete_error err)
{
	struct string msg;
	unsigned char *errmsg;
	unsigned char *text;

	switch (err) {
	case DELETE_IMPOSSIBLE:
		if (item->type == BI_FOLDER) {
			if (ops->messages && ops->messages->cant_delete_folder)
				errmsg = ops->messages->cant_delete_folder;
			else
				errmsg = delete_messages[1][DELETE_IMPOSSIBLE];
		} else {
			if (ops->messages && ops->messages->cant_delete_item)
				errmsg = ops->messages->cant_delete_item;
			else
				errmsg = delete_messages[0][DELETE_IMPOSSIBLE];
		}
		break;

	case DELETE_LOCKED:
		if (item->type == BI_FOLDER) {
			if (ops->messages && ops->messages->cant_delete_used_folder)
				errmsg = ops->messages->cant_delete_used_folder;
			else
				errmsg = delete_messages[1][DELETE_LOCKED];
		} else {
			if (ops->messages && ops->messages->cant_delete_used_item)
				errmsg = ops->messages->cant_delete_used_item;
			else
				errmsg = delete_messages[0][DELETE_LOCKED];
		}
		break;

	default:
		INTERNAL("Bad delete error code (%d)!", err);
		return;
	}

	text = ops->get_text(item, term);

	if (!text || !init_string(&msg)) {
		mem_free_if(text);
		return;
	}

	add_format_to_string(&msg, _(errmsg, term), text);
	mem_free(text);

	if (item->type == BI_LEAF) {
		unsigned char *info = ops->get_info(item, term);

		if (info) {
			add_format_to_string(&msg, "\n\n%s", info);
			mem_free(info);
		}
	}

	info_box(term, MSGBOX_FREE_TEXT, N_("Delete error"), ALIGN_LEFT,
		 msg.source);
}

static void
do_delete_item(struct listbox_item *item, struct listbox_context *info,
	       int last)
{
	struct listbox_ops *ops = info->box->ops;

	assert(item);

	if (!ops->can_delete(item)) {
		print_delete_error(item, info->term, ops, DELETE_IMPOSSIBLE);
		return;
	}

	if (ops->is_used(item)) {
		print_delete_error(item, info->term, ops, DELETE_LOCKED);
		return;
	}

	ops->delete(item, last);
}

static int
delete_marked(struct listbox_item *item, void *data_, int *offset)
{
	struct listbox_context *context = data_;

	if (item->marked && !context->box->ops->is_used(item)) {
		/* Save the first marked so it can be deleted last */
		if (!context->item) {
			context->item = item;
		} else {
			do_delete_item(item, context, 0);
		}

		return 1;
	}

	return 0;
}

static void
push_ok_delete_button(void *context_)
{
	struct listbox_context *context = context_;
	struct listbox_item *root;
	int last = 0;

	if (context->item) {
		context->box->ops->unlock(context->item);
	} else {
		traverse_listbox_items_list(context->box->items->next,
					    context->box, 0, 0,
					    delete_marked, context);
		if (!context->item) return;
	}

	root = context->box->ops->get_root(context->item);
	if (root) {
		last = context->item == root->child.prev;
	}

	/* Delete the last one (traversal should save one to delete) */
	do_delete_item(context->item, context, 1);

	/* If removing the last item in a folder move focus to previous item in
	 * the folder or the root. */
	if (last)
		listbox_sel_move(context->widget_data, -1);
}

t_handler_event_status
push_hierbox_delete_button(struct dialog_data *dlg_data,
			   struct widget_data *button)
{
	struct terminal *term = dlg_data->win->term;
	struct listbox_data *box = get_dlg_listbox_data(dlg_data);
	struct listbox_context *context;
	unsigned char *text;
	enum delete_error delete;

	if (!box->sel) return EVENT_PROCESSED;

	assert(box->ops && box->ops->can_delete && box->ops->delete);

	context = init_listbox_context(box, term, box->sel, scan_for_marks);
	if (!context) return EVENT_PROCESSED;

	context->widget_data = dlg_data->widgets_data;

	if (!context->item) {
		unsigned char *title = N_("Delete marked items");
		unsigned char *message = N_("Delete marked items?");

		if (box->ops->messages) {
			if (box->ops->messages->delete_marked_items)
				message = box->ops->messages->delete_marked_items;
			if (box->ops->messages->delete_marked_items_title)
				title = box->ops->messages->delete_marked_items_title;
		}

		msg_box(term, getml(context, NULL), 0,
			title, ALIGN_CENTER,
			message,
			context, 2,
			N_("~Yes"), push_ok_delete_button, B_ENTER,
			N_("~No"), done_listbox_context, B_ESC);
		return EVENT_PROCESSED;
	}

	delete = box->ops->can_delete(context->item)
		 ? DELETE_LOCKED : DELETE_IMPOSSIBLE;

	if (delete == DELETE_IMPOSSIBLE || box->ops->is_used(context->item)) {
		print_delete_error(context->item, term, box->ops, delete);
		mem_free(context);
		return EVENT_PROCESSED;
	}

	text = box->ops->get_text(context->item, term);
	if (!text) {
		mem_free(context);
		return EVENT_PROCESSED;
	}

	if (context->item->type == BI_FOLDER) {
		unsigned char *title = N_("Delete folder");
		unsigned char *message = N_("Delete the folder \"%s\" and its content?");

		if (box->ops->messages) {
			if (box->ops->messages->delete_folder)
				message = box->ops->messages->delete_folder;
			if (box->ops->messages->delete_folder_title)
				title = box->ops->messages->delete_folder_title;
		}

		box->ops->lock(context->item);
		msg_box(term, getml(context, NULL), MSGBOX_FREE_TEXT,
			title, ALIGN_CENTER,
			msg_text(term, message, text),
			context, 2,
			N_("~Yes"), push_ok_delete_button, B_ENTER,
			N_("~No"), done_listbox_context, B_ESC);
	} else {
		unsigned char *title = N_("Delete item");
		unsigned char *message = N_("Delete \"%s\"?\n\n%s");
		unsigned char *msg;

		if (box->ops->messages) {
			if (box->ops->messages->delete_item)
				message = box->ops->messages->delete_item;
			if (box->ops->messages->delete_item_title)
				title = box->ops->messages->delete_item_title;
		}

		msg = box->ops->get_info(context->item, term);
		box->ops->lock(context->item);

		msg_box(term, getml(context, NULL), MSGBOX_FREE_TEXT,
			title, ALIGN_LEFT,
			msg_text(term, message, text, empty_string_or_(msg)),
			context, 2,
			N_("~Yes"), push_ok_delete_button, B_ENTER,
			N_("~No"), done_listbox_context, B_ESC);
		mem_free_if(msg);
	}
	mem_free(text);

	return EVENT_PROCESSED;
}


/* Clear action */

static int
delete_unused(struct listbox_item *item, void *data_, int *offset)
{
	struct listbox_context *context = data_;

	if (context->box->ops->is_used(item)) return 0;

	do_delete_item(item, context, 0);
	return 1;
}

static void
do_clear_browser(void *context_)
{
	struct listbox_context *context = context_;

	traverse_listbox_items_list(context->box->items->next,
				    context->box, 0, 0,
				    delete_unused, context);
}

t_handler_event_status
push_hierbox_clear_button(struct dialog_data *dlg_data,
			  struct widget_data *button)
{
	struct listbox_data *box = get_dlg_listbox_data(dlg_data);
	struct terminal *term = dlg_data->win->term;
	struct listbox_context *context;
	unsigned char *title = N_("Clear all items");
	unsigned char *message = N_("Do you really want to remove all items?");

	if (!box->sel) return EVENT_PROCESSED;

	assert(box->ops);

	context = init_listbox_context(box, term, NULL, scan_for_used);
	if (!context) return EVENT_PROCESSED;

	if (context->item) {
		/* FIXME: If the clear button should be used for browsers where
		 * not all items can be deleted scan_for_used() should also can
		 * for undeletable and we should be able to pass either delete
		 * error types. */
		print_delete_error(context->item, term, box->ops, DELETE_LOCKED);
		mem_free(context);
		return EVENT_PROCESSED;
	}

	if (box->ops->messages) {
		if (box->ops->messages->clear_all_items)
			message = box->ops->messages->clear_all_items;
		if (box->ops->messages->clear_all_items_title)
			title = box->ops->messages->clear_all_items_title;
	}

	msg_box(term, getml(context, NULL), 0,
		title, ALIGN_CENTER,
		message,
		context, 2,
		N_("~Yes"), do_clear_browser, B_ENTER,
		N_("~No"), NULL, B_ESC);

	return EVENT_PROCESSED;
}


/* Search action */

static int
scan_for_matches(struct listbox_item *item, void *info_, int *offset)
{
	struct listbox_context *context = info_;
	unsigned char *text = (unsigned char *) context->widget_data;

	if (!*text) {
		item->visible = 1;
		return 0;
	}

	switch (context->box->ops->match(item, context->term, text)) {
	case LISTBOX_MATCH_OK:
		/* Mark that we have a match by setting the item to non-NULL */
		context->item = item;
		item->visible = 1;
		break;

	case LISTBOX_MATCH_NO:
		item->visible = 0;
		break;

	case LISTBOX_MATCH_IMPOSSIBLE:
		break;
	}

	return 0;
}

static int
mark_visible(struct listbox_item *item, void *xxx, int *offset)
{
	item->visible = 1;
	return 0;
}


static void
search_hierbox_browser(void *data, unsigned char *text)
{
	struct dialog_data *dlg_data = data;
	struct listbox_data *box = get_dlg_listbox_data(dlg_data);
	struct terminal *term = dlg_data->win->term;
	struct listbox_context *context;

	context = init_listbox_context(box, term, NULL, NULL);
	if (!context) return;

	/* Eeew :/ */
	context->widget_data = (void *) text;

	traverse_listbox_items_list(box->items->next, box, 0, 0,
				    scan_for_matches, context);

	if (!context->item && *text) {
		switch (get_opt_int("document.browse.search.show_not_found")) {
		case 2:
			info_box(term, MSGBOX_FREE_TEXT,
				 N_("Search"), ALIGN_CENTER,
				 msg_text(term,
					  N_("Search string '%s' not found"),
					  text));
			break;

		case 1:
			beep_terminal(term);

		default:
			break;
		}

		traverse_listbox_items_list(box->items->next, box, 0, 0,
					    mark_visible, NULL);
	}

	mem_free(context);
}

t_handler_event_status
push_hierbox_search_button(struct dialog_data *dlg_data,
			   struct widget_data *button)
{
	struct terminal *term = dlg_data->win->term;
	struct listbox_data *box = get_dlg_listbox_data(dlg_data);

	if (!box->sel) return EVENT_PROCESSED;

	assert(box->ops->match);

	input_dialog(term, NULL, N_("Search"), N_("Name"),
		     dlg_data, NULL,
		     MAX_STR_LEN, "", 0, 0, NULL,
		     search_hierbox_browser, NULL);

	return EVENT_PROCESSED;
}