static void _idle_image_load_pixbuf(Preview * preview, gint width, gint height)
{
BrowserPluginHelper * helper = preview->helper;
GdkPixbuf * pixbuf;
GError * error = NULL;
if(width <= 0)
width = 1;
if(height <= 0)
height = 1;
#if GTK_CHECK_VERSION(2, 6, 0)
if((pixbuf = gdk_pixbuf_new_from_file_at_scale(preview->path, width,
height, TRUE, &error)) == NULL)
#else
if((pixbuf = gdk_pixbuf_new_from_file_at_size(preview->path, width,
height, &error)) == NULL)
#endif
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
return;
}
if(error != NULL)
{
helper->error(NULL, error->message, 1);
g_error_free(error);
}
gtk_image_set_from_pixbuf(GTK_IMAGE(preview->view_image_image), pixbuf);
g_object_unref(pixbuf);
}
static int _refresh_name(Preview * preview, char const * path)
{
BrowserPluginHelper * helper = preview->helper;
gchar * p;
free(preview->path);
if((preview->path = strdup(path)) == NULL)
return -helper->error(helper->browser, strerror(errno), 1);
p = g_filename_display_basename(path);
gtk_label_set_text(GTK_LABEL(preview->name), p);
g_free(p);
return 0;
}
/* preview_on_idle_text */
static gboolean _preview_on_idle_text(gpointer data)
{
Preview * preview = data;
BrowserPluginHelper * helper = preview->helper;
GtkTextBuffer * tbuf;
GtkTextIter iter;
int fd;
char buf[256];
ssize_t s;
String const * p = NULL;
preview->source = 0;
gtk_widget_show(GTK_WIDGET(preview->copy));
gtk_widget_show(GTK_WIDGET(preview->select_all));
gtk_widget_show(preview->toolbar);
tbuf = preview->view_text_tbuf;
gtk_text_buffer_set_text(tbuf, "", 0);
gtk_text_buffer_get_end_iter(tbuf, &iter);
if((fd = open(preview->path, O_RDONLY)) < 0)
{
helper->error(helper->browser, strerror(errno), 1);
return FALSE;
}
/* FIXME use a GIOChannel instead */
while((s = read(fd, buf, sizeof(buf))) > 0)
{
if(p == NULL)
{
if((p = helper->config_get(helper->browser, "preview",
"ellipsize")) == NULL
|| strtol(p, NULL, 0) != 0)
{
if(s == sizeof(buf))
{
buf[sizeof(buf) - 3] = '.';
buf[sizeof(buf) - 2] = '.';
buf[sizeof(buf) - 1] = '.';
}
gtk_text_buffer_set_text(tbuf, buf, s);
break;
}
}
gtk_text_buffer_insert(preview->view_text_tbuf, &iter, buf, s);
}
close(fd);
gtk_widget_show(preview->view_text);
return FALSE;
}
static void _list_add(Trash * trash, Config * config, char const * path,
char const * filename, const time_t sixmonths)
{
const char ext[] = DATA_EXTENSION;
const char section[] = DATA_SECTION;
BrowserPluginHelper * helper = trash->helper;
size_t len;
GtkTreeIter iter;
GdkPixbuf * pixbuf;
char * p;
char const * q;
struct tm tm;
time_t t = -1;
char const * u;
char buf[16];
if((len = strlen(filename)) <= sizeof(ext))
return;
if(strncmp(&filename[len - sizeof(ext) + 1], ext, sizeof(ext)) != 0)
return;
config_reset(config);
p = g_strdup_printf("%s/%s", path, filename);
if(config_load(config, p) != 0
|| (q = config_get(config, section, DATA_PATH)) == NULL)
{
g_free(p);
return;
}
pixbuf = helper->get_icon(helper->browser, q, NULL, NULL, NULL, 24);
if((u = config_get(config, section, DATA_DELETIONDATE)) != NULL
&& strptime(u, "%Y-%m-%dT%H:%M:%S", &tm) != NULL)
{
t = mktime(&tm);
len = strftime(buf, sizeof(buf), (t >= sixmonths)
? "%b %e %H:%M" : "%b %e %Y", &tm);
buf[len] = '\0';
u = buf;
}
else
u = "";
_list_get_iter(trash, &iter, p);
gtk_list_store_set(trash->store, &iter, TC_PIXBUF, pixbuf,
TC_FILENAME, filename, TC_PATH, p,
TC_PATH_ORIGINAL, q, TC_DELETED, t,
TC_DELETED_DISPLAY, u, TC_UPDATED, TRUE, -1);
g_free(p);
}
static void _refresh_type(Properties * properties, struct stat * lst)
{
BrowserPluginHelper * helper = properties->helper;
char const * type = NULL;
GdkPixbuf * pixbuf;
const int iconsize = 48;
type = helper->get_type(helper->browser, properties->filename,
lst->st_mode);
pixbuf = helper->get_icon(helper->browser, properties->filename, type,
lst, NULL, iconsize);
gtk_image_set_from_pixbuf(GTK_IMAGE(properties->image), pixbuf);
g_object_unref(pixbuf);
if(type == NULL)
type = _("Unknown type");
gtk_label_set_text(GTK_LABEL(properties->type), type);
}
/* preview_get_image_size */
static void _preview_get_image_size(Preview * preview, gint * width,
gint * height)
{
BrowserPluginHelper * helper = preview->helper;
GdkPixbuf * pixbuf;
GError * error = NULL;
/* check if we have cached the values */
if(preview->view_image_width > 0
&& preview->view_image_height > 0)
{
*width = preview->view_image_width;
*height = preview->view_image_height;
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() %dx%d (cached)\n", __func__,
*width, *height);
#endif
return;
}
*width = PREVIEW_IMAGE_SIZE_DEFAULT;
*height = PREVIEW_IMAGE_SIZE_DEFAULT;
if(preview->path != NULL
&& (pixbuf = gdk_pixbuf_new_from_file(preview->path,
&error)) != NULL)
{
*width = gdk_pixbuf_get_width(pixbuf);
*height = gdk_pixbuf_get_height(pixbuf);
g_object_unref(pixbuf);
/* cache the values */
preview->view_image_width = *width;
preview->view_image_height = *height;
}
if(error != NULL)
{
helper->error(NULL, error->message, 1);
g_error_free(error);
}
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() %dx%d\n", __func__, *width, *height);
#endif
}
/* cvs_task_on_io_can_read */
static gboolean _cvs_task_on_io_can_read(GIOChannel * channel,
GIOCondition condition, gpointer data)
{
CVSTask * task = data;
CVS * cvs = task->cvs;
BrowserPluginHelper * helper = cvs->helper;
char buf[256];
gsize cnt = 0;
GError * error = NULL;
GIOStatus status;
GtkTextBuffer * tbuf;
GtkTextIter iter;
if(condition != G_IO_IN)
return FALSE;
if(channel != task->o_channel && channel != task->e_channel)
return FALSE;
status = g_io_channel_read_chars(channel, buf, sizeof(buf), &cnt,
&error);
if(cnt > 0)
{
tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(task->view));
gtk_text_buffer_get_end_iter(tbuf, &iter);
gtk_text_buffer_insert(tbuf, &iter, buf, cnt);
}
switch(status)
{
case G_IO_STATUS_NORMAL:
break;
case G_IO_STATUS_ERROR:
helper->error(helper->browser, error->message, 1);
g_error_free(error);
case G_IO_STATUS_EOF:
default: /* should not happen... */
_cvs_task_close_channel(task, channel);
return FALSE;
}
return TRUE;
}
static void _idle_image_load_animation(Preview * preview)
{
BrowserPluginHelper * helper = preview->helper;
GdkPixbufAnimation * pixbuf;
GError * error = NULL;
if((pixbuf = gdk_pixbuf_animation_new_from_file(preview->path, &error))
== NULL)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
return;
}
if(error != NULL)
{
helper->error(NULL, error->message, 1);
g_error_free(error);
}
gtk_image_set_from_animation(GTK_IMAGE(preview->view_image_image),
pixbuf);
g_object_unref(pixbuf);
}
/* selection_refresh */
static void _selection_refresh(Selection * selection, GList * selected)
{
BrowserPluginHelper * helper = selection->helper;
GList * l;
gchar * basename;
GtkTreeIter iter;
GdkPixbuf * pixbuf;
struct stat lst;
struct stat st;
struct stat * plst;
struct stat * pst;
size_t cnt;
size_t size;
char buf[64];
gtk_list_store_clear(selection->store);
for(l = selected, cnt = 0, size = 0; l != NULL; l = l->next, cnt++)
{
plst = (lstat(l->data, &lst) == 0) ? &lst : NULL;
pst = (stat(l->data, &st) == 0) ? &st : NULL;
pixbuf = helper->get_icon(helper->browser, l->data, NULL, plst,
pst, 16);
basename = g_path_get_basename(l->data);
gtk_list_store_append(selection->store, &iter);
gtk_list_store_set(selection->store, &iter, SC_ICON, pixbuf,
SC_FILENAME, l->data,
SC_FILENAME_DISPLAY, basename,
SC_SIZE, lst.st_size,
SC_SIZE_DISPLAY, _common_size(lst.st_size),
SC_ELLIPSIZE, PANGO_ELLIPSIZE_END, -1);
g_free(basename);
if(plst != NULL)
size += lst.st_size;
}
snprintf(buf, sizeof(buf), "%lu selected (%s)", cnt,
_common_size(size));
gtk_label_set_text(GTK_LABEL(selection->status), buf);
}
/* cvs_add_task */
static int _cvs_add_task(CVS * cvs, char const * title,
char const * directory, char * argv[])
{
BrowserPluginHelper * helper = cvs->helper;
CVSTask ** p;
CVSTask * task;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD;
gboolean res;
GError * error = NULL;
PangoFontDescription * font;
char buf[256];
GtkWidget * vbox;
GtkWidget * widget;
if((p = realloc(cvs->tasks, sizeof(*p) * (cvs->tasks_cnt + 1))) == NULL)
return -helper->error(helper->browser, strerror(errno), 1);
cvs->tasks = p;
if((task = object_new(sizeof(*task))) == NULL)
return -helper->error(helper->browser, error_get(), 1);
task->cvs = cvs;
#ifdef DEBUG
argv[0] = "echo";
#endif
res = g_spawn_async_with_pipes(directory, argv, NULL, flags, NULL, NULL,
&task->pid, NULL, &task->o_fd, &task->e_fd, &error);
if(res != TRUE)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
object_delete(task);
return -1;
}
cvs->tasks[cvs->tasks_cnt++] = task;
/* widgets */
font = pango_font_description_new();
pango_font_description_set_family(font, "monospace");
task->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(task->window), 600, 400);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(task->window), plugin.icon);
#endif
snprintf(buf, sizeof(buf), "%s - %s (%s)", _("CVS"), title, directory);
gtk_window_set_title(GTK_WINDOW(task->window), buf);
g_signal_connect_swapped(task->window, "delete-event", G_CALLBACK(
_cvs_task_on_closex), task);
vbox = gtk_vbox_new(FALSE, 0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
task->view = gtk_text_view_new();
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(task->view), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(task->view), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(task->view),
GTK_WRAP_WORD_CHAR);
gtk_widget_modify_font(task->view, font);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(widget),
task->view);
gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 0);
task->statusbar = gtk_statusbar_new();
task->statusbar_id = 0;
gtk_box_pack_start(GTK_BOX(vbox), task->statusbar, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(task->window), vbox);
gtk_widget_show_all(task->window);
pango_font_description_free(font);
/* events */
task->source = g_child_watch_add(task->pid, _cvs_task_on_child_watch,
task);
task->o_channel = g_io_channel_unix_new(task->o_fd);
if((g_io_channel_set_encoding(task->o_channel, NULL, &error))
!= G_IO_STATUS_NORMAL)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
}
task->o_source = g_io_add_watch(task->o_channel, G_IO_IN,
_cvs_task_on_io_can_read, task);
task->e_channel = g_io_channel_unix_new(task->e_fd);
if((g_io_channel_set_encoding(task->e_channel, NULL, &error))
!= G_IO_STATUS_NORMAL)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
}
task->e_source = g_io_add_watch(task->e_channel, G_IO_IN,
_cvs_task_on_io_can_read, task);
_cvs_task_set_status(task, _("Running command..."));
return 0;
}
static void _refresh_dir(CVS * cvs)
{
BrowserPluginHelper * helper = cvs->helper;
char const dir[] = "CVS";
size_t len = strlen(cvs->filename);
char * p = NULL;
struct stat st;
gchar * q;
char const * filename = cvs->filename;
/* reset the interface */
gtk_label_set_text(GTK_LABEL(cvs->d_root), NULL);
gtk_label_set_text(GTK_LABEL(cvs->d_repository), NULL);
gtk_label_set_text(GTK_LABEL(cvs->d_tag), NULL);
/* consider "CVS" folders as managed */
if((len = strlen(filename)) >= 4
&& strcmp(&filename[len - 4], "/CVS") == 0)
{
if((p = strdup(filename)) != NULL)
{
p[len - 4] = '\0';
filename = p;
}
}
/* check if it is a CVS repository */
else
{
len = strlen(filename) + sizeof(dir) + 1;
if((p = malloc(len)) == NULL)
{
helper->error(helper->browser, strerror(errno), 1);
return;
}
snprintf(p, len, "%s/%s", filename, dir);
if(lstat(p, &st) != 0)
{
/* check if the parent folder is managed */
if(_cvs_is_managed(filename, NULL) == FALSE)
_refresh_status(cvs, _("Not a CVS repository"));
else
{
_refresh_status(cvs, _("Not managed by CVS"));
gtk_widget_show(cvs->add);
}
free(p);
return;
}
}
/* this folder is managed */
gtk_widget_show(cvs->directory);
/* obtain the CVS root */
if((q = _cvs_get_root(filename)) != NULL)
{
gtk_label_set_text(GTK_LABEL(cvs->d_root), q);
free(q);
}
/* obtain the CVS repository */
if((q = _cvs_get_repository(filename)) != NULL)
{
gtk_label_set_text(GTK_LABEL(cvs->d_repository), q);
free(q);
}
/* obtain the default CVS tag (if set) */
if((q = _cvs_get_tag(filename)) != NULL)
{
if(q[0] == 'T' && q[1] != '\0')
gtk_label_set_text(GTK_LABEL(cvs->d_tag), &q[1]);
g_free(q);
}
free(p);
}
