HGKeeper

* Screen Capture - a plugin that allows taking screenshots and sending them

* to your buddies as inline images.

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include "internal.h"

#include <gdk/gdkkeysyms.h>

#include "debug.h"

#include "version.h"

#include "gtkconv.h"

#include "gtkplugin.h"

#include "gtkutils.h"

#include "gtkwebviewtoolbar.h"

#include "pidginicon.h"

#define SCRNCAP_SHOOTING_TIMEOUT 500

#define SCRNCAP_DEFAULT_COLOR "#FFFF00000000"

enum

{

SCRNCAP_RESPONSE_COLOR

};

static gboolean is_shooting = FALSE;

static guint shooting_timeout = 0;

static GtkWidget *current_window = NULL;

static gint crop_origin_x, crop_origin_y;

static gboolean crop_active;

static gint crop_x, crop_y, crop_w, crop_h;

static gint draw_origin_x, draw_origin_y;

static gboolean draw_active;

static GdkRGBA brush_color = {1, 0, 0, 1};

static gint line_width = 2;

/******************************************************************************

* libpidgin helper functions

******************************************************************************/

static inline void

scrncap_conv_set_data(PidginConversation *gtkconv, const gchar *key,

gpointer value)

{

g_return_if_fail(gtkconv != NULL);

g_object_set_data(G_OBJECT(gtkconv->tab_cont), key, value);

}

static inline gpointer

scrncap_conv_get_data(PidginConversation *gtkconv, const gchar *key)

{

g_return_val_if_fail(gtkconv != NULL, NULL);

return g_object_get_data(G_OBJECT(gtkconv->tab_cont), key);

}

/******************************************************************************

* GdkPixbuf helper functions

******************************************************************************/

static GdkPixbuf *

scrncap_perform_screenshot(void)

{

GdkWindow *root;

gint orig_x, orig_y;

root = gdk_get_default_root_window();

gdk_window_get_origin(root, &orig_x, &orig_y);

return gdk_pixbuf_get_from_window(root, 0, 0,

gdk_window_get_width(root), gdk_window_get_height(root));

}

static void

scrncap_pixbuf_darken(GdkPixbuf *pixbuf)

{

guchar *pixels;

int i, y, width, height, row_width, n_channels, rowstride, pad;

pixels = gdk_pixbuf_get_pixels(pixbuf);

width = gdk_pixbuf_get_width(pixbuf);

height = gdk_pixbuf_get_height(pixbuf);

n_channels = gdk_pixbuf_get_n_channels(pixbuf);

rowstride = gdk_pixbuf_get_rowstride(pixbuf);

row_width = width * n_channels;

pad = rowstride - row_width;

g_return_if_fail(pad >= 0);

for (y = 0; y < height; y++) {

for (i = 0; i < row_width; i++, pixels++)

*pixels /= 2;

pixels += pad;

}

static PurpleImage *

scrncap_pixbuf_to_image(GdkPixbuf *pixbuf)

{

PurpleImage *image = NULL;

gchar *buffer;

gsize count;

GError *error = NULL;

if (!gdk_pixbuf_save_to_buffer(pixbuf, &buffer, &count, "png",

&error, NULL)) {

purple_debug_error("screencap", "Failed saving an image: %s",

error->message);

g_error_free(error);

return NULL;

}

image = purple_image_new_take_data((guint8 *)buffer, count);

if (purple_image_get_extension(image) == NULL) {

purple_debug_error("screencap", "Invalid image format");

g_object_unref(image);

return NULL;

}

return image;

}

/******************************************************************************

* Draw window

******************************************************************************/

static gboolean

scrncap_drawing_area_btnpress(GtkWidget *draw_area, GdkEventButton *event,

gpointer _unused)

{

if (draw_active)

return TRUE;

draw_origin_x = event->x;

draw_origin_y = event->y;

draw_active = TRUE;

return TRUE;

}

static gboolean

scrncap_drawing_area_btnrelease(GtkWidget *draw_area, GdkEvent *event,

gpointer _unused)

{

if (!draw_active)

return TRUE;

draw_active = FALSE;

return TRUE;

}

static gboolean

scrncap_drawing_area_motion(GtkWidget *draw_area, GdkEventButton *event,

gpointer _cr)

{

cairo_t *cr = _cr;

int x, y;

int redraw_x, redraw_y, redraw_w, redraw_h;

x = event->x;

y = event->y;

if (!draw_active) {

draw_origin_x = x;

draw_origin_y = y;

draw_active = TRUE;

return FALSE;

}

cairo_move_to(cr, draw_origin_x, draw_origin_y);

cairo_line_to(cr, x, y);

cairo_set_line_width(cr, line_width);

cairo_stroke(cr);

redraw_x = MIN(draw_origin_x, x) - line_width - 1;

redraw_y = MIN(draw_origin_y, y) - line_width - 1;

redraw_w = MAX(draw_origin_x, x) - redraw_x + line_width + 1;

redraw_h = MAX(draw_origin_y, y) - redraw_y + line_width + 1;

draw_origin_x = x;

draw_origin_y = y;

gtk_widget_queue_draw_area(draw_area,

redraw_x, redraw_y, redraw_w, redraw_h);

return FALSE;

}

static gboolean

scrncap_drawing_area_enter(GtkWidget *widget, GdkEvent *event,

GdkCursor *draw_cursor)

{

GdkWindow *gdkwindow;

gdkwindow = gtk_widget_get_window(GTK_WIDGET(widget));

gdk_window_set_cursor(gdkwindow, draw_cursor);

return FALSE;

}

static gboolean

scrncap_drawing_area_leave(GtkWidget *widget, GdkEvent *event,

GdkCursor *draw_cursor)

{

GdkWindow *gdkwindow;

gdkwindow = gtk_widget_get_window(GTK_WIDGET(widget));

gdk_window_set_cursor(gdkwindow, NULL);

return FALSE;

}

static void

scrncap_draw_window_close(GtkWidget *window, gpointer _unused)

{

if (current_window != window)

return;

is_shooting = FALSE;

current_window = NULL;

}

static gboolean

scrncap_draw_window_paint(GtkWidget *widget, cairo_t *cr, gpointer _surface)

{

cairo_surface_t *surface = _surface;

cairo_set_source_surface(cr, surface, 0, 0);

cairo_paint(cr);

return FALSE;

}

static void

scrncap_draw_window_response(GtkDialog *draw_window, gint response_id,

gpointer _webview)

{

PidginWebView *webview = PIDGIN_WEBVIEW(_webview);

GdkPixbuf *result = NULL;

PurpleImage *image;

const gchar *fname_prefix;

gchar *fname;

static guint fname_no = 0;

if (response_id == SCRNCAP_RESPONSE_COLOR)

return;

if (response_id == GTK_RESPONSE_OK) {

cairo_surface_t *surface = g_object_get_data(

G_OBJECT(draw_window), "surface");

result = gdk_pixbuf_get_from_surface(surface, 0, 0,

cairo_image_surface_get_width(surface),

cairo_image_surface_get_height(surface));

}

gtk_widget_destroy(GTK_WIDGET(draw_window));

if (result == NULL)

return;

image = scrncap_pixbuf_to_image(result);

/* translators: this is the file name prefix,

* keep it lowercase and pure ASCII.

* Please avoid "_" character, use "-" instead. */

fname_prefix = _("screenshot-");

fname = g_strdup_printf("%s%u", fname_prefix, ++fname_no);

purple_image_set_friendly_filename(image, fname);

g_free(fname);

pidgin_webview_insert_image(webview, image);

g_object_unref(image);

}

static void

scrncap_draw_color_selected(GtkColorButton *button, cairo_t *cr)

{

gchar *color_str;

gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(button), &brush_color);

gdk_cairo_set_source_rgba(cr, &brush_color);

color_str = gdk_rgba_to_string(&brush_color);

purple_prefs_set_string("/plugins/gtk/screencap/brush_color", color_str);

g_free(color_str);

}

static void

scrncap_draw_window(PidginWebView *webview, GdkPixbuf *screen)

{

GtkDialog *draw_window;

GtkWidget *drawing_area, *box;

GtkWidget *scroll_area;

GtkWidget *color_button;

int width, height;

cairo_t *cr;

cairo_surface_t *surface;

GdkDisplay *display;

GdkCursor *draw_cursor;

is_shooting = TRUE;

current_window = pidgin_create_dialog(

_("Insert screenshot"), 0, "insert-screenshot", TRUE);

draw_window = GTK_DIALOG(current_window);

gtk_widget_set_size_request(GTK_WIDGET(draw_window), 400, 300);

gtk_window_set_position(GTK_WINDOW(draw_window), GTK_WIN_POS_CENTER);

g_signal_connect(G_OBJECT(draw_window), "destroy",

G_CALLBACK(scrncap_draw_window_close), NULL);

display = gtk_widget_get_display(current_window);

draw_cursor = gdk_cursor_new_for_display(display, GDK_PENCIL);

g_object_set_data_full(G_OBJECT(draw_window), "draw-cursor",

draw_cursor, g_object_unref);

width = gdk_pixbuf_get_width(screen);

height = gdk_pixbuf_get_height(screen);

surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);

cr = cairo_create(surface);

g_signal_connect_swapped(G_OBJECT(draw_window), "destroy",

G_CALLBACK(cairo_destroy), cr);

g_object_set_data_full(G_OBJECT(draw_window), "surface",

surface, (GDestroyNotify)cairo_surface_destroy);

gdk_cairo_set_source_pixbuf(cr, screen, 0, 0);

cairo_rectangle(cr, 0, 0, width, height);

cairo_fill(cr);

g_object_unref(screen);

drawing_area = gtk_drawing_area_new();

gtk_widget_set_size_request(drawing_area, width, height);

g_signal_connect(G_OBJECT(drawing_area), "draw",

G_CALLBACK(scrncap_draw_window_paint), surface);

gtk_widget_add_events(drawing_area, GDK_BUTTON_PRESS_MASK |

GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK |

GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);

g_signal_connect(G_OBJECT(drawing_area), "button-press-event",

G_CALLBACK(scrncap_drawing_area_btnpress), NULL);

g_signal_connect(G_OBJECT(drawing_area), "button-release-event",

G_CALLBACK(scrncap_drawing_area_btnrelease), NULL);

g_signal_connect(G_OBJECT(drawing_area), "motion-notify-event",

G_CALLBACK(scrncap_drawing_area_motion), cr);

g_signal_connect(G_OBJECT(drawing_area), "enter-notify-event",

G_CALLBACK(scrncap_drawing_area_enter), draw_cursor);

g_signal_connect(G_OBJECT(drawing_area), "leave-notify-event",

G_CALLBACK(scrncap_drawing_area_leave), draw_cursor);

box = drawing_area;

g_object_set(drawing_area,

"halign", GTK_ALIGN_CENTER,

"valign", GTK_ALIGN_CENTER,

NULL);

scroll_area = pidgin_make_scrollable(box,

GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC,

GTK_SHADOW_NONE, -1, -1);

g_object_set(G_OBJECT(scroll_area), "expand", TRUE, NULL);

gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(

GTK_DIALOG(draw_window))), scroll_area);

color_button = gtk_color_button_new();

gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(color_button),

&brush_color);

g_signal_connect(G_OBJECT(color_button), "color-set",

G_CALLBACK(scrncap_draw_color_selected), cr);

scrncap_draw_color_selected(GTK_COLOR_BUTTON(color_button), cr);

gtk_dialog_add_action_widget(draw_window, color_button,

SCRNCAP_RESPONSE_COLOR);

gtk_dialog_add_button(draw_window, _("_Add"), GTK_RESPONSE_OK);

gtk_dialog_add_button(draw_window, _("_Cancel"),

GTK_RESPONSE_CANCEL);

gtk_dialog_set_default_response(draw_window, GTK_RESPONSE_OK);

g_signal_connect(G_OBJECT(draw_window), "response",

G_CALLBACK(scrncap_draw_window_response), webview);

gtk_widget_show_all(GTK_WIDGET(draw_window));

}

/******************************************************************************

* Crop window

******************************************************************************/

static void

scrncap_crop_window_close(GtkWidget *window, gpointer _unused)

{

if (current_window != window)

return;

is_shooting = FALSE;

current_window = NULL;

}

static gboolean

scrncap_crop_window_keypress(GtkWidget *crop_window, GdkEventKey *event,

gpointer _webview)

{

PidginWebView *webview = PIDGIN_WEBVIEW(_webview);

guint key = event->keyval;

if (key == GDK_KEY_Escape) {

gtk_widget_destroy(crop_window);

return TRUE;

}

if (key == GDK_KEY_Return) {

GdkPixbuf *screenshot, *subscreen, *result;

screenshot = g_object_get_data(G_OBJECT(crop_window),

"screenshot");

subscreen = gdk_pixbuf_new_subpixbuf(screenshot,

crop_x, crop_y, crop_w, crop_h);

result = gdk_pixbuf_copy(subscreen);

g_object_unref(subscreen);

gtk_widget_destroy(crop_window);

scrncap_draw_window(webview, result);

return TRUE;

}

return FALSE;

}

static gboolean

scrncap_crop_window_focusout(GtkWidget *window, GdkEventFocus *event,

gpointer _unused)

{

gtk_widget_destroy(window);

return FALSE;

}

static gboolean

scrncap_crop_window_btnpress(GtkWidget *window, GdkEventButton *event,

gpointer _unused)

{

GtkWidget *hint_box;

GtkImage *selection;

GtkFixed *cont;

g_return_val_if_fail(!crop_active, TRUE);

hint_box = g_object_get_data(G_OBJECT(window), "hint-box");

if (hint_box) {

gtk_widget_destroy(hint_box);

g_object_set_data(G_OBJECT(window), "hint-box", NULL);

}

selection = g_object_get_data(G_OBJECT(window), "selection");

cont = g_object_get_data(G_OBJECT(window), "cont");

gtk_fixed_move(cont, GTK_WIDGET(selection), -10, -10);

gtk_image_set_from_pixbuf(selection, NULL);

gtk_widget_show(GTK_WIDGET(selection));

crop_origin_x = event->x_root;

crop_origin_y = event->y_root;

crop_active = TRUE;

return TRUE;

}

static gboolean

scrncap_crop_window_btnrelease(GtkWidget *window, GdkEvent *event,

gpointer _unused)

{

crop_active = FALSE;

return TRUE;

}

static gboolean

scrncap_crop_window_motion(GtkWidget *window, GdkEventButton *event,

gpointer _unused)

{

GtkFixed *cont;

GtkImage *selection;

GdkPixbuf *crop, *screenshot;

g_return_val_if_fail(crop_active, FALSE);

selection = g_object_get_data(G_OBJECT(window), "selection");

cont = g_object_get_data(G_OBJECT(window), "cont");

crop_x = MIN(crop_origin_x, event->x_root);

crop_y = MIN(crop_origin_y, event->y_root);

crop_w = abs(crop_origin_x - event->x_root);

crop_h = abs(crop_origin_y - event->y_root);

crop_w = MAX(crop_w, 1);

crop_h = MAX(crop_h, 1);

gtk_fixed_move(cont, GTK_WIDGET(selection), crop_x, crop_y);

screenshot = g_object_get_data(G_OBJECT(window), "screenshot");

crop = gdk_pixbuf_new_subpixbuf(screenshot,

crop_x, crop_y, crop_w, crop_h);

gtk_image_set_from_pixbuf(GTK_IMAGE(selection), crop);

g_object_unref(crop);

return FALSE;

}

static void

scrncap_crop_window_realize(GtkWidget *crop_window, gpointer _unused)

{

GdkWindow *gdkwindow;

GdkDisplay *display;

GdkCursor *cursor;

gdkwindow = gtk_widget_get_window(GTK_WIDGET(crop_window));

display = gdk_window_get_display(gdkwindow);

gdk_window_set_events(gdkwindow, gdk_window_get_events(gdkwindow) |

GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |

GDK_BUTTON_MOTION_MASK);

cursor = gdk_cursor_new_for_display(display, GDK_CROSSHAIR);

gdk_window_set_cursor(gdkwindow, cursor);

g_object_unref(cursor);

}

static gboolean

scrncap_do_screenshot_cb(gpointer _webview)

{

PidginWebView *webview = PIDGIN_WEBVIEW(_webview);

GtkWindow *crop_window;

GdkPixbuf *screenshot, *screenshot_d;

int width, height;

GtkFixed *cont;

GtkImage *image, *selection;

GtkWidget *hint;

gchar *hint_msg;

GtkRequisition hint_size;

GtkWidget *hint_box;

shooting_timeout = 0;

crop_active = FALSE;

(void)webview;

screenshot = scrncap_perform_screenshot();

g_return_val_if_fail(screenshot != NULL, G_SOURCE_REMOVE);

width = gdk_pixbuf_get_width(screenshot);

height = gdk_pixbuf_get_height(screenshot);

crop_x = crop_y = 0;

crop_w = width;

crop_h = height;

current_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

crop_window = GTK_WINDOW(current_window);

gtk_window_set_decorated(crop_window, FALSE);

gtk_window_set_resizable(crop_window, FALSE);

gtk_widget_set_size_request(GTK_WIDGET(crop_window), width, height);

gtk_window_fullscreen(crop_window);

gtk_window_set_keep_above(crop_window, TRUE);

g_signal_connect(G_OBJECT(crop_window), "realize",

G_CALLBACK(scrncap_crop_window_realize), NULL);

g_signal_connect(G_OBJECT(crop_window), "destroy",

G_CALLBACK(scrncap_crop_window_close), NULL);

g_signal_connect(G_OBJECT(crop_window), "key-press-event",

G_CALLBACK(scrncap_crop_window_keypress), webview);

g_signal_connect(G_OBJECT(crop_window), "focus-out-event",

G_CALLBACK(scrncap_crop_window_focusout), NULL);

g_signal_connect(G_OBJECT(crop_window), "button-press-event",

G_CALLBACK(scrncap_crop_window_btnpress), NULL);

g_signal_connect(G_OBJECT(crop_window), "button-release-event",

G_CALLBACK(scrncap_crop_window_btnrelease), NULL);

g_signal_connect(G_OBJECT(crop_window), "motion-notify-event",

G_CALLBACK(scrncap_crop_window_motion), NULL);

g_object_set_data_full(G_OBJECT(crop_window), "screenshot",

screenshot, g_object_unref);

cont = GTK_FIXED(gtk_fixed_new());

g_object_set_data(G_OBJECT(crop_window), "cont", cont);

gtk_container_add(GTK_CONTAINER(crop_window), GTK_WIDGET(cont));

screenshot_d = gdk_pixbuf_copy(screenshot);

scrncap_pixbuf_darken(screenshot_d);

image = GTK_IMAGE(gtk_image_new_from_pixbuf(screenshot_d));

g_object_unref(screenshot_d);

gtk_fixed_put(cont, GTK_WIDGET(image), 0, 0);

selection = GTK_IMAGE(gtk_image_new_from_pixbuf(NULL));

gtk_fixed_put(cont, GTK_WIDGET(selection), -10, -10);

g_object_set_data(G_OBJECT(crop_window), "selection", selection);

hint = gtk_label_new(NULL);

hint_msg = g_strdup_printf("<span size='x-large'>%s</span>",

_("Select the region to send and press Enter button to confirm "

"or press Escape button to cancel"));

gtk_label_set_markup(GTK_LABEL(hint), hint_msg);

g_free(hint_msg);

gtk_widget_set_margin_start(hint, 10);

gtk_widget_set_margin_end(hint, 10);

gtk_widget_set_margin_top(hint, 7);

gtk_widget_set_margin_bottom(hint, 7);

hint_box = gtk_event_box_new();

gtk_container_add(GTK_CONTAINER(hint_box), hint);

gtk_widget_get_preferred_size(hint, NULL, &hint_size);

gtk_fixed_put(cont, hint_box,

width / 2 - hint_size.width / 2 - 10,

height / 2 - hint_size.height / 2 - 7);

g_object_set_data(G_OBJECT(crop_window), "hint-box", hint_box);

gtk_widget_show_all(GTK_WIDGET(crop_window));

gtk_widget_hide(GTK_WIDGET(selection));

return G_SOURCE_REMOVE;

}

static void

scrncap_do_screenshot(GtkAction *action, PidginWebView *webview)

{

if (current_window) {

gtk_window_present(GTK_WINDOW(current_window));

return;

}

if (is_shooting)

return;

is_shooting = TRUE;

shooting_timeout = g_timeout_add(SCRNCAP_SHOOTING_TIMEOUT,

scrncap_do_screenshot_cb, webview);

}

/******************************************************************************

* PidginConversation setup

******************************************************************************/

static void

scrncap_convwin_switch(GtkNotebook *notebook, GtkWidget *page, gint page_num,

gpointer _win)

{

PidginConvWindow *win = _win;

PidginConversation *gtkconv;

PidginWebView *webview;

gboolean images_supported;

GtkAction *action;

gtkconv = pidgin_conv_window_get_active_gtkconv(win);

if (gtkconv == NULL)

return;

webview = PIDGIN_WEBVIEW(gtkconv->entry);

action = g_object_get_data(G_OBJECT(win->menu->menubar),

"insert-screenshot-action");

g_return_if_fail(action != NULL);

images_supported = pidgin_webview_get_format_functions(webview) &

PIDGIN_WEBVIEW_IMAGE;

gtk_action_set_sensitive(action, images_supported);

}

static void

scrncap_convwin_menu_cb(GtkAction *action, PidginConvWindow *win)

{

PidginConversation *gtkconv;

PidginWebView *webview;

gtkconv = pidgin_conv_window_get_active_gtkconv(win);

webview = PIDGIN_WEBVIEW(gtkconv->entry);

scrncap_do_screenshot(action, webview);

}

static void

scrncap_convwin_init(PidginConvWindow *win)

{

PidginConvWindowMenu *menu = win->menu;

GtkAction *action;

GtkWidget *conv_submenu, *conv_insert_image;

GtkWidget *scrncap_btn_menu;

gint pos = -1, i;

GList *children, *it;

action = g_object_get_data(G_OBJECT(menu->menubar),

"insert-screenshot-action");

if (action != NULL)

return;

action = gtk_action_new("InsertScreenshot", _("Insert Screens_hot..."),

NULL, PIDGIN_ICON_CAMERA_PHOTO);

gtk_action_set_is_important(action, TRUE);

g_object_set_data_full(G_OBJECT(menu->menubar),

"insert-screenshot-action", action, g_object_unref);

g_signal_connect(G_OBJECT(action), "activate",

G_CALLBACK(scrncap_convwin_menu_cb), win);

conv_insert_image = gtk_ui_manager_get_widget(menu->ui,

"/Conversation/ConversationMenu/InsertImage");

g_return_if_fail(conv_insert_image != NULL);

conv_submenu = gtk_widget_get_parent(conv_insert_image);

children = gtk_container_get_children(GTK_CONTAINER(conv_submenu));

pos = g_list_index(children, conv_insert_image);

if (pos != -1)

++pos;

g_list_free(children);

g_warn_if_fail(pos >= 0);

scrncap_btn_menu = gtk_action_create_menu_item(action);

g_object_set_data(G_OBJECT(menu->menubar), "insert-screenshot-btn",

scrncap_btn_menu);

gtk_menu_shell_insert(GTK_MENU_SHELL(conv_submenu),

GTK_WIDGET(scrncap_btn_menu), pos);

gtk_widget_show(GTK_WIDGET(scrncap_btn_menu));

g_signal_connect_after(G_OBJECT(win->notebook), "switch-page",

G_CALLBACK(scrncap_convwin_switch), win);

scrncap_convwin_switch(GTK_NOTEBOOK(win->notebook), NULL, 0, win);

}

static void

scrncap_convwin_uninit(PidginConvWindow *win)

{

PidginConvWindowMenu *menu = win->menu;

GtkWidget *btn;

btn = g_object_get_data(G_OBJECT(menu->menubar),

"insert-screenshot-btn");

if (btn)

gtk_widget_destroy(btn);

g_object_set_data(G_OBJECT(menu->menubar),

"insert-screenshot-btn", NULL);

g_object_set_data(G_OBJECT(menu->menubar),

"insert-screenshot-action", NULL);

g_signal_handlers_disconnect_matched(win->notebook, G_SIGNAL_MATCH_FUNC,

0, 0, NULL, scrncap_convwin_switch, NULL);

}

static void

scrncap_conversation_update(PidginWebView *webview,

PidginWebViewButtons buttons, gpointer _action)

{

GtkAction *action = GTK_ACTION(_action);

gtk_action_set_sensitive(action, buttons & PIDGIN_WEBVIEW_IMAGE);

}

static void

scrncap_conversation_init(PidginConversation *gtkconv)

{

PidginWebView *webview;

PidginWebViewToolbar *toolbar;

GtkAction *action;

GtkToolItem *scrncap_btn_wide;

GtkWidget *scrncap_btn_lean;

gint pos = -1, i;

GtkToolbar *wide_view, *lean_view;

GtkMenu *wide_menu = NULL;

GList *wide_children, *it;

if (scrncap_conv_get_data(gtkconv, "scrncap-btn-wide") != NULL)

return;

webview = PIDGIN_WEBVIEW(gtkconv->entry);

toolbar = PIDGIN_WEBVIEWTOOLBAR(pidgin_webview_get_toolbar(webview));

g_return_if_fail(toolbar != NULL);

wide_view = GTK_TOOLBAR(pidgin_webviewtoolbar_get_wide_view(toolbar));

g_return_if_fail(wide_view != NULL);

lean_view = GTK_TOOLBAR(pidgin_webviewtoolbar_get_lean_view(toolbar));

g_return_if_fail(lean_view != NULL);

action = gtk_action_new("InsertScreenshot", _("_Screenshot"),

_("Insert screenshot"), PIDGIN_ICON_CAMERA_PHOTO);

gtk_action_set_is_important(action, TRUE);

g_signal_connect(G_OBJECT(action), "activate",

G_CALLBACK(scrncap_do_screenshot), webview);

scrncap_btn_wide = GTK_TOOL_ITEM(gtk_action_create_tool_item(action));

scrncap_conv_set_data(gtkconv, "scrncap-btn-wide", scrncap_btn_wide);

for (i = 0; i < gtk_toolbar_get_n_items(wide_view); i++) {

GtkToolItem *ref_item = gtk_toolbar_get_nth_item(wide_view, i);

GtkAction *action;

action = g_object_get_data(G_OBJECT(ref_item), "action");

if (action == NULL)

continue;

if (g_strcmp0(gtk_action_get_name(action), "InsertImage") == 0) {

pos = i + 1;

break;

}

gtk_toolbar_insert(wide_view, scrncap_btn_wide, pos);

gtk_widget_show(GTK_WIDGET(scrncap_btn_wide));

for (i = 0; i < gtk_toolbar_get_n_items(lean_view); i++) {

GtkToolItem *ref_item = gtk_toolbar_get_nth_item(lean_view, i);

const gchar *menu_name;

menu_name = g_object_get_data(G_OBJECT(ref_item), "menu-name");

if (g_strcmp0(menu_name, "insert") == 0) {

wide_menu = g_object_get_data(G_OBJECT(ref_item), "menu");

break;

}

g_return_if_fail(wide_menu);

pos = -1;

wide_children = gtk_container_get_children(GTK_CONTAINER(wide_menu));

for (it = wide_children, i = 0; it; it = g_list_next(it), i++) {

GtkWidget *child = it->data;

GtkAction *action;

action = g_object_get_data(G_OBJECT(child), "action");

if (action == NULL)

continue;

if (g_strcmp0(gtk_action_get_name(action), "InsertImage") == 0) {

pos = i + 1;

break;

}

g_list_free(wide_children);

if (pos < 0) {

g_warn_if_fail(pos >= 0);

pos = 0;

}

g_signal_connect_object(G_OBJECT(webview), "allowed-formats-updated",

G_CALLBACK(scrncap_conversation_update), action, 0);

scrncap_conversation_update(webview,

pidgin_webview_get_format_functions(webview), action);

scrncap_btn_lean = gtk_action_create_menu_item(action);

scrncap_conv_set_data(gtkconv, "scrncap-btn-lean", scrncap_btn_lean);

gtk_menu_shell_insert(GTK_MENU_SHELL(wide_menu),

GTK_WIDGET(scrncap_btn_lean), pos);

gtk_widget_show(GTK_WIDGET(scrncap_btn_lean));

}

static void

scrncap_conversation_uninit(PidginConversation *gtkconv)

{

GtkWidget *scrncap_btn_wide, *scrncap_btn_lean;

scrncap_btn_wide = scrncap_conv_get_data(gtkconv, "scrncap-btn-wide");

if (scrncap_btn_wide == NULL)

return;

scrncap_btn_lean = scrncap_conv_get_data(gtkconv, "scrncap-btn-lean");

gtk_widget_destroy(scrncap_btn_wide);

if (scrncap_btn_lean)

gtk_widget_destroy(scrncap_btn_lean);

scrncap_conv_set_data(gtkconv, "scrncap-btn-wide", NULL);

scrncap_conv_set_data(gtkconv, "scrncap-btn-lean", NULL);

}

/******************************************************************************

* Plugin setup

******************************************************************************/

static PidginPluginInfo *

plugin_query(GError **error)

{

const gchar * const authors[] = {

"Tomasz Wasilczyk <twasilczyk@pidgin.im>",

NULL

};

return pidgin_plugin_info_new(

"id", "gtk-screencap",

"name", N_("Screen Capture"),

"version", DISPLAY_VERSION,

"category", N_("Utility"),

"summary", N_("Send screenshots to your buddies."),

"description", N_("Adds an option to send a screenshot as an inline "

"image. It works only with protocols that supports "

"inline images."),

"authors", authors,

"website", PURPLE_WEBSITE,

"abi-version", PURPLE_ABI_VERSION,

NULL

);

}

static gboolean

plugin_load(PurplePlugin *plugin, GError **error)

{

GList *it;

const gchar *color_str;

purple_prefs_add_none("/plugins");

purple_prefs_add_none("/plugins/gtk");

purple_prefs_add_none("/plugins/gtk/screencap");

purple_prefs_add_string("/plugins/gtk/screencap/brush_color",

SCRNCAP_DEFAULT_COLOR);

color_str = purple_prefs_get_string("/plugins/gtk/screencap/brush_color");

if (color_str && color_str[0])

gdk_rgba_parse(&brush_color, color_str);

purple_signal_connect(pidgin_conversations_get_handle(),

"conversation-displayed", plugin,

PURPLE_CALLBACK(scrncap_conversation_init), NULL);

purple_signal_connect(pidgin_conversations_get_handle(),

"conversation-window-created", plugin,

PURPLE_CALLBACK(scrncap_convwin_init), NULL);

it = purple_conversations_get_all();

for (; it; it = g_list_next(it)) {

PurpleConversation *conv = it->data;

if (!PIDGIN_IS_PIDGIN_CONVERSATION(conv))

continue;

scrncap_conversation_init(PIDGIN_CONVERSATION(conv));

}

it = pidgin_conv_windows_get_list();

for (; it; it = g_list_next(it)) {

PidginConvWindow *win = it->data;

scrncap_convwin_init(win);

}

return TRUE;

}

static gboolean

plugin_unload(PurplePlugin *plugin, GError **error)

{

GList *it;

if (shooting_timeout > 0)

g_source_remove(shooting_timeout);

if (current_window != NULL)

gtk_widget_destroy(GTK_WIDGET(current_window));

it = purple_conversations_get_all();

for (; it; it = g_list_next(it)) {

PurpleConversation *conv = it->data;

if (!PIDGIN_IS_PIDGIN_CONVERSATION(conv))

continue;

scrncap_conversation_uninit(PIDGIN_CONVERSATION(conv));

}

it = pidgin_conv_windows_get_list();

for (; it; it = g_list_next(it)) {

PidginConvWindow *win = it->data;

scrncap_convwin_uninit(win);

}

return TRUE;

}

PURPLE_PLUGIN_INIT(screencap, plugin_query, plugin_load, plugin_unload);

pidgin/pidgin