HGKeeper

* pidgin

* Pidgin is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* 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 <glib/gi18n-lib.h>

#include <gtk/gtk.h>

#include <adwaita.h>

#include <math.h>

#ifndef M_PI

#define M_PI (3.14159265358979323846264338327950288)

#endif

#include <purple.h>

#include "gtkwhiteboard.h"

#include "gtkutils.h"

#define UI_DATA "pidgin-ui-data"

#define PIDGIN_TYPE_WHITEBOARD (pidgin_whiteboard_get_type())

G_DECLARE_FINAL_TYPE(PidginWhiteboard, pidgin_whiteboard, PIDGIN, WHITEBOARD,

GtkWindow)

/**

* PidginWhiteboard:

* @cr: Cairo context for drawing

* @surface: Cairo surface for drawing

* @wb: Backend data for this whiteboard

* @drawing_area: Drawing area

* @color_button: A color chooser widget

* @width: Canvas width

* @height: Canvas height

* @brush_color: Foreground color

* @brush_size: Brush size

* @brush_state: The @PidginWhiteboardBrushState state of the brush

* A PidginWhiteboard

struct _PidginWhiteboard

{

GtkWindow parent;

cairo_t *cr;

cairo_surface_t *surface;

PurpleWhiteboard *wb;

GtkWidget *drawing_area;

GtkBox *toolbar;

GtkWidget *color_button;

int width;

int height;

int brush_color;

int brush_size;

/* Tracks last position of the mouse when drawing */

gdouble start_x;

gdouble start_y;

gdouble last_x;

gdouble last_y;

};

G_DEFINE_FINAL_TYPE(PidginWhiteboard, pidgin_whiteboard, GTK_TYPE_WINDOW)

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

* Helpers

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

static void

pidgin_whiteboard_rgb24_to_rgba(int color_rgb, GdkRGBA *color)

{

color->red = ((color_rgb >> 16) & 0xFF) / 255.0f;

color->green = ((color_rgb >> 8) & 0xFF) / 255.0f;

color->blue = (color_rgb & 0xFF) / 255.0f;

color->alpha = 1.0f;

}

static void

whiteboard_destroy_cb(GtkWidget *widget, G_GNUC_UNUSED gpointer data)

{

PidginWhiteboard *gtkwb = PIDGIN_WHITEBOARD(widget);

g_clear_object(&gtkwb->wb);

}

static void

pidgin_whiteboard_resize(G_GNUC_UNUSED GtkDrawingArea *self, gint width,

gint height, gpointer data)

{

PidginWhiteboard *gtkwb = (PidginWhiteboard*)data;

GdkRGBA white = {1.0f, 1.0f, 1.0f, 1.0f};

cairo_t *cr;

g_clear_pointer(&gtkwb->cr, cairo_destroy);

g_clear_pointer(&gtkwb->surface, cairo_surface_destroy);

gtkwb->surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width,

height);

gtkwb->cr = cr = cairo_create(gtkwb->surface);

gdk_cairo_set_source_rgba(cr, &white);

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

cairo_fill(cr);

}

static gboolean

pidgin_whiteboard_draw_event(G_GNUC_UNUSED GtkWidget *widget, cairo_t *cr,

gpointer _gtkwb)

{

PidginWhiteboard *gtkwb = _gtkwb;

cairo_set_source_surface(cr, gtkwb->surface, 0, 0);

cairo_paint(cr);

return FALSE;

}

static void

pidgin_whiteboard_draw_brush_point(PurpleWhiteboard *wb, int x, int y,

int color, int size)

{

PidginWhiteboard *gtkwb = g_object_get_data(G_OBJECT(wb), UI_DATA);

GtkWidget *widget = gtkwb->drawing_area;

cairo_t *gfx_con = gtkwb->cr;

GdkRGBA rgba;

/* Interpret and convert color */

pidgin_whiteboard_rgb24_to_rgba(color, &rgba);

gdk_cairo_set_source_rgba(gfx_con, &rgba);

/* Draw a circle */

cairo_arc(gfx_con, x, y, size / 2.0, 0.0, 2.0 * M_PI);

cairo_fill(gfx_con);

gtk_widget_queue_draw(widget);

}

/* Uses Bresenham's algorithm (as provided by Wikipedia) */

static void

pidgin_whiteboard_draw_brush_line(PurpleWhiteboard *wb, int x0, int y0, int x1,

int y1, int color, int size)

{

int temp;

int xstep;

int ystep;

int dx;

int dy;

int error;

int derror;

int x;

int y;

gboolean steep = abs(y1 - y0) > abs(x1 - x0);

if (steep) {

temp = x0;

x0 = y0;

y0 = temp;

temp = x1;

x1 = y1;

y1 = temp;

}

dx = abs(x1 - x0);

dy = abs(y1 - y0);

error = 0;

derror = dy;

x = x0;

y = y0;

if (x0 < x1) {

xstep = 1;

} else {

xstep = -1;

}

if (y0 < y1) {

ystep = 1;

} else {

ystep = -1;

}

if (steep) {

pidgin_whiteboard_draw_brush_point(wb, y, x, color, size);

} else {

pidgin_whiteboard_draw_brush_point(wb, x, y, color, size);

}

while (x != x1) {

x += xstep;

error += derror;

if ((error * 2) >= dx) {

y += ystep;

error -= dx;

}

if (steep) {

pidgin_whiteboard_draw_brush_point(wb, y, x, color,

size);

} else {

pidgin_whiteboard_draw_brush_point(wb, x, y, color,

size);

}

static void

pidgin_whiteboard_brush_down(G_GNUC_UNUSED GtkGestureDrag* self, gdouble x,

gdouble y, gpointer data)

{

PidginWhiteboard *gtkwb = (PidginWhiteboard*)data;

PurpleWhiteboard *wb = gtkwb->wb;

GList *draw_list = purple_whiteboard_get_draw_list(wb);

if(gtkwb->cr != NULL) {

/* Check if draw_list has contents; if so, clear it */

if(draw_list) {

purple_whiteboard_draw_list_destroy(draw_list);

draw_list = NULL;

}

/* Set tracking variables */

gtkwb->start_x = x;

gtkwb->start_y = y;

gtkwb->last_x = 0;

gtkwb->last_y = 0;

draw_list = g_list_append(draw_list, GINT_TO_POINTER(gtkwb->start_x));

draw_list = g_list_append(draw_list, GINT_TO_POINTER(gtkwb->start_y));

pidgin_whiteboard_draw_brush_point(gtkwb->wb, gtkwb->start_x,

gtkwb->start_y, gtkwb->brush_color,

gtkwb->brush_size);

}

purple_whiteboard_set_draw_list(wb, draw_list);

}

static void

pidgin_whiteboard_brush_motion(G_GNUC_UNUSED GtkGestureDrag* self, gdouble x,

gdouble y, gpointer data)

{

PidginWhiteboard *gtkwb = (PidginWhiteboard*)data;

PurpleWhiteboard *wb = gtkwb->wb;

GList *draw_list = purple_whiteboard_get_draw_list(wb);

if (gtkwb->cr != NULL) {

gdouble dx, dy;

/* x and y are relative to the starting post, but we need to know where

* there are according to the last point, so we have to do the algebra.

dx = (x + gtkwb->start_x - gtkwb->last_x);

dy = (y + gtkwb->start_y - gtkwb->last_y);

draw_list = g_list_append(draw_list, GINT_TO_POINTER(dx));

draw_list = g_list_append(draw_list, GINT_TO_POINTER(dy));

pidgin_whiteboard_draw_brush_line(gtkwb->wb,

gtkwb->start_x + gtkwb->last_x,

gtkwb->start_y + gtkwb->last_y,

gtkwb->start_x + x,

gtkwb->start_y + y,

gtkwb->brush_color,

gtkwb->brush_size);

gtkwb->last_x = x;

gtkwb->last_y = y;

}

purple_whiteboard_set_draw_list(wb, draw_list);

}

static void

pidgin_whiteboard_brush_up(G_GNUC_UNUSED GtkGestureDrag *self,

G_GNUC_UNUSED gdouble x, G_GNUC_UNUSED gdouble y,

gpointer data)

{

PidginWhiteboard *gtkwb = (PidginWhiteboard*)data;

PurpleWhiteboard *wb = gtkwb->wb;

GList *draw_list = purple_whiteboard_get_draw_list(wb);

if(gtkwb->cr != NULL) {

/* Send draw list to protocol draw_list handler */

purple_whiteboard_send_draw_list(gtkwb->wb, draw_list);

/* The brush stroke is finished, clear the list for another one

if (draw_list) {

purple_whiteboard_draw_list_destroy(draw_list);

}

purple_whiteboard_set_draw_list(wb, NULL);

}

static void pidgin_whiteboard_set_dimensions(PurpleWhiteboard *wb, int width, int height)

{

PidginWhiteboard *gtkwb = g_object_get_data(G_OBJECT(wb), UI_DATA);

gtkwb->width = width;

gtkwb->height = height;

}

static void pidgin_whiteboard_set_brush(PurpleWhiteboard *wb, int size, int color)

{

PidginWhiteboard *gtkwb = g_object_get_data(G_OBJECT(wb), UI_DATA);

gtkwb->brush_size = size;

gtkwb->brush_color = color;

}

static void pidgin_whiteboard_clear(PurpleWhiteboard *wb)

{

PidginWhiteboard *gtkwb = g_object_get_data(G_OBJECT(wb), UI_DATA);

GtkWidget *drawing_area = gtkwb->drawing_area;

cairo_t *cr = gtkwb->cr;

GtkAllocation allocation;

GdkRGBA white = {1.0f, 1.0f, 1.0f, 1.0f};

gtk_widget_get_allocation(drawing_area, &allocation);

gdk_cairo_set_source_rgba(cr, &white);

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

cairo_fill(cr);

gtk_widget_queue_draw(drawing_area);

}

static void

pidgin_whiteboard_clear_response(G_GNUC_UNUSED AdwMessageDialog *self,

char *response, gpointer data)

{

PidginWhiteboard *gtkwb = (PidginWhiteboard *)data;

if(!purple_strequal(response, "yes")) {

return;

}

pidgin_whiteboard_clear(gtkwb->wb);

/* Do protocol specific clearing procedures */

purple_whiteboard_send_clear(gtkwb->wb);

}

static void

pidgin_whiteboard_button_clear_press(G_GNUC_UNUSED GtkWidget *widget,

gpointer data)

{

PidginWhiteboard *gtkwb = (PidginWhiteboard*)(data);

AdwMessageDialog *dialog = NULL;

/* Confirm whether the user really wants to clear */

dialog = ADW_MESSAGE_DIALOG(adw_message_dialog_new(

GTK_WINDOW(gtkwb),

_("Clear whiteboard?"),

_("Do you want to clear this whiteboard?")));

adw_message_dialog_add_responses(dialog, "no", _("_No"), "yes", _("_Yes"),

NULL);

adw_message_dialog_set_response_appearance(dialog, "yes",

ADW_RESPONSE_DESTRUCTIVE);

adw_message_dialog_set_default_response(dialog, "yes");

adw_message_dialog_set_close_response(dialog, "no");

g_signal_connect(dialog, "response",

G_CALLBACK(pidgin_whiteboard_clear_response), gtkwb);

gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);

gtk_window_present_with_time(GTK_WINDOW(dialog), GDK_CURRENT_TIME);

}

static void

pidgin_whiteboard_save_response(GObject *obj, GAsyncResult *result,

gpointer data)

{

PidginWhiteboard *gtkwb = (PidginWhiteboard *)data;

GFile *file = NULL;

char *filename = NULL;

GdkPixbuf *pixbuf;

gboolean success;

file = gtk_file_dialog_save_finish(GTK_FILE_DIALOG(obj), result, NULL);

if(file == NULL) {

return;

}

filename = g_file_get_path(file);

pixbuf = gdk_pixbuf_get_from_surface(gtkwb->surface, 0, 0,

gtkwb->width, gtkwb->height);

success = gdk_pixbuf_save(pixbuf, filename, "png", NULL,

"compression", "9", NULL);

g_object_unref(pixbuf);

if (success) {

purple_debug_info("gtkwhiteboard", "whiteboard saved to \"%s\"",

filename);

} else {

purple_notify_error(NULL, _("Whiteboard"),

_("Unable to save the file"), NULL, NULL);

purple_debug_error("gtkwhiteboard",

"whiteboard couldn't be saved to \"%s\"", filename);

}

g_free(filename);

g_object_unref(file);

}

static void

pidgin_whiteboard_button_save_press(G_GNUC_UNUSED GtkWidget *widget,

gpointer _gtkwb)

{

PidginWhiteboard *gtkwb = _gtkwb;

GtkFileDialog *dialog;

dialog = gtk_file_dialog_new();

gtk_file_dialog_set_title(dialog, _("Save File"));

gtk_file_dialog_set_modal(dialog, TRUE);

gtk_file_dialog_set_initial_name(dialog, "whiteboard.png");

gtk_file_dialog_save(dialog, GTK_WINDOW(gtkwb), NULL,

pidgin_whiteboard_save_response, gtkwb);

g_object_unref(dialog);

}

static void

notify_color_cb(GObject *obj, G_GNUC_UNUSED GParamSpec *pspec, gpointer data) {

PidginWhiteboard *gtkwb = data;

PurpleWhiteboard *wb = gtkwb->wb;

const GdkRGBA *color;

int old_size, old_color;

int new_color;

color = gtk_color_dialog_button_get_rgba(GTK_COLOR_DIALOG_BUTTON(obj));

new_color = (unsigned int)(color->red * 255) << 16;

new_color |= (unsigned int)(color->green * 255) << 8;

new_color |= (unsigned int)(color->blue * 255);

purple_whiteboard_get_brush(wb, &old_size, &old_color);

purple_whiteboard_send_brush(wb, old_size, new_color);

}

static void

pidgin_whiteboard_create(PurpleWhiteboard *wb)

{

PidginWhiteboard *gtkwb;

GdkRGBA color;

gtkwb = g_object_new(PIDGIN_TYPE_WHITEBOARD, NULL);

gtkwb->wb = wb;

g_object_set_data_full(G_OBJECT(wb), UI_DATA, gtkwb, g_object_unref);

/* Get dimensions (default?) for the whiteboard canvas */

if (!purple_whiteboard_get_dimensions(wb, &gtkwb->width,

&gtkwb->height)) {

/* Give some initial board-size */

gtkwb->width = 300;

gtkwb->height = 250;

}

if (!purple_whiteboard_get_brush(wb, &gtkwb->brush_size,

&gtkwb->brush_color)) {

/* Give some initial brush-info */

gtkwb->brush_size = 2;

gtkwb->brush_color = 0xff0000;

}

/* Set the window title to the id of the whiteboard as we can't test

* anything right now.

gtk_window_set_title(GTK_WINDOW(gtkwb), purple_whiteboard_get_id(wb));

gtk_widget_set_name(GTK_WIDGET(gtkwb), purple_whiteboard_get_id(wb));

gtk_widget_set_size_request(GTK_WIDGET(gtkwb->drawing_area),

gtkwb->width, gtkwb->height);

pidgin_whiteboard_rgb24_to_rgba(gtkwb->brush_color, &color);

gtk_color_dialog_button_set_rgba(GTK_COLOR_DIALOG_BUTTON(gtkwb->color_button),

&color);

/* Make all this (window) visible */

gtk_widget_set_visible(GTK_WIDGET(gtkwb), TRUE);

/* TODO Specific protocol/whiteboard assignment here? Needs a UI Op? */

/* Set default brush size and color */

ds->brush_size = DOODLE_BRUSH_MEDIUM;

ds->brush_color = 0;

}

static void

pidgin_whiteboard_destroy(PurpleWhiteboard *wb)

{

PidginWhiteboard *gtkwb;

g_return_if_fail(wb != NULL);

gtkwb = g_object_get_data(G_OBJECT(wb), UI_DATA);

g_return_if_fail(gtkwb != NULL);

/* TODO Ask if user wants to save picture before the session is closed

gtkwb->wb = NULL;

}

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

* GObject implementation

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

static void

pidgin_whiteboard_init(PidginWhiteboard *self) {

gtk_widget_init_template(GTK_WIDGET(self));

self->color_button = gtk_color_dialog_button_new(gtk_color_dialog_new());

g_signal_connect(self->color_button, "notify::rgba",

G_CALLBACK(notify_color_cb), self);

gtk_box_append(self->toolbar, GTK_WIDGET(self->color_button));

}

static void

pidgin_whiteboard_finalize(GObject *obj) {

PidginWhiteboard *gtkwb = PIDGIN_WHITEBOARD(obj);

/* Clear graphical memory */

g_clear_pointer(&gtkwb->cr, cairo_destroy);

g_clear_pointer(&gtkwb->surface, cairo_surface_destroy);

G_OBJECT_CLASS(pidgin_whiteboard_parent_class)->finalize(obj);

}

static void

pidgin_whiteboard_class_init(PidginWhiteboardClass *klass)

{

GObjectClass *obj_class = G_OBJECT_CLASS(klass);

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);

obj_class->finalize = pidgin_whiteboard_finalize;

gtk_widget_class_set_template_from_resource(

widget_class, "/im/pidgin/Pidgin3/Whiteboard/whiteboard.ui");

gtk_widget_class_bind_template_child(widget_class, PidginWhiteboard,

drawing_area);

gtk_widget_class_bind_template_child(widget_class, PidginWhiteboard,

toolbar);