X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=src%2Fxo-misc.c;h=cf63de78c3e2cfc1c8377f53bd7ac2d4b96f6b32;hb=b471a5e1ffc9ad87400f079679fdf261875d513e;hp=619ab17ca1eac3811b11a6f378b88986c89e6552;hpb=2e5ff0bff41fa53d4941b6f0fe49c8914bf29cbc;p=xournal.git diff --git a/src/xo-misc.c b/src/xo-misc.c index 619ab17..cf63de7 100644 --- a/src/xo-misc.c +++ b/src/xo-misc.c @@ -7,6 +7,7 @@ #include #include #include +#include #include "xournal.h" #include "xo-interface.h" @@ -15,6 +16,7 @@ #include "xo-misc.h" #include "xo-file.h" #include "xo-paint.h" +#include "xo-shapes.h" // some global constants @@ -91,8 +93,15 @@ struct Page *new_page_with_bg(struct Background *bg, double width, double height void realloc_cur_path(int n) { if (n <= ui.cur_path_storage_alloc) return; - ui.cur_path_storage_alloc = n+10; - ui.cur_path.coords = g_realloc(ui.cur_path.coords, 2*(n+10)*sizeof(double)); + ui.cur_path_storage_alloc = n+100; + ui.cur_path.coords = g_realloc(ui.cur_path.coords, 2*(n+100)*sizeof(double)); +} + +void realloc_cur_widths(int n) +{ + if (n <= ui.cur_widths_storage_alloc) return; + ui.cur_widths_storage_alloc = n+100; + ui.cur_widths = g_realloc(ui.cur_widths, (n+100)*sizeof(double)); } // undo utility functions @@ -124,6 +133,7 @@ void clear_redo_stack(void) while (redo!=NULL) { if (redo->type == ITEM_STROKE) { gnome_canvas_points_free(redo->item->path); + if (redo->item->brush.variable_width) g_free(redo->item->widths); g_free(redo->item); /* the strokes are unmapped, so there are no associated canvas items */ } @@ -132,12 +142,13 @@ void clear_redo_stack(void) g_free(redo->item->font_name); g_free(redo->item); } - else if (redo->type == ITEM_ERASURE) { + else if (redo->type == ITEM_ERASURE || redo->type == ITEM_RECOGNIZER) { for (list = redo->erasurelist; list!=NULL; list=list->next) { erasure = (struct UndoErasureData *)list->data; for (repl = erasure->replacement_items; repl!=NULL; repl=repl->next) { it = (struct Item *)repl->data; gnome_canvas_points_free(it->path); + if (it->brush.variable_width) g_free(it->widths); g_free(it); } g_list_free(erasure->replacement_items); @@ -160,10 +171,16 @@ void clear_redo_stack(void) else if (redo->type == ITEM_MOVESEL || redo->type == ITEM_REPAINTSEL) { g_list_free(redo->itemlist); g_list_free(redo->auxlist); } + else if (redo->type == ITEM_RESIZESEL) { + g_list_free(redo->itemlist); + } else if (redo->type == ITEM_PASTE) { for (list = redo->itemlist; list!=NULL; list=list->next) { it = (struct Item *)list->data; - if (it->type == ITEM_STROKE) gnome_canvas_points_free(it->path); + if (it->type == ITEM_STROKE) { + gnome_canvas_points_free(it->path); + if (it->brush.variable_width) g_free(it->widths); + } g_free(it); } g_list_free(redo->itemlist); @@ -192,11 +209,13 @@ void clear_undo_stack(void) while (undo!=NULL) { // for strokes, items are already in the journal, so we don't free them // for erasures, we need to free the dead items - if (undo->type == ITEM_ERASURE) { + if (undo->type == ITEM_ERASURE || undo->type == ITEM_RECOGNIZER) { for (list = undo->erasurelist; list!=NULL; list=list->next) { erasure = (struct UndoErasureData *)list->data; - if (erasure->item->type == ITEM_STROKE) + if (erasure->item->type == ITEM_STROKE) { gnome_canvas_points_free(erasure->item->path); + if (erasure->item->brush.variable_width) g_free(erasure->item->widths); + } if (erasure->item->type == ITEM_TEXT) { g_free(erasure->item->text); g_free(erasure->item->font_name); } g_free(erasure->item); @@ -216,6 +235,9 @@ void clear_undo_stack(void) else if (undo->type == ITEM_MOVESEL || undo->type == ITEM_REPAINTSEL) { g_list_free(undo->itemlist); g_list_free(undo->auxlist); } + else if (undo->type == ITEM_RESIZESEL) { + g_list_free(undo->itemlist); + } else if (undo->type == ITEM_PASTE) { g_list_free(undo->itemlist); } @@ -330,10 +352,9 @@ void get_pointer_coords(GdkEvent *event, gdouble *ret) void fix_xinput_coords(GdkEvent *event) { -#ifdef ENABLE_XINPUT_BUGFIX double *axes, *px, *py, axis_width; GdkDevice *device; - int wx, wy, sx, sy; + int wx, wy, sx, sy, ix, iy; if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) { axes = event->button.axes; @@ -348,22 +369,73 @@ void fix_xinput_coords(GdkEvent *event) device = event->motion.device; } else return; // nothing we know how to do - - gdk_window_get_origin(event->any.window, &wx, &wy); - // somehow, behavior changed starting with GTK+ 2.11.0 - if (!gtk_check_version(2, 11, 0)) sx = sy = 0; - else gnome_canvas_get_scroll_offsets(canvas, &sx, &sy); - - axis_width = device->axes[0].max - device->axes[0].min; - if (axis_width>EPSILON) - *px = (axes[0]/axis_width)*ui.screen_width + sx - wx; - axis_width = device->axes[1].max - device->axes[1].min; - if (axis_width>EPSILON) - *py = (axes[1]/axis_width)*ui.screen_height + sy - wy; + gnome_canvas_get_scroll_offsets(canvas, &sx, &sy); + +#ifdef ENABLE_XINPUT_BUGFIX + // fix broken events with the core pointer's location + if (!finite(axes[0]) || !finite(axes[1]) || (axes[0]==0. && axes[1]==0.)) { + gdk_window_get_pointer(GTK_WIDGET(canvas)->window, &ix, &iy, NULL); + *px = ix + sx; + *py = iy + sy; + } + else { + gdk_window_get_origin(GTK_WIDGET(canvas)->window, &wx, &wy); + axis_width = device->axes[0].max - device->axes[0].min; + if (axis_width>EPSILON) + *px = (axes[0]/axis_width)*ui.screen_width + sx - wx; + axis_width = device->axes[1].max - device->axes[1].min; + if (axis_width>EPSILON) + *py = (axes[1]/axis_width)*ui.screen_height + sy - wy; + } +#else + if (!finite(*px) || !finite(*py) || (*px==0. && *py==0.)) { + gdk_window_get_pointer(GTK_WIDGET(canvas)->window, &ix, &iy, NULL); + *px = ix + sx; + *py = iy + sy; + } + else { + /* with GTK+ 2.16 or earlier, the event comes from the parent gdkwindow + and so needs to be adjusted for scrolling */ + if (gtk_major_version == 2 && gtk_minor_version <= 16) { + *px += sx; + *py += sy; + } + /* with GTK+ 2.17, events come improperly translated, and the event's + GdkWindow isn't even the same for ButtonDown as for MotionNotify... */ + if (gtk_major_version == 2 && gtk_minor_version == 17) { // GTK+ 2.17 issues !! + gdk_window_get_position(GTK_WIDGET(canvas)->window, &wx, &wy); + *px += sx - wx; + *py += sy - wy; + } + } #endif } +double get_pressure_multiplier(GdkEvent *event) +{ + double *axes; + double rawpressure; + GdkDevice *device; + + if (event->type == GDK_MOTION_NOTIFY) { + axes = event->motion.axes; + device = event->motion.device; + } + else { + axes = event->button.axes; + device = event->button.device; + } + + if (device == gdk_device_get_core_pointer() + || device->num_axes <= 2) return 1.0; + + rawpressure = axes[2]/(device->axes[2].max - device->axes[2].min); + if (!finite(rawpressure)) return 1.0; + + return ((1-rawpressure)*ui.width_minimum_multiplier + rawpressure*ui.width_maximum_multiplier); +} + void update_item_bbox(struct Item *item) { int i; @@ -404,15 +476,32 @@ void make_page_clipbox(struct Page *pg) void make_canvas_item_one(GnomeCanvasGroup *group, struct Item *item) { - GnomeCanvasItem *i; PangoFontDescription *font_desc; + GnomeCanvasPoints points; + int j; - if (item->type == ITEM_STROKE) - item->canvas_item = gnome_canvas_item_new(group, - gnome_canvas_line_get_type(), "points", item->path, - "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND, - "fill-color-rgba", item->brush.color_rgba, - "width-units", item->brush.thickness, NULL); + if (item->type == ITEM_STROKE) { + if (!item->brush.variable_width) + item->canvas_item = gnome_canvas_item_new(group, + gnome_canvas_line_get_type(), "points", item->path, + "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND, + "fill-color-rgba", item->brush.color_rgba, + "width-units", item->brush.thickness, NULL); + else { + item->canvas_item = gnome_canvas_item_new(group, + gnome_canvas_group_get_type(), NULL); + points.num_points = 2; + points.ref_count = 1; + for (j = 0; j < item->path->num_points-1; j++) { + points.coords = item->path->coords+2*j; + gnome_canvas_item_new((GnomeCanvasGroup *) item->canvas_item, + gnome_canvas_line_get_type(), "points", &points, + "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND, + "fill-color-rgba", item->brush.color_rgba, + "width-units", item->widths[j], NULL); + } + } + } if (item->type == ITEM_TEXT) { font_desc = pango_font_description_from_string(item->font_name); pango_font_description_set_absolute_size(font_desc, @@ -463,6 +552,7 @@ void update_canvas_bg(struct Page *pg) double *pt; double x, y; int w, h; + gboolean is_well_scaled; if (pg->bg->canvas_item != NULL) gtk_object_destroy(GTK_OBJECT(pg->bg->canvas_item)); @@ -518,44 +608,36 @@ void update_canvas_bg(struct Page *pg) if (pg->bg->type == BG_PIXMAP) { - if (ui.antialias_bg) { - set_cursor_busy(TRUE); - w = (int)floor(pg->width*ui.zoom+0.5); - h = (int)floor(pg->height*ui.zoom+0.5); - if (w == gdk_pixbuf_get_width(pg->bg->pixbuf) && - h == gdk_pixbuf_get_height(pg->bg->pixbuf)) - scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf); - else - scaled_pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf, w, h, GDK_INTERP_BILINEAR); - pg->bg->pixbuf_scale = ui.zoom; - set_cursor_busy(FALSE); - } - else { - scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf); - pg->bg->pixbuf_scale = 0; - } + pg->bg->pixbuf_scale = 0; pg->bg->canvas_item = gnome_canvas_item_new(pg->group, gnome_canvas_pixbuf_get_type(), - "pixbuf", scaled_pix, + "pixbuf", pg->bg->pixbuf, "width", pg->width, "height", pg->height, "width-set", TRUE, "height-set", TRUE, NULL); - gdk_pixbuf_unref(scaled_pix); lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL); } if (pg->bg->type == BG_PDF) { if (pg->bg->pixbuf == NULL) return; - pg->bg->canvas_item = gnome_canvas_item_new(pg->group, - gnome_canvas_pixbuf_get_type(), - "pixbuf", pg->bg->pixbuf, - "width", pg->width, "height", pg->height, - "width-set", TRUE, "height-set", TRUE, - NULL); + is_well_scaled = (fabs(pg->bg->pixel_width - pg->width*ui.zoom) < 2. + && fabs(pg->bg->pixel_height - pg->height*ui.zoom) < 2.); + if (is_well_scaled) + pg->bg->canvas_item = gnome_canvas_item_new(pg->group, + gnome_canvas_pixbuf_get_type(), + "pixbuf", pg->bg->pixbuf, + "width-in-pixels", TRUE, "height-in-pixels", TRUE, + NULL); + else + pg->bg->canvas_item = gnome_canvas_item_new(pg->group, + gnome_canvas_pixbuf_get_type(), + "pixbuf", pg->bg->pixbuf, + "width", pg->width, "height", pg->height, + "width-set", TRUE, "height-set", TRUE, + NULL); lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL); } - } gboolean is_visible(struct Page *pg) @@ -575,35 +657,38 @@ void rescale_bg_pixmaps(void) GList *pglist; struct Page *pg; GdkPixbuf *pix; + gboolean is_well_scaled; + gdouble zoom_to_request; for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) { pg = (struct Page *)pglist->data; // in progressive mode we scale only visible pages if (ui.progressive_bg && !is_visible(pg)) continue; - if (pg->bg->type == BG_PIXMAP && pg->bg->canvas_item!=NULL) { // do the rescaling ourselves - if (ui.antialias_bg) { - if (pg->bg->pixbuf_scale == ui.zoom) continue; - set_cursor_busy(TRUE); - pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf, - (int)floor(pg->width*ui.zoom+0.5), (int)floor(pg->height*ui.zoom+0.5), - GDK_INTERP_BILINEAR); - gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pix, NULL); - gdk_pixbuf_unref(pix); - pg->bg->pixbuf_scale = ui.zoom; - set_cursor_busy(FALSE); - } else - { - g_object_get(G_OBJECT(pg->bg->canvas_item), "pixbuf", &pix, NULL); - if (pix!=pg->bg->pixbuf) - gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pg->bg->pixbuf, NULL); - pg->bg->pixbuf_scale = 0; - } + if (pg->bg->type == BG_PIXMAP && pg->bg->canvas_item!=NULL) { + g_object_get(G_OBJECT(pg->bg->canvas_item), "pixbuf", &pix, NULL); + if (pix!=pg->bg->pixbuf) + gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pg->bg->pixbuf, NULL); + pg->bg->pixbuf_scale = 0; } - if (pg->bg->type == BG_PDF) { // request an asynchronous update - if (pg->bg->pixbuf_scale == ui.zoom) continue; - add_bgpdf_request(pg->bg->file_page_seq, ui.zoom, FALSE); - pg->bg->pixbuf_scale = ui.zoom; + if (pg->bg->type == BG_PDF) { + // make pixmap scale to correct size if current one is wrong + is_well_scaled = (fabs(pg->bg->pixel_width - pg->width*ui.zoom) < 2. + && fabs(pg->bg->pixel_height - pg->height*ui.zoom) < 2.); + if (pg->bg->canvas_item != NULL && !is_well_scaled) { + g_object_get(pg->bg->canvas_item, "width-in-pixels", &is_well_scaled, NULL); + if (is_well_scaled) + gnome_canvas_item_set(pg->bg->canvas_item, + "width", pg->width, "height", pg->height, + "width-in-pixels", FALSE, "height-in-pixels", FALSE, + "width-set", TRUE, "height-set", TRUE, + NULL); + } + // request an asynchronous update to a better pixmap if needed + zoom_to_request = MIN(ui.zoom, MAX_SAFE_RENDER_DPI/72.0); + if (pg->bg->pixbuf_scale == zoom_to_request) continue; + if (add_bgpdf_request(pg->bg->file_page_seq, zoom_to_request)) + pg->bg->pixbuf_scale = zoom_to_request; } } } @@ -643,6 +728,16 @@ void rgb_to_gdkcolor(guint rgba, GdkColor *color) color->blue = ((rgba>>8)&0xff)*0x101; } +guint32 gdkcolor_to_rgba(GdkColor gdkcolor, guint16 alpha) +{ + guint32 rgba = ((gdkcolor.red & 0xff00) << 16) | + ((gdkcolor.green & 0xff00) << 8) | + ((gdkcolor.blue & 0xff00) ) | + ((alpha & 0xff00) >> 8); + + return rgba; +} + // some interface functions void update_thickness_buttons(void) @@ -672,6 +767,9 @@ void update_thickness_buttons(void) void update_color_buttons(void) { + GdkColor gdkcolor; + GtkColorButton *colorbutton; + if (ui.selection!=NULL || (ui.toolno[ui.cur_mapping] != TOOL_PEN && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER && ui.toolno[ui.cur_mapping] != TOOL_TEXT)) { gtk_toggle_tool_button_set_active( @@ -726,6 +824,22 @@ void update_color_buttons(void) gtk_toggle_tool_button_set_active( GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE); } + + colorbutton = GTK_COLOR_BUTTON(GET_COMPONENT("buttonColorChooser")); + if ((ui.toolno[ui.cur_mapping] != TOOL_PEN && + ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER && + ui.toolno[ui.cur_mapping] != TOOL_TEXT)) + gdkcolor.red = gdkcolor.blue = gdkcolor.green = 0; + else rgb_to_gdkcolor(ui.cur_brush->color_rgba, &gdkcolor); + gtk_color_button_set_color(colorbutton, &gdkcolor); + if (ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) { + gtk_color_button_set_alpha(colorbutton, + (ui.cur_brush->color_rgba&0xff)*0x101); + gtk_color_button_set_use_alpha(colorbutton, TRUE); + } else { + gtk_color_button_set_alpha(colorbutton, 0xffff); + gtk_color_button_set_use_alpha(colorbutton, FALSE); + } } void update_tool_buttons(void) @@ -766,7 +880,12 @@ void update_tool_buttons(void) } gtk_toggle_tool_button_set_active( - GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), ui.ruler[ui.cur_mapping]); + GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), + ui.toolno[ui.cur_mapping]ruler); + gtk_toggle_tool_button_set_active( + GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonReco")), + ui.toolno[ui.cur_mapping]recognizer); + update_thickness_buttons(); update_color_buttons(); } @@ -809,15 +928,27 @@ void update_tool_menu(void) } gtk_check_menu_item_set_active( - GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]); + GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), + ui.toolno[0]ruler); + gtk_toggle_tool_button_set_active( + GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonReco")), + ui.toolno[ui.cur_mapping]recognizer); gtk_check_menu_item_set_active( - GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]); + GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), + ui.toolno[0] ui.cur_page->nlayers+1) { @@ -1156,12 +1284,14 @@ void update_page_stuff(void) ui.layerbox_length--; } while (ui.layerbox_length < ui.cur_page->nlayers+1) { - g_snprintf(tmp, 10, "Layer %d", ui.layerbox_length++); + g_snprintf(tmp, 10, _("Layer %d"), ui.layerbox_length++); gtk_combo_box_prepend_text(layerbox, tmp); } gtk_combo_box_set_active(layerbox, ui.cur_page->nlayers-1-ui.layerno); ui.in_update_page_stuff = FALSE; + gtk_container_forall(GTK_CONTAINER(layerbox), unset_flags, (gpointer)GTK_CAN_FOCUS); + // update the paper-style menu radio buttons if (ui.view_continuous) @@ -1199,7 +1329,7 @@ void update_page_stuff(void) break; default: gtk_check_menu_item_set_active( - GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOther")), TRUE); + GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE); break; } switch (ui.cur_page->bg->ruling) { @@ -1272,15 +1402,20 @@ void update_file_name(char *filename) if (ui.filename != NULL) g_free(ui.filename); ui.filename = filename; if (filename == NULL) { - gtk_window_set_title(GTK_WINDOW (winMain), "Xournal"); + gtk_window_set_title(GTK_WINDOW (winMain), _("Xournal")); return; } p = g_utf8_strrchr(filename, -1, '/'); if (p == NULL) p = filename; else p = g_utf8_next_char(p); - g_snprintf(tmp, 100, "Xournal - %s", p); + g_snprintf(tmp, 100, _("Xournal - %s"), p); gtk_window_set_title(GTK_WINDOW (winMain), tmp); new_mru_entry(filename); + + if (filename[0]=='/') { + if (ui.default_path!=NULL) g_free(ui.default_path); + ui.default_path = g_path_get_dirname(filename); + } } void update_undo_redo_enabled(void) @@ -1310,9 +1445,6 @@ void update_mapping_linkings(int toolno) if (ui.linked_brush[i] == BRUSH_LINKED) { if (toolno >= 0 && toolno < NUM_STROKE_TOOLS) g_memmove(&(ui.brushes[i][toolno]), &(ui.brushes[0][toolno]), sizeof(struct Brush)); - ui.ruler[i] = ui.ruler[0]; - if (ui.toolno[i]!=TOOL_PEN && ui.toolno[i]!=TOOL_HIGHLIGHTER) - ui.ruler[i] = FALSE; } if (ui.linked_brush[i] == BRUSH_COPIED && toolno == ui.toolno[i]) { ui.linked_brush[i] = BRUSH_STATIC; @@ -1321,14 +1453,22 @@ void update_mapping_linkings(int toolno) } } -void set_cur_color(int color) +void set_cur_color(int color_no, guint color_rgba) { - ui.cur_brush->color_no = color; - if (ui.toolno[0] == TOOL_HIGHLIGHTER) - ui.cur_brush->color_rgba = predef_colors_rgba[color] & ui.hiliter_alpha_mask; + int which_mapping, tool; + + if (ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) tool = TOOL_HIGHLIGHTER; + else tool = TOOL_PEN; + if (ui.cur_mapping>0 && ui.linked_brush[ui.cur_mapping]!=BRUSH_LINKED) + which_mapping = ui.cur_mapping; + else which_mapping = 0; + + ui.brushes[which_mapping][tool].color_no = color_no; + if (tool == TOOL_HIGHLIGHTER && (color_rgba & 0xff) == 0xff) + ui.brushes[which_mapping][tool].color_rgba = color_rgba & ui.hiliter_alpha_mask; else - ui.cur_brush->color_rgba = predef_colors_rgba[color]; - update_mapping_linkings(ui.toolno[0]); + ui.brushes[which_mapping][tool].color_rgba = color_rgba; + update_mapping_linkings(tool); } void recolor_temp_text(int color_no, guint color_rgba) @@ -1351,39 +1491,40 @@ void recolor_temp_text(int color_no, guint color_rgba) gtk_widget_grab_focus(ui.cur_item->widget); } -void process_color_activate(GtkMenuItem *menuitem, int color) +void process_color_activate(GtkMenuItem *menuitem, int color_no, guint color_rgba) { if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) { if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return; - } else { + } + else if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_TOOL_BUTTON) { if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem))) return; } - if (ui.cur_mapping != 0) return; // not user-generated - reset_focus(); + if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated if (ui.cur_item_type == ITEM_TEXT) - recolor_temp_text(color, predef_colors_rgba[color]); + recolor_temp_text(color_no, color_rgba); if (ui.selection != NULL) { - recolor_selection(color); + recolor_selection(color_no, color_rgba); update_color_buttons(); update_color_menu(); } - if (ui.toolno[0] != TOOL_PEN && ui.toolno[0] != TOOL_HIGHLIGHTER - && ui.toolno[0] != TOOL_TEXT) { + if (ui.toolno[ui.cur_mapping] != TOOL_PEN && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER + && ui.toolno[ui.cur_mapping] != TOOL_TEXT) { if (ui.selection != NULL) return; + ui.cur_mapping = 0; end_text(); - ui.toolno[0] = TOOL_PEN; - ui.cur_brush = &(ui.brushes[0][TOOL_PEN]); + ui.toolno[ui.cur_mapping] = TOOL_PEN; + ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]); update_tool_buttons(); update_tool_menu(); } - set_cur_color(color); + set_cur_color(color_no, color_rgba); update_color_buttons(); update_color_menu(); update_cursor(); @@ -1391,6 +1532,8 @@ void process_color_activate(GtkMenuItem *menuitem, int color) void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val) { + int which_mapping; + if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) { if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return; @@ -1399,10 +1542,9 @@ void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val) return; } - if (ui.cur_mapping != 0) return; // not user-generated + if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated if (ui.selection != NULL && GTK_OBJECT_TYPE(menuitem) != GTK_TYPE_RADIO_MENU_ITEM) { - reset_focus(); rethicken_selection(val); update_thickness_buttons(); } @@ -1412,11 +1554,13 @@ void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val) return; } - if (ui.brushes[0][tool].thickness_no == val) return; - reset_focus(); + if (ui.cur_mapping>0 && ui.linked_brush[ui.cur_mapping]!=BRUSH_LINKED) + which_mapping = ui.cur_mapping; + else which_mapping = 0; + if (ui.brushes[which_mapping][tool].thickness_no == val) return; end_text(); - ui.brushes[0][tool].thickness_no = val; - ui.brushes[0][tool].thickness = predef_thickness[tool][val]; + ui.brushes[which_mapping][tool].thickness_no = val; + ui.brushes[which_mapping][tool].thickness = predef_thickness[tool][val]; update_mapping_linkings(tool); update_thickness_buttons(); @@ -1426,16 +1570,18 @@ void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val) update_cursor(); } -void process_papercolor_activate(GtkMenuItem *menuitem, int color) +void process_papercolor_activate(GtkMenuItem *menuitem, int color, guint rgba) { struct Page *pg; GList *pglist; gboolean hasdone; - if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) - return; + if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) { + if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) + return; + } - if ((ui.cur_page->bg->type != BG_SOLID) || ui.bg_apply_all_pages) + if ((ui.cur_page->bg->type != BG_SOLID) || ui.bg_apply_all_pages || color == COLOR_OTHER) gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE); @@ -1443,7 +1589,7 @@ void process_papercolor_activate(GtkMenuItem *menuitem, int color) hasdone = FALSE; for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) { if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data; - if (pg->bg->type == BG_SOLID && pg->bg->color_no != color) { + if (pg->bg->type == BG_SOLID && pg->bg->color_rgba != rgba) { prepare_new_undo(); if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO; undo->multiop |= MULTIOP_CONT_REDO; @@ -1454,7 +1600,7 @@ void process_papercolor_activate(GtkMenuItem *menuitem, int color) undo->bg->canvas_item = NULL; pg->bg->color_no = color; - pg->bg->color_rgba = predef_bgcolors_rgba[color]; + pg->bg->color_rgba = rgba; update_canvas_bg(pg); } if (!ui.bg_apply_all_pages) break; @@ -1511,12 +1657,11 @@ gboolean ok_to_close(void) { GtkWidget *dialog; GtkResponseType response; - GList *pagelist; if (ui.saved) return TRUE; dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT, - GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Save changes to '%s'?", - (ui.filename!=NULL) ? ui.filename:"Untitled"); + GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, _("Save changes to '%s'?"), + (ui.filename!=NULL) ? ui.filename:_("Untitled")); gtk_dialog_add_button(GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); response = gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy(dialog); @@ -1529,13 +1674,8 @@ gboolean ok_to_close(void) return TRUE; } -// test if we're still busy loading a PDF background file -gboolean page_ops_forbidden(void) -{ - return (bgpdf.status != STATUS_NOT_INIT && bgpdf.create_pages); -} - // send the focus back to the appropriate widget + void reset_focus(void) { if (ui.cur_item_type == ITEM_TEXT) @@ -1559,6 +1699,7 @@ void reset_selection(void) update_thickness_buttons(); update_color_buttons(); update_font_button(); + update_cursor(); } void move_journal_items_by(GList *itemlist, double dx, double dy, @@ -1609,10 +1750,70 @@ void move_journal_items_by(GList *itemlist, double dx, double dy, } } +void resize_journal_items_by(GList *itemlist, double scaling_x, double scaling_y, + double offset_x, double offset_y) +{ + struct Item *item; + GList *list; + double mean_scaling, temp; + double *pt, *wid; + GnomeCanvasGroup *group; + int i; + + /* geometric mean of x and y scalings = rescaling for stroke widths + and for text font sizes */ + mean_scaling = sqrt(fabs(scaling_x * scaling_y)); + + for (list = itemlist; list != NULL; list = list->next) { + item = (struct Item *)list->data; + if (item->type == ITEM_STROKE) { + item->brush.thickness = item->brush.thickness * mean_scaling; + for (i=0, pt=item->path->coords; ipath->num_points; i++, pt+=2) { + pt[0] = pt[0]*scaling_x + offset_x; + pt[1] = pt[1]*scaling_y + offset_y; + } + if (item->brush.variable_width) + for (i=0, wid=item->widths; ipath->num_points-1; i++, wid++) + *wid = *wid * mean_scaling; + + item->bbox.left = item->bbox.left*scaling_x + offset_x; + item->bbox.right = item->bbox.right*scaling_x + offset_x; + item->bbox.top = item->bbox.top*scaling_y + offset_y; + item->bbox.bottom = item->bbox.bottom*scaling_y + offset_y; + if (item->bbox.left > item->bbox.right) { + temp = item->bbox.left; + item->bbox.left = item->bbox.right; + item->bbox.right = temp; + } + if (item->bbox.top > item->bbox.bottom) { + temp = item->bbox.top; + item->bbox.top = item->bbox.bottom; + item->bbox.bottom = temp; + } + } + if (item->type == ITEM_TEXT) { + /* must scale about NW corner -- all other points of the text box + are font- and zoom-dependent, so scaling about center of text box + couldn't be undone properly. FIXME? */ + item->font_size *= mean_scaling; + item->bbox.left = item->bbox.left*scaling_x + offset_x; + item->bbox.top = item->bbox.top*scaling_y + offset_y; + } + // redraw the item + if (item->canvas_item!=NULL) { + group = (GnomeCanvasGroup *) item->canvas_item->parent; + gtk_object_destroy(GTK_OBJECT(item->canvas_item)); + make_canvas_item_one(group, item); + } + } +} + // Switch between button mappings /* NOTE ABOUT BUTTON MAPPINGS: ui.cur_mapping is 0 except while a canvas - click event is being processed ... */ + click event is being processed ... or if ui.button_switch_mapping is + enabled and mappings are switched (but even then, canvas should have + a pointer grab from the initial click that switched the mapping) */ void switch_mapping(int m) { @@ -1623,6 +1824,8 @@ void switch_mapping(int m) ui.cur_brush = &(ui.brushes[m][ui.toolno[m]]); if (ui.toolno[m] == TOOL_TEXT) ui.cur_brush = &(ui.brushes[m][TOOL_PEN]); + if (m==0) ui.which_unswitch_button = 0; + update_tool_buttons(); update_color_menu(); update_cursor(); @@ -1631,16 +1834,12 @@ void switch_mapping(int m) void process_mapping_activate(GtkMenuItem *menuitem, int m, int tool) { if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return; - if (ui.cur_mapping!=0) return; + if (ui.cur_mapping!=0 && !ui.button_switch_mapping) return; if (ui.toolno[m] == tool) return; + switch_mapping(0); end_text(); - reset_focus(); ui.toolno[m] = tool; - ui.ruler[m] = FALSE; - if (ui.linked_brush[m] == BRUSH_LINKED - && (tool==TOOL_PEN || tool==TOOL_HIGHLIGHTER)) - ui.ruler[m] = ui.ruler[0]; if (ui.linked_brush[m] == BRUSH_COPIED) { ui.linked_brush[m] = BRUSH_STATIC; update_mappings_menu_linkings(); @@ -1702,6 +1901,15 @@ gboolean can_accel(GtkWidget *widget, guint id, gpointer data) return GTK_WIDGET_SENSITIVE(widget); } +gboolean can_accel_except_text(GtkWidget *widget, guint id, gpointer data) +{ + if (ui.cur_item_type == ITEM_TEXT) { + g_signal_stop_emission_by_name(widget, "can-activate-accel"); + return FALSE; + } + return GTK_WIDGET_SENSITIVE(widget); +} + void allow_all_accels(void) { g_signal_connect((gpointer) GET_COMPONENT("fileNew"), @@ -1741,9 +1949,9 @@ void allow_all_accels(void) g_signal_connect((gpointer) GET_COMPONENT("viewFirstPage"), "can-activate-accel", G_CALLBACK(can_accel), NULL); g_signal_connect((gpointer) GET_COMPONENT("viewPreviousPage"), - "can-activate-accel", G_CALLBACK(can_accel), NULL); + "can-activate-accel", G_CALLBACK(can_accel_except_text), NULL); g_signal_connect((gpointer) GET_COMPONENT("viewNextPage"), - "can-activate-accel", G_CALLBACK(can_accel), NULL); + "can-activate-accel", G_CALLBACK(can_accel_except_text), NULL); g_signal_connect((gpointer) GET_COMPONENT("viewLastPage"), "can-activate-accel", G_CALLBACK(can_accel), NULL); g_signal_connect((gpointer) GET_COMPONENT("toolsPen"), @@ -1766,6 +1974,8 @@ void allow_all_accels(void) "can-activate-accel", G_CALLBACK(can_accel), NULL); g_signal_connect((gpointer) GET_COMPONENT("toolsRuler"), "can-activate-accel", G_CALLBACK(can_accel), NULL); + g_signal_connect((gpointer) GET_COMPONENT("toolsReco"), + "can-activate-accel", G_CALLBACK(can_accel), NULL); } void add_scroll_bindings(void) @@ -1810,3 +2020,159 @@ gboolean is_event_within_textview(GdkEventButton *event) if (pt[1]bbox.top || pt[1]>ui.cur_item->bbox.bottom) return FALSE; return TRUE; } + +void hide_unimplemented(void) +{ + gtk_widget_hide(GET_COMPONENT("filePrintOptions")); + gtk_widget_hide(GET_COMPONENT("journalFlatten")); + gtk_widget_hide(GET_COMPONENT("toolsSelectRegion")); + gtk_widget_hide(GET_COMPONENT("buttonSelectRegion")); + gtk_widget_hide(GET_COMPONENT("button2SelectRegion")); + gtk_widget_hide(GET_COMPONENT("button3SelectRegion")); + gtk_widget_hide(GET_COMPONENT("helpIndex")); + + /* config file only works with glib 2.6 and beyond */ + if (glib_minor_version<6) { + gtk_widget_hide(GET_COMPONENT("optionsAutoSavePrefs")); + gtk_widget_hide(GET_COMPONENT("optionsSavePreferences")); + } + /* gtkprint only works with gtk+ 2.10 and beyond */ + if (gtk_check_version(2, 10, 0)) { + gtk_widget_hide(GET_COMPONENT("filePrint")); + } +} + +// toggle fullscreen mode +void do_fullscreen(gboolean active) +{ + end_text(); + ui.fullscreen = active; + gtk_check_menu_item_set_active( + GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen); + gtk_toggle_tool_button_set_active( + GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen); + + if (ui.fullscreen) gtk_window_fullscreen(GTK_WINDOW(winMain)); + else gtk_window_unfullscreen(GTK_WINDOW(winMain)); + + update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]); +} + +/* attempt to work around GTK+ 2.16/2.17 bugs where random interface + elements receive XInput events that they can't handle properly */ + +// prevent interface items from getting bogus XInput events + +gboolean filter_extended_events (GtkWidget *widget, GdkEvent *event, + gpointer user_data) +{ + if (event->type == GDK_MOTION_NOTIFY && + event->motion.device != gdk_device_get_core_pointer()) + return TRUE; + if ((event->type == GDK_BUTTON_PRESS || event->type == GDK_2BUTTON_PRESS || + event->type == GDK_3BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) && + event->button.device != gdk_device_get_core_pointer()) + return TRUE; + return FALSE; +} + +/* Code to turn an extended input event into a core event and send it to + a different GdkWindow -- e.g. could be used when a click in a text edit box + gets sent to the canvas instead due to incorrect event translation. + We now turn off xinput altogether while editing text under GTK+ 2.17, so + this isn't needed any more... but could become useful again someday! +*/ + +/* +gboolean fix_extended_events (GtkWidget *widget, GdkEvent *event, + gpointer user_data) +{ + int ix, iy; + GdkWindow *window; + + if (user_data) window = (GdkWindow *)user_data; + else window = widget->window; + + if (event->type == GDK_MOTION_NOTIFY && + event->motion.device != gdk_device_get_core_pointer()) { +// printf("fixing motion\n"); + gdk_window_get_pointer(window, &ix, &iy, NULL); + event->motion.x = ix; event->motion.y = iy; + event->motion.device = gdk_device_get_core_pointer(); + g_object_unref(event->motion.window); + event->motion.window = g_object_ref(window); + gtk_widget_event(widget, event); + return TRUE; + } + if ((event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) && + event->button.device != gdk_device_get_core_pointer()) { +// printf("fixing button from pos = %f, %f\n", event->button.x, event->button.y); + gdk_window_get_pointer(window, &ix, &iy, NULL); + event->button.x = ix; event->button.y = iy; + event->button.device = gdk_device_get_core_pointer(); + g_object_unref(event->button.window); + event->button.window = g_object_ref(window); +// printf("fixing button to pos = %f, %f\n", event->button.x, event->button.y); + gtk_widget_event(widget, event); + return TRUE; + } + return FALSE; +} +*/ + + +/* When enter is pressed into page spinbox, send focus back to canvas. */ + +gboolean handle_activate_signal(GtkWidget *widget, gpointer user_data) +{ + reset_focus(); + return FALSE; +} + +/* recursively unset widget flags */ + +void unset_flags(GtkWidget *w, gpointer flag) +{ + GTK_WIDGET_UNSET_FLAGS(w, (GtkWidgetFlags)flag); + if(GTK_IS_CONTAINER(w)) + gtk_container_forall(GTK_CONTAINER(w), unset_flags, flag); +} + +/* reset focus when a key or button press event reaches someone, or when the + page-number spin button should relinquish control... */ + +gboolean intercept_activate_events(GtkWidget *w, GdkEvent *ev, gpointer data) +{ + if (w == GET_COMPONENT("hbox1")) { + /* the event won't be processed since the hbox1 doesn't know what to do with it, + so we might as well kill it and avoid confusing ourselves when it gets + propagated further ... */ + return TRUE; + } + if (w == GET_COMPONENT("spinPageNo")) { + /* we let the spin button take care of itself, and don't steal its focus, + unless the user presses Esc or Tab (in those cases we intervene) */ + if (ev->type != GDK_KEY_PRESS) return FALSE; + if (ev->key.keyval == GDK_Escape) + gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), ui.pageno+1); // abort + else if (ev->key.keyval != GDK_Tab && ev->key.keyval != GDK_ISO_Left_Tab) + return FALSE; // let the spin button process it + } + + // otherwise, we want to make sure the canvas or text item gets focus back... + reset_focus(); + return FALSE; +} + +void install_focus_hooks(GtkWidget *w, gpointer data) +{ + if (w == NULL) return; + g_signal_connect(w, "key-press-event", G_CALLBACK(intercept_activate_events), data); + g_signal_connect(w, "button-press-event", G_CALLBACK(intercept_activate_events), data); + if (GTK_IS_MENU_ITEM(w)) { + g_signal_connect(w, "activate", G_CALLBACK(intercept_activate_events), data); + install_focus_hooks(gtk_menu_item_get_submenu(GTK_MENU_ITEM(w)), data); + } + if(GTK_IS_CONTAINER(w)) + gtk_container_forall(GTK_CONTAINER(w), install_focus_hooks, data); +}