+/*
+ * 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 software 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, see <http://www.gnu.org/licenses/>.
+ */
+
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "xo-misc.h"
#include "xo-paint.h"
+/***** Win32 fix for gdk_cursor_new_from_pixmap() by Dirk Gerrits ****/
+
+#ifdef WIN32
+gboolean colors_too_similar(const GdkColor *colora, const GdkColor *colorb)
+{
+ return (abs(colora->red - colorb->red) < 256 &&
+ abs(colora->green - colorb->green) < 256 &&
+ abs(colora->blue - colorb->blue) < 256);
+}
+
+/* gdk_cursor_new_from_pixmap is broken on Windows.
+ this is a workaround using gdk_cursor_new_from_pixbuf. */
+GdkCursor* fixed_gdk_cursor_new_from_pixmap(GdkPixmap *source, GdkPixmap *mask,
+ const GdkColor *fg, const GdkColor *bg,
+ gint x, gint y)
+{
+ GdkPixmap *rgb_pixmap;
+ GdkGC *gc;
+ GdkPixbuf *rgb_pixbuf, *rgba_pixbuf;
+ GdkCursor *cursor;
+ int width, height;
+
+ /* HACK! It seems impossible to work with RGBA pixmaps directly in
+ GDK-Win32. Instead we pick some third color, different from fg
+ and bg, and use that as the 'transparent color'. We do this using
+ colors_too_similar (see above) because two colors could be
+ unequal in GdkColor's 16-bit/sample, but equal in GdkPixbuf's
+ 8-bit/sample. */
+ GdkColor candidates[3] = {{0,65535,0,0}, {0,0,65535,0}, {0,0,0,65535}};
+ GdkColor *trans = &candidates[0];
+ if (colors_too_similar(trans, fg) || colors_too_similar(trans, bg)) {
+ trans = &candidates[1];
+ if (colors_too_similar(trans, fg) || colors_too_similar(trans, bg)) {
+ trans = &candidates[2];
+ }
+ } /* trans is now guaranteed to be unique from fg and bg */
+
+ /* create an empty pixmap to hold the cursor image */
+ gdk_drawable_get_size(source, &width, &height);
+ rgb_pixmap = gdk_pixmap_new(NULL, width, height, 24);
+
+ /* blit the bitmaps defining the cursor onto a transparent background */
+ gc = gdk_gc_new(rgb_pixmap);
+ gdk_gc_set_fill(gc, GDK_SOLID);
+ gdk_gc_set_rgb_fg_color(gc, trans);
+ gdk_draw_rectangle(rgb_pixmap, gc, TRUE, 0, 0, width, height);
+ gdk_gc_set_fill(gc, GDK_OPAQUE_STIPPLED);
+ gdk_gc_set_stipple(gc, source);
+ gdk_gc_set_clip_mask(gc, mask);
+ gdk_gc_set_rgb_fg_color(gc, fg);
+ gdk_gc_set_rgb_bg_color(gc, bg);
+ gdk_draw_rectangle(rgb_pixmap, gc, TRUE, 0, 0, width, height);
+ gdk_gc_unref(gc);
+
+ /* create a cursor out of the created pixmap */
+ rgb_pixbuf = gdk_pixbuf_get_from_drawable(
+ NULL, rgb_pixmap, gdk_colormap_get_system(), 0, 0, 0, 0, width, height);
+ gdk_pixmap_unref(rgb_pixmap);
+ rgba_pixbuf = gdk_pixbuf_add_alpha(
+ rgb_pixbuf, TRUE, trans->red, trans->green, trans->blue);
+ gdk_pixbuf_unref(rgb_pixbuf);
+ cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), rgba_pixbuf, x, y);
+ gdk_pixbuf_unref(rgba_pixbuf);
+
+ return cursor;
+}
+#define gdk_cursor_new_from_pixmap fixed_gdk_cursor_new_from_pixmap
+#endif
+
+
/************** drawing nice cursors *********/
static char cursor_pen_bits[] = {
GdkPixmap *source, *mask;
GdkColor fg = {0, 0, 0, 0}, bg = {0, 65535, 65535, 65535};
+ ui.is_sel_cursor = FALSE;
if (GTK_WIDGET(canvas)->window == NULL) return;
if (ui.cursor!=NULL) {
gdk_window_set_cursor(GTK_WIDGET(canvas)->window, ui.cursor);
}
+/* adjust the cursor shape if it hovers near a selection box */
+
+void update_cursor_for_resize(double *pt)
+{
+ gboolean in_range_x, in_range_y;
+ gboolean can_resize_left, can_resize_right, can_resize_bottom, can_resize_top;
+ gdouble resize_margin;
+ GdkCursorType newcursor;
+
+ // if we're not even close to the box in some direction, return immediately
+ resize_margin = RESIZE_MARGIN / ui.zoom;
+ if (pt[0]<ui.selection->bbox.left-resize_margin || pt[0]>ui.selection->bbox.right+resize_margin
+ || pt[1]<ui.selection->bbox.top-resize_margin || pt[1]>ui.selection->bbox.bottom+resize_margin)
+ {
+ if (ui.is_sel_cursor) update_cursor();
+ return;
+ }
+
+ ui.is_sel_cursor = TRUE;
+ can_resize_left = (pt[0] < ui.selection->bbox.left+resize_margin);
+ can_resize_right = (pt[0] > ui.selection->bbox.right-resize_margin);
+ can_resize_top = (pt[1] < ui.selection->bbox.top+resize_margin);
+ can_resize_bottom = (pt[1] > ui.selection->bbox.bottom-resize_margin);
+
+ if (can_resize_left) {
+ if (can_resize_top) newcursor = GDK_TOP_LEFT_CORNER;
+ else if (can_resize_bottom) newcursor = GDK_BOTTOM_LEFT_CORNER;
+ else newcursor = GDK_LEFT_SIDE;
+ }
+ else if (can_resize_right) {
+ if (can_resize_top) newcursor = GDK_TOP_RIGHT_CORNER;
+ else if (can_resize_bottom) newcursor = GDK_BOTTOM_RIGHT_CORNER;
+ else newcursor = GDK_RIGHT_SIDE;
+ }
+ else if (can_resize_top) newcursor = GDK_TOP_SIDE;
+ else if (can_resize_bottom) newcursor = GDK_BOTTOM_SIDE;
+ else newcursor = GDK_FLEUR;
+
+ if (ui.cursor!=NULL && ui.cursor->type == newcursor) return;
+ if (ui.cursor!=NULL) gdk_cursor_unref(ui.cursor);
+ ui.cursor = gdk_cursor_new(newcursor);
+ gdk_window_set_cursor(GTK_WIDGET(canvas)->window, ui.cursor);
+}
/************** painting strokes *************/
ui.cur_path.num_points = 1;
get_pointer_coords(event, ui.cur_path.coords);
- if (ui.ruler[ui.cur_mapping])
+ if (ui.cur_brush->ruler) {
ui.cur_item->canvas_item = gnome_canvas_item_new(ui.cur_layer->group,
gnome_canvas_line_get_type(),
"cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
"fill-color-rgba", ui.cur_item->brush.color_rgba,
"width-units", ui.cur_item->brush.thickness, NULL);
- else
+ ui.cur_item->brush.variable_width = FALSE;
+ } else
ui.cur_item->canvas_item = gnome_canvas_item_new(
ui.cur_layer->group, gnome_canvas_group_get_type(), NULL);
}
void continue_stroke(GdkEvent *event)
{
GnomeCanvasPoints seg;
- double *pt;
+ double *pt, current_width;
- if (ui.ruler[ui.cur_mapping]) {
+ if (ui.cur_brush->ruler) {
pt = ui.cur_path.coords;
} else {
realloc_cur_path(ui.cur_path.num_points+1);
get_pointer_coords(event, pt+2);
- if (ui.ruler[ui.cur_mapping])
+ if (ui.cur_item->brush.variable_width) {
+ realloc_cur_widths(ui.cur_path.num_points);
+ current_width = ui.cur_item->brush.thickness*get_pressure_multiplier(event);
+ ui.cur_widths[ui.cur_path.num_points-1] = current_width;
+ }
+ else current_width = ui.cur_item->brush.thickness;
+
+ if (ui.cur_brush->ruler)
ui.cur_path.num_points = 2;
else {
if (hypot(pt[0]-pt[2], pt[1]-pt[3]) < PIXEL_MOTION_THRESHOLD/ui.zoom)
upon creation the line just copies the contents of the GnomeCanvasPoints
into an internal structure */
- if (ui.ruler[ui.cur_mapping])
+ if (ui.cur_brush->ruler)
gnome_canvas_item_set(ui.cur_item->canvas_item, "points", &seg, NULL);
else
gnome_canvas_item_new((GnomeCanvasGroup *)ui.cur_item->canvas_item,
gnome_canvas_line_get_type(), "points", &seg,
"cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
"fill-color-rgba", ui.cur_item->brush.color_rgba,
- "width-units", ui.cur_item->brush.thickness, NULL);
+ "width-units", current_width, NULL);
}
void finalize_stroke(void)
ui.cur_path.coords[2] = ui.cur_path.coords[0]+0.1;
ui.cur_path.coords[3] = ui.cur_path.coords[1];
ui.cur_path.num_points = 2;
+ ui.cur_item->brush.variable_width = FALSE;
}
- subdivide_cur_path(); // split the segment so eraser will work
+ if (!ui.cur_item->brush.variable_width)
+ subdivide_cur_path(); // split the segment so eraser will work
ui.cur_item->path = gnome_canvas_points_new(ui.cur_path.num_points);
g_memmove(ui.cur_item->path->coords, ui.cur_path.coords,
2*ui.cur_path.num_points*sizeof(double));
+ if (ui.cur_item->brush.variable_width)
+ ui.cur_item->widths = (gdouble *)g_memdup(ui.cur_widths,
+ (ui.cur_path.num_points-1)*sizeof(gdouble));
+ else ui.cur_item->widths = NULL;
update_item_bbox(ui.cur_item);
ui.cur_path.num_points = 0;
- // destroy the entire group of temporary line segments
- gtk_object_destroy(GTK_OBJECT(ui.cur_item->canvas_item));
- // make a new line item to replace it
- make_canvas_item_one(ui.cur_layer->group, ui.cur_item);
+ if (!ui.cur_item->brush.variable_width) {
+ // destroy the entire group of temporary line segments
+ gtk_object_destroy(GTK_OBJECT(ui.cur_item->canvas_item));
+ // make a new line item to replace it
+ make_canvas_item_one(ui.cur_layer->group, ui.cur_item);
+ }
// add undo information
prepare_new_undo();
g_memmove(&newhead->brush, &item->brush, sizeof(struct Brush));
newhead->path = gnome_canvas_points_new(i);
g_memmove(newhead->path->coords, item->path->coords, 2*i*sizeof(double));
+ if (newhead->brush.variable_width)
+ newhead->widths = (gdouble *)g_memdup(item->widths, (i-1)*sizeof(gdouble));
+ else newhead->widths = NULL;
}
while (++i < item->path->num_points) {
pt+=2;
newtail->path = gnome_canvas_points_new(item->path->num_points-i);
g_memmove(newtail->path->coords, item->path->coords+2*i,
2*(item->path->num_points-i)*sizeof(double));
+ if (newtail->brush.variable_width)
+ newtail->widths = (gdouble *)g_memdup(item->widths+i,
+ (item->path->num_points-i-1)*sizeof(gdouble));
+ else newtail->widths = NULL;
newtail->canvas_item = NULL;
}
}
if (item->type == ITEM_STROKE) {
// it's inside an erasure list - we destroy it
gnome_canvas_points_free(item->path);
+ if (item->brush.variable_width) g_free(item->widths);
if (item->canvas_item != NULL)
gtk_object_destroy(GTK_OBJECT(item->canvas_item));
erasure->nrepl--;
void finalize_erasure(void)
{
GList *itemlist, *partlist;
- struct Item *item, *part;
+ struct Item *item;
prepare_new_undo();
undo->type = ITEM_ERASURE;
return FALSE;
}
+gboolean start_resizesel(GdkEvent *event)
+{
+ double pt[2], resize_margin, hmargin, vmargin;
+
+ if (ui.selection==NULL) return FALSE;
+ if (ui.cur_layer != ui.selection->layer) return FALSE;
+
+ get_pointer_coords(event, pt);
+
+ if (ui.selection->type == ITEM_SELECTRECT) {
+ resize_margin = RESIZE_MARGIN/ui.zoom;
+ hmargin = (ui.selection->bbox.right-ui.selection->bbox.left)*0.3;
+ if (hmargin>resize_margin) hmargin = resize_margin;
+ vmargin = (ui.selection->bbox.bottom-ui.selection->bbox.top)*0.3;
+ if (vmargin>resize_margin) vmargin = resize_margin;
+
+ // make sure the click is within a box slightly bigger than the selection rectangle
+ if (pt[0]<ui.selection->bbox.left-resize_margin ||
+ pt[0]>ui.selection->bbox.right+resize_margin ||
+ pt[1]<ui.selection->bbox.top-resize_margin ||
+ pt[1]>ui.selection->bbox.bottom+resize_margin)
+ return FALSE;
+
+ // now, if the click is near the edge, it's a resize operation
+ // keep track of which edges we're close to, since those are the ones which should move
+ ui.selection->resizing_left = (pt[0]<ui.selection->bbox.left+hmargin);
+ ui.selection->resizing_right = (pt[0]>ui.selection->bbox.right-hmargin);
+ ui.selection->resizing_top = (pt[1]<ui.selection->bbox.top+vmargin);
+ ui.selection->resizing_bottom = (pt[1]>ui.selection->bbox.bottom-vmargin);
+
+ // we're not near any edge, give up
+ if (!(ui.selection->resizing_left || ui.selection->resizing_right ||
+ ui.selection->resizing_top || ui.selection->resizing_bottom))
+ return FALSE;
+
+ ui.cur_item_type = ITEM_RESIZESEL;
+ ui.selection->new_y1 = ui.selection->bbox.top;
+ ui.selection->new_y2 = ui.selection->bbox.bottom;
+ ui.selection->new_x1 = ui.selection->bbox.left;
+ ui.selection->new_x2 = ui.selection->bbox.right;
+ gnome_canvas_item_set(ui.selection->canvas_item, "dash", NULL, NULL);
+ update_cursor_for_resize(pt);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
void start_vertspace(GdkEvent *event)
{
double pt[2];
}
}
+void continue_resizesel(GdkEvent *event)
+{
+ double pt[2];
+
+ get_pointer_coords(event, pt);
+
+ if (ui.selection->resizing_top) ui.selection->new_y1 = pt[1];
+ if (ui.selection->resizing_bottom) ui.selection->new_y2 = pt[1];
+ if (ui.selection->resizing_left) ui.selection->new_x1 = pt[0];
+ if (ui.selection->resizing_right) ui.selection->new_x2 = pt[0];
+
+ gnome_canvas_item_set(ui.selection->canvas_item,
+ "x1", ui.selection->new_x1, "x2", ui.selection->new_x2,
+ "y1", ui.selection->new_y1, "y2", ui.selection->new_y2, NULL);
+}
+
void finalize_movesel(void)
{
GList *list, *link;
- struct Item *item;
if (ui.selection->items != NULL) {
prepare_new_undo();
ui.selection->bbox.top += undo->val_y;
ui.selection->bbox.bottom += undo->val_y;
make_dashed(ui.selection->canvas_item);
+ /* update selection box object's offset to be trivial, and its internal
+ coordinates to agree with those of the bbox; need this since resize
+ operations will modify the box by setting its coordinates directly */
+ gnome_canvas_item_affine_absolute(ui.selection->canvas_item, NULL);
+ gnome_canvas_item_set(ui.selection->canvas_item,
+ "x1", ui.selection->bbox.left, "x2", ui.selection->bbox.right,
+ "y1", ui.selection->bbox.top, "y2", ui.selection->bbox.bottom, NULL);
}
ui.cur_item_type = ITEM_NONE;
update_cursor();
}
+#define SCALING_EPSILON 0.001
+
+void finalize_resizesel(void)
+{
+ struct Item *item;
+
+ // build the affine transformation
+ double offset_x, offset_y, scaling_x, scaling_y;
+ scaling_x = (ui.selection->new_x2 - ui.selection->new_x1) /
+ (ui.selection->bbox.right - ui.selection->bbox.left);
+ scaling_y = (ui.selection->new_y2 - ui.selection->new_y1) /
+ (ui.selection->bbox.bottom - ui.selection->bbox.top);
+ // couldn't undo a resize-by-zero...
+ if (fabs(scaling_x)<SCALING_EPSILON) scaling_x = SCALING_EPSILON;
+ if (fabs(scaling_y)<SCALING_EPSILON) scaling_y = SCALING_EPSILON;
+ offset_x = ui.selection->new_x1 - ui.selection->bbox.left * scaling_x;
+ offset_y = ui.selection->new_y1 - ui.selection->bbox.top * scaling_y;
+
+ if (ui.selection->items != NULL) {
+ // create the undo information
+ prepare_new_undo();
+ undo->type = ITEM_RESIZESEL;
+ undo->itemlist = g_list_copy(ui.selection->items);
+ undo->auxlist = NULL;
+
+ undo->scaling_x = scaling_x;
+ undo->scaling_y = scaling_y;
+ undo->val_x = offset_x;
+ undo->val_y = offset_y;
+
+ // actually do the resize operation
+ resize_journal_items_by(ui.selection->items, scaling_x, scaling_y, offset_x, offset_y);
+ }
+
+ if (scaling_x>0) {
+ ui.selection->bbox.left = ui.selection->new_x1;
+ ui.selection->bbox.right = ui.selection->new_x2;
+ } else {
+ ui.selection->bbox.left = ui.selection->new_x2;
+ ui.selection->bbox.right = ui.selection->new_x1;
+ }
+ if (scaling_y>0) {
+ ui.selection->bbox.top = ui.selection->new_y1;
+ ui.selection->bbox.bottom = ui.selection->new_y2;
+ } else {
+ ui.selection->bbox.top = ui.selection->new_y2;
+ ui.selection->bbox.bottom = ui.selection->new_y1;
+ }
+ make_dashed(ui.selection->canvas_item);
+
+ ui.cur_item_type = ITEM_NONE;
+ update_cursor();
+}
void selection_delete(void)
{
the forward direction */
}
-void callback_clipboard_get(GtkClipboard *clipboard,
- GtkSelectionData *selection_data,
- guint info, gpointer user_data)
-{
- int length;
-
- g_memmove(&length, user_data, sizeof(int));
- gtk_selection_data_set(selection_data,
- gdk_atom_intern("_XOURNAL", FALSE), 8, user_data, length);
-}
-
-void callback_clipboard_clear(GtkClipboard *clipboard, gpointer user_data)
-{
- g_free(user_data);
-}
-
-void selection_to_clip(void)
-{
- int bufsz, nitems, val;
- char *buf, *p;
- GList *list;
- struct Item *item;
- GtkTargetEntry target;
-
- if (ui.selection == NULL) return;
- bufsz = 2*sizeof(int) // bufsz, nitems
- + sizeof(struct BBox); // bbox
- nitems = 0;
- for (list = ui.selection->items; list != NULL; list = list->next) {
- item = (struct Item *)list->data;
- nitems++;
- if (item->type == ITEM_STROKE) {
- bufsz+= sizeof(int) // type
- + sizeof(struct Brush) // brush
- + sizeof(int) // num_points
- + 2*item->path->num_points*sizeof(double); // the points
- }
- else if (item->type == ITEM_TEXT) {
- bufsz+= sizeof(int) // type
- + sizeof(struct Brush) // brush
- + 2*sizeof(double) // bbox upper-left
- + sizeof(int) // text len
- + strlen(item->text)+1 // text
- + sizeof(int) // font_name len
- + strlen(item->font_name)+1 // font_name
- + sizeof(double); // font_size
- }
- else bufsz+= sizeof(int); // type
- }
- p = buf = g_malloc(bufsz);
- g_memmove(p, &bufsz, sizeof(int)); p+= sizeof(int);
- g_memmove(p, &nitems, sizeof(int)); p+= sizeof(int);
- g_memmove(p, &ui.selection->bbox, sizeof(struct BBox)); p+= sizeof(struct BBox);
- for (list = ui.selection->items; list != NULL; list = list->next) {
- item = (struct Item *)list->data;
- g_memmove(p, &item->type, sizeof(int)); p+= sizeof(int);
- if (item->type == ITEM_STROKE) {
- g_memmove(p, &item->brush, sizeof(struct Brush)); p+= sizeof(struct Brush);
- g_memmove(p, &item->path->num_points, sizeof(int)); p+= sizeof(int);
- g_memmove(p, item->path->coords, 2*item->path->num_points*sizeof(double));
- p+= 2*item->path->num_points*sizeof(double);
- }
- if (item->type == ITEM_TEXT) {
- g_memmove(p, &item->brush, sizeof(struct Brush)); p+= sizeof(struct Brush);
- g_memmove(p, &item->bbox.left, sizeof(double)); p+= sizeof(double);
- g_memmove(p, &item->bbox.top, sizeof(double)); p+= sizeof(double);
- val = strlen(item->text);
- g_memmove(p, &val, sizeof(int)); p+= sizeof(int);
- g_memmove(p, item->text, val+1); p+= val+1;
- val = strlen(item->font_name);
- g_memmove(p, &val, sizeof(int)); p+= sizeof(int);
- g_memmove(p, item->font_name, val+1); p+= val+1;
- g_memmove(p, &item->font_size, sizeof(double)); p+= sizeof(double);
- }
- }
-
- target.target = "_XOURNAL";
- target.flags = 0;
- target.info = 0;
-
- gtk_clipboard_set_with_data(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
- &target, 1,
- callback_clipboard_get, callback_clipboard_clear, buf);
-}
-
-
-void clipboard_paste(void)
-{
- GtkSelectionData *sel_data;
- unsigned char *p;
- int nitems, npts, i, len;
- GList *list;
- struct Item *item;
- double hoffset, voffset, cx, cy;
- double *pf;
- int sx, sy, wx, wy;
-
- if (ui.cur_layer == NULL) return;
-
- ui.cur_item_type = ITEM_PASTE;
- sel_data = gtk_clipboard_wait_for_contents(
- gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
- gdk_atom_intern("_XOURNAL", FALSE));
- ui.cur_item_type = ITEM_NONE;
- if (sel_data == NULL) return; // paste failed
-
- reset_selection();
-
- ui.selection = g_new(struct Selection, 1);
- p = sel_data->data + sizeof(int);
- g_memmove(&nitems, p, sizeof(int)); p+= sizeof(int);
- ui.selection->type = ITEM_SELECTRECT;
- ui.selection->layer = ui.cur_layer;
- g_memmove(&ui.selection->bbox, p, sizeof(struct BBox)); p+= sizeof(struct BBox);
- ui.selection->items = NULL;
-
- // find by how much we translate the pasted selection
- gnome_canvas_get_scroll_offsets(canvas, &sx, &sy);
- gdk_window_get_geometry(GTK_WIDGET(canvas)->window, NULL, NULL, &wx, &wy, NULL);
- gnome_canvas_window_to_world(canvas, sx + wx/2, sy + wy/2, &cx, &cy);
- cx -= ui.cur_page->hoffset;
- cy -= ui.cur_page->voffset;
- if (cx + (ui.selection->bbox.right-ui.selection->bbox.left)/2 > ui.cur_page->width)
- cx = ui.cur_page->width - (ui.selection->bbox.right-ui.selection->bbox.left)/2;
- if (cx - (ui.selection->bbox.right-ui.selection->bbox.left)/2 < 0)
- cx = (ui.selection->bbox.right-ui.selection->bbox.left)/2;
- if (cy + (ui.selection->bbox.bottom-ui.selection->bbox.top)/2 > ui.cur_page->height)
- cy = ui.cur_page->height - (ui.selection->bbox.bottom-ui.selection->bbox.top)/2;
- if (cy - (ui.selection->bbox.bottom-ui.selection->bbox.top)/2 < 0)
- cy = (ui.selection->bbox.bottom-ui.selection->bbox.top)/2;
- hoffset = cx - (ui.selection->bbox.right+ui.selection->bbox.left)/2;
- voffset = cy - (ui.selection->bbox.top+ui.selection->bbox.bottom)/2;
- ui.selection->bbox.left += hoffset;
- ui.selection->bbox.right += hoffset;
- ui.selection->bbox.top += voffset;
- ui.selection->bbox.bottom += voffset;
-
- ui.selection->canvas_item = gnome_canvas_item_new(ui.cur_layer->group,
- gnome_canvas_rect_get_type(), "width-pixels", 1,
- "outline-color-rgba", 0x000000ff,
- "fill-color-rgba", 0x80808040,
- "x1", ui.selection->bbox.left, "x2", ui.selection->bbox.right,
- "y1", ui.selection->bbox.top, "y2", ui.selection->bbox.bottom, NULL);
- make_dashed(ui.selection->canvas_item);
-
- while (nitems-- > 0) {
- item = g_new(struct Item, 1);
- ui.selection->items = g_list_append(ui.selection->items, item);
- ui.cur_layer->items = g_list_append(ui.cur_layer->items, item);
- ui.cur_layer->nitems++;
- g_memmove(&item->type, p, sizeof(int)); p+= sizeof(int);
- if (item->type == ITEM_STROKE) {
- g_memmove(&item->brush, p, sizeof(struct Brush)); p+= sizeof(struct Brush);
- g_memmove(&npts, p, sizeof(int)); p+= sizeof(int);
- item->path = gnome_canvas_points_new(npts);
- pf = (double *)p;
- for (i=0; i<npts; i++) {
- item->path->coords[2*i] = pf[2*i] + hoffset;
- item->path->coords[2*i+1] = pf[2*i+1] + voffset;
- }
- p+= 2*item->path->num_points*sizeof(double);
- update_item_bbox(item);
- make_canvas_item_one(ui.cur_layer->group, item);
- }
- if (item->type == ITEM_TEXT) {
- g_memmove(&item->brush, p, sizeof(struct Brush)); p+= sizeof(struct Brush);
- g_memmove(&item->bbox.left, p, sizeof(double)); p+= sizeof(double);
- g_memmove(&item->bbox.top, p, sizeof(double)); p+= sizeof(double);
- item->bbox.left += hoffset;
- item->bbox.top += voffset;
- g_memmove(&len, p, sizeof(int)); p+= sizeof(int);
- item->text = g_malloc(len+1);
- g_memmove(item->text, p, len+1); p+= len+1;
- g_memmove(&len, p, sizeof(int)); p+= sizeof(int);
- item->font_name = g_malloc(len+1);
- g_memmove(item->font_name, p, len+1); p+= len+1;
- g_memmove(&item->font_size, p, sizeof(double)); p+= sizeof(double);
- make_canvas_item_one(ui.cur_layer->group, item);
- }
- }
-
- prepare_new_undo();
- undo->type = ITEM_PASTE;
- undo->layer = ui.cur_layer;
- undo->itemlist = g_list_copy(ui.selection->items);
-
- gtk_selection_data_free(sel_data);
- update_copy_paste_enabled();
-}
-
// modify the color or thickness of pen strokes in a selection
-void recolor_selection(int color)
+void recolor_selection(int color_no, guint color_rgba)
{
GList *itemlist;
struct Item *item;
struct Brush *brush;
+ GnomeCanvasGroup *group;
if (ui.selection == NULL) return;
prepare_new_undo();
g_memmove(brush, &(item->brush), sizeof(struct Brush));
undo->auxlist = g_list_append(undo->auxlist, brush);
// repaint the stroke
- item->brush.color_no = color;
- item->brush.color_rgba = predef_colors_rgba[color];
- if (item->canvas_item!=NULL)
- gnome_canvas_item_set(item->canvas_item,
- "fill-color-rgba", item->brush.color_rgba, NULL);
+ item->brush.color_no = color_no;
+ item->brush.color_rgba = color_rgba | 0xff; // no alpha
+ if (item->canvas_item!=NULL) {
+ if (!item->brush.variable_width)
+ gnome_canvas_item_set(item->canvas_item,
+ "fill-color-rgba", item->brush.color_rgba, NULL);
+ else {
+ group = (GnomeCanvasGroup *) item->canvas_item->parent;
+ gtk_object_destroy(GTK_OBJECT(item->canvas_item));
+ make_canvas_item_one(group, item);
+ }
+ }
}
}
GList *itemlist;
struct Item *item;
struct Brush *brush;
+ GnomeCanvasGroup *group;
if (ui.selection == NULL) return;
prepare_new_undo();
// repaint the stroke
item->brush.thickness_no = val;
item->brush.thickness = predef_thickness[TOOL_PEN][val];
- if (item->canvas_item!=NULL)
- gnome_canvas_item_set(item->canvas_item,
- "width-units", item->brush.thickness, NULL);
+ if (item->canvas_item!=NULL) {
+ if (!item->brush.variable_width)
+ gnome_canvas_item_set(item->canvas_item,
+ "width-units", item->brush.thickness, NULL);
+ else {
+ group = (GnomeCanvasGroup *) item->canvas_item->parent;
+ gtk_object_destroy(GTK_OBJECT(item->canvas_item));
+ item->brush.variable_width = FALSE;
+ make_canvas_item_one(group, item);
+ }
+ }
}
}
int cx, cy;
get_pointer_coords(event, pt);
+ pt[0] += ui.cur_page->hoffset;
+ pt[1] += ui.cur_page->voffset;
gnome_canvas_get_scroll_offsets(canvas, &cx, &cy);
ui.hand_scrollto_cx = cx - (pt[0]-ui.hand_refpt[0])*ui.zoom;
ui.hand_scrollto_cy = cy - (pt[1]-ui.hand_refpt[1])*ui.zoom;
void start_text(GdkEvent *event, struct Item *item)
{
double pt[2];
- gchar *text;
GtkTextBuffer *buffer;
GnomeCanvasItem *canvas_item;
PangoFontDescription *font_desc;
GdkColor color;
-
+
get_pointer_coords(event, pt);
+
ui.cur_item_type = ITEM_TEXT;
if (item==NULL) {
item->canvas_item = canvas_item;
gtk_widget_show(item->widget);
- gtk_widget_grab_focus(item->widget);
ui.resize_signal_handler =
g_signal_connect((gpointer) winMain, "check_resize",
G_CALLBACK(resize_textview), NULL);
update_font_button();
gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), FALSE);
gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), FALSE);
+ gtk_widget_grab_focus(item->widget);
}
void end_text(void)
GnomeCanvasItem *tmpitem;
if (ui.cur_item_type!=ITEM_TEXT) return; // nothing for us to do!
-
+
// finalize the text that's been edited...
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui.cur_item->widget));
gtk_text_buffer_get_bounds(buffer, &start, &end);
void rescale_text_items(void)
{
GList *pagelist, *layerlist, *itemlist;
- struct Layer *l;
for (pagelist = journal.pages; pagelist!=NULL; pagelist = pagelist->next)
for (layerlist = ((struct Page *)pagelist->data)->layers; layerlist!=NULL; layerlist = layerlist->next)
else *p=0;
}
else size=0.;
- reset_focus();
g_free(ui.font_name);
ui.font_name = str;
if (size>0.) ui.font_size = size;
projects / xournal.git / blobdiff