#include <time.h>
#include <libgnomeprintui/gnome-print-dialog.h>
#include <glib/gstdio.h>
+#include <gdk/gdkkeysyms.h>
#include "xournal.h"
#include "xo-callbacks.h"
#include "xo-file.h"
#include "xo-paint.h"
#include "xo-print.h"
+#include "xo-shapes.h"
void
on_fileNew_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
if (close_journal()) {
new_journal();
- ui.zoom = DEFAULT_ZOOM;
+ ui.zoom = ui.startup_zoom;
update_page_stuff();
gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0);
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
int file_domain;
gboolean success;
+ end_text();
+ reset_focus();
if (!ok_to_close()) return; // user aborted on save confirmation
dialog = gtk_file_chooser_dialog_new("Open PDF", GTK_WINDOW (winMain),
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
+ GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
filt_all = gtk_file_filter_new();
gtk_file_filter_set_name(filt_all, "All files");
filt_pdf = gtk_file_filter_new();
gtk_file_filter_set_name(filt_pdf, "PDF files");
gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
+ gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
+ if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
+
attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return;
}
gtk_main_iteration();
}
new_journal();
- ui.zoom = DEFAULT_ZOOM;
+ ui.zoom = ui.startup_zoom;
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
update_page_stuff();
success = init_bgpdf(filename, TRUE, file_domain);
char *filename;
gboolean success;
+ end_text();
+ reset_focus();
if (!ok_to_close()) return; // user aborted on save confirmation
dialog = gtk_file_chooser_dialog_new("Open Journal", GTK_WINDOW (winMain),
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
+ GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
filt_all = gtk_file_filter_new();
gtk_file_filter_set_name(filt_all, "All files");
gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
-
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
+
+ if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
+
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return;
}
{
GtkWidget *dialog;
+ end_text();
+ reset_focus();
if (ui.filename == NULL) {
on_fileSaveAs_activate(menuitem, user_data);
return;
gboolean warn;
struct stat stat_buf;
+ end_text();
+ reset_focus();
dialog = gtk_file_chooser_dialog_new("Save Journal", GTK_WINDOW (winMain),
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
+ GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
if (ui.filename!=NULL) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
else {
curtime = time(NULL);
strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
+ if (ui.default_path!=NULL)
+ gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
// somehow this doesn't seem to be set by default
- gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
+ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
do {
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return;
}
on_filePrint_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
- GtkWidget *printDialog, *preview;
+ GtkWidget *printDialog;
GnomePrintJob *gpj;
int fromPage, toPage;
int response;
guchar *s;
GnomePrintConfig *config = gnome_print_config_default();
+ end_text();
+ reset_focus();
if (ui.filename!=NULL) {
if (g_str_has_suffix(ui.filename, ".xoj")) {
in_fn = g_strdup(ui.filename);
gpointer user_data)
{
- GtkWidget *dialog;
+ GtkWidget *dialog, *warning_dialog;
GtkFileFilter *filt_all, *filt_pdf;
char *filename, *in_fn;
char stime[30];
time_t curtime;
- GnomePrintJob *gpj;
- GnomePrintConfig *config;
-
+ gboolean warn;
- dialog = gtk_file_chooser_dialog_new("Print to PDF", GTK_WINDOW (winMain),
+ end_text();
+ reset_focus();
+ dialog = gtk_file_chooser_dialog_new("Export to PDF", GTK_WINDOW (winMain),
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
+ GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
if (ui.filename!=NULL) {
if (g_str_has_suffix(ui.filename, ".xoj")) {
} else {
curtime = time(NULL);
strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
+ if (ui.default_path!=NULL)
+ gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
in_fn = NULL;
}
filt_pdf = gtk_file_filter_new();
gtk_file_filter_set_name(filt_pdf, "PDF files");
gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
+ gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
+ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
+ g_free(in_fn);
- // somehow this doesn't seem to be set by default
- gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
+ do {
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
+ gtk_widget_destroy(dialog);
+ return;
+ }
+ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+ warn = g_file_test(filename, G_FILE_TEST_EXISTS);
+ if (warn) {
+ warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
+ GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
+ "Should the file %s be overwritten?", filename);
+ if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
+ warn = FALSE;
+ gtk_widget_destroy(warning_dialog);
+ }
+ } while(warn);
+
+ gtk_widget_destroy(dialog);
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
- g_free(in_fn);
+ set_cursor_busy(TRUE);
+ if (!print_to_pdf(filename)) {
+ set_cursor_busy(FALSE);
+ dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error creating file '%s'", filename);
+ gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
- return;
}
- filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
- g_free(in_fn);
- gtk_widget_destroy(dialog);
-
- config = gnome_print_config_default();
- gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
- gpj = gnome_print_job_new(config);
- gnome_print_job_print_to_file(gpj, filename);
-
- print_job_render(gpj, 0, journal.npages-1);
- gnome_print_config_unref(config);
-
+ set_cursor_busy(FALSE);
g_free(filename);
}
on_fileQuit_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
if (ok_to_close()) gtk_main_quit ();
}
struct Brush tmp_brush;
struct Background *tmp_bg;
double tmp_x, tmp_y;
+ gchar *tmpstr;
+ GnomeCanvasGroup *group;
+ end_text();
+ reset_focus();
if (undo == NULL) return; // nothing to undo!
reset_selection(); // safer
- if (undo->type == ITEM_STROKE) {
+ if (undo->type == ITEM_STROKE || undo->type == ITEM_TEXT) {
// we're keeping the stroke info, but deleting the canvas item
gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
undo->item->canvas_item = NULL;
undo->layer->items = g_list_remove(undo->layer->items, undo->item);
undo->layer->nitems--;
}
- else if (undo->type == ITEM_ERASURE) {
+ else if (undo->type == ITEM_ERASURE || undo->type == ITEM_RECOGNIZER) {
for (list = undo->erasurelist; list!=NULL; list = list->next) {
erasure = (struct UndoErasureData *)list->data;
// delete all the created items
undo->layer->nitems--;
}
// recreate the deleted one
- erasure->item->canvas_item = gnome_canvas_item_new(undo->layer->group,
- gnome_canvas_line_get_type(), "points", erasure->item->path,
- "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
- "fill-color-rgba", erasure->item->brush.color_rgba,
- "width-units", erasure->item->brush.thickness, NULL);
+ make_canvas_item_one(undo->layer->group, erasure->item);
+
undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
erasure->npos);
if (erasure->npos == 0)
else if (undo->type == ITEM_MOVESEL) {
for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
it = (struct Item *)itemlist->data;
- if (it->canvas_item != NULL)
+ if (it->canvas_item != NULL) {
+ if (undo->layer != undo->layer2)
+ gnome_canvas_item_reparent(it->canvas_item, undo->layer->group);
gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
+ }
}
- move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y);
+ move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y,
+ undo->layer2, undo->layer, undo->auxlist);
+ }
+ else if (undo->type == ITEM_RESIZESEL) {
+ resize_journal_items_by(undo->itemlist,
+ 1/undo->scaling_x, 1/undo->scaling_y,
+ -undo->val_x/undo->scaling_x, -undo->val_y/undo->scaling_y);
}
else if (undo->type == ITEM_PASTE) {
for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
(undo->val >= 0) ? undo->val:0);
undo->page->nlayers++;
- for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next) {
- it = (struct Item *)itemlist->data;
- if (it->type == ITEM_STROKE) {
- it->canvas_item = gnome_canvas_item_new(undo->layer->group,
- gnome_canvas_line_get_type(), "points", it->path,
- "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
- "fill-color-rgba", it->brush.color_rgba,
- "width-units", it->brush.thickness, NULL);
- }
- }
+ for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next)
+ make_canvas_item_one(undo->layer->group, (struct Item *)itemlist->data);
+
do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
}
else if (undo->type == ITEM_REPAINTSEL) {
g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
g_memmove(&(it->brush), list->data, sizeof(struct Brush));
g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
- if (it->type == ITEM_STROKE && it->canvas_item != NULL)
+ if (it->type == ITEM_STROKE && it->canvas_item != NULL) {
+ // remark: a variable-width item might have lost its variable-width
+ group = (GnomeCanvasGroup *) it->canvas_item->parent;
+ gtk_object_destroy(GTK_OBJECT(it->canvas_item));
+ make_canvas_item_one(group, it);
+ }
+ if (it->type == ITEM_TEXT && it->canvas_item != NULL)
gnome_canvas_item_set(it->canvas_item,
- "fill-color-rgba", it->brush.color_rgba,
- "width-units", it->brush.thickness, NULL);
+ "fill-color-rgba", it->brush.color_rgba, NULL);
}
}
+ else if (undo->type == ITEM_TEXT_EDIT) {
+ tmpstr = undo->str;
+ undo->str = undo->item->text;
+ undo->item->text = tmpstr;
+ gnome_canvas_item_set(undo->item->canvas_item, "text", tmpstr, NULL);
+ update_item_bbox(undo->item);
+ }
+ else if (undo->type == ITEM_TEXT_ATTRIB) {
+ tmpstr = undo->str;
+ undo->str = undo->item->font_name;
+ undo->item->font_name = tmpstr;
+ tmp_x = undo->val_x;
+ undo->val_x = undo->item->font_size;
+ undo->item->font_size = tmp_x;
+ g_memmove(&tmp_brush, undo->brush, sizeof(struct Brush));
+ g_memmove(undo->brush, &(undo->item->brush), sizeof(struct Brush));
+ g_memmove(&(undo->item->brush), &tmp_brush, sizeof(struct Brush));
+ gnome_canvas_item_set(undo->item->canvas_item,
+ "fill-color-rgba", undo->item->brush.color_rgba, NULL);
+ update_text_item_displayfont(undo->item);
+ update_item_bbox(undo->item);
+ }
// move item from undo to redo stack
u = undo;
struct Background *tmp_bg;
struct Layer *l;
double tmp_x, tmp_y;
+ gchar *tmpstr;
+ GnomeCanvasGroup *group;
+ end_text();
+ reset_focus();
if (redo == NULL) return; // nothing to redo!
reset_selection(); // safer
- if (redo->type == ITEM_STROKE) {
+ if (redo->type == ITEM_STROKE || redo->type == ITEM_TEXT) {
// re-create the canvas_item
- redo->item->canvas_item = gnome_canvas_item_new(redo->layer->group,
- gnome_canvas_line_get_type(), "points", redo->item->path,
- "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
- "fill-color-rgba", redo->item->brush.color_rgba,
- "width-units", redo->item->brush.thickness, NULL);
+ make_canvas_item_one(redo->layer->group, redo->item);
// reinsert the item on its layer
redo->layer->items = g_list_append(redo->layer->items, redo->item);
redo->layer->nitems++;
}
- 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;
target = g_list_find(redo->layer->items, erasure->item);
// re-create all the created items
for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
it = (struct Item *)itemlist->data;
- it->canvas_item = gnome_canvas_item_new(redo->layer->group,
- gnome_canvas_line_get_type(), "points", it->path,
- "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
- "fill-color-rgba", it->brush.color_rgba,
- "width-units", it->brush.thickness, NULL);
+ make_canvas_item_one(redo->layer->group, it);
redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
redo->layer->nitems++;
lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
}
journal.pages = g_list_remove(journal.pages, redo->page);
journal.npages--;
- if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
+ if (ui.pageno > redo->val || ui.pageno == journal.npages) ui.pageno--;
ui.cur_page = NULL;
// so do_switch_page() won't try to remap the layers of the defunct page
do_switch_page(ui.pageno, TRUE, TRUE);
else if (redo->type == ITEM_MOVESEL) {
for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
it = (struct Item *)itemlist->data;
- if (it->canvas_item != NULL)
+ if (it->canvas_item != NULL) {
+ if (redo->layer != redo->layer2)
+ gnome_canvas_item_reparent(it->canvas_item, redo->layer2->group);
gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
+ }
}
- move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y);
+ move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y,
+ redo->layer, redo->layer2, NULL);
+ }
+ else if (redo->type == ITEM_RESIZESEL) {
+ resize_journal_items_by(redo->itemlist,
+ redo->scaling_x, redo->scaling_y, redo->val_x, redo->val_y);
}
else if (redo->type == ITEM_PASTE) {
for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
it = (struct Item *)itemlist->data;
- it->canvas_item = gnome_canvas_item_new(redo->layer->group,
- gnome_canvas_line_get_type(), "points", it->path,
- "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
- "fill-color-rgba", it->brush.color_rgba,
- "width-units", it->brush.thickness, NULL);
+ make_canvas_item_one(redo->layer->group, it);
redo->layer->items = g_list_append(redo->layer->items, it);
redo->layer->nitems++;
}
g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
g_memmove(&(it->brush), list->data, sizeof(struct Brush));
g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
- if (it->type == ITEM_STROKE && it->canvas_item != NULL)
+ if (it->type == ITEM_STROKE && it->canvas_item != NULL) {
+ // remark: a variable-width item might have lost its variable-width
+ group = (GnomeCanvasGroup *) it->canvas_item->parent;
+ gtk_object_destroy(GTK_OBJECT(it->canvas_item));
+ make_canvas_item_one(group, it);
+ }
+ if (it->type == ITEM_TEXT && it->canvas_item != NULL)
gnome_canvas_item_set(it->canvas_item,
- "fill-color-rgba", it->brush.color_rgba,
- "width-units", it->brush.thickness, NULL);
+ "fill-color-rgba", it->brush.color_rgba, NULL);
}
}
+ else if (redo->type == ITEM_TEXT_EDIT) {
+ tmpstr = redo->str;
+ redo->str = redo->item->text;
+ redo->item->text = tmpstr;
+ gnome_canvas_item_set(redo->item->canvas_item, "text", tmpstr, NULL);
+ update_item_bbox(redo->item);
+ }
+ else if (redo->type == ITEM_TEXT_ATTRIB) {
+ tmpstr = redo->str;
+ redo->str = redo->item->font_name;
+ redo->item->font_name = tmpstr;
+ tmp_x = redo->val_x;
+ redo->val_x = redo->item->font_size;
+ redo->item->font_size = tmp_x;
+ g_memmove(&tmp_brush, redo->brush, sizeof(struct Brush));
+ g_memmove(redo->brush, &(redo->item->brush), sizeof(struct Brush));
+ g_memmove(&(redo->item->brush), &tmp_brush, sizeof(struct Brush));
+ gnome_canvas_item_set(redo->item->canvas_item,
+ "fill-color-rgba", redo->item->brush.color_rgba, NULL);
+ update_text_item_displayfont(redo->item);
+ update_item_bbox(redo->item);
+ }
// move item from redo to undo stack
u = redo;
on_editCut_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
selection_to_clip();
selection_delete();
}
on_editCopy_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
selection_to_clip();
}
on_editPaste_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
clipboard_paste();
}
on_editDelete_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
selection_delete();
}
double yscroll;
struct Page *pg;
+ reset_focus();
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
if (ui.view_continuous) return;
ui.view_continuous = TRUE;
GtkAdjustment *v_adj;
double yscroll;
+ reset_focus();
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
if (!ui.view_continuous) return;
ui.view_continuous = FALSE;
on_viewZoomIn_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ reset_focus();
if (ui.zoom > MAX_ZOOM) return;
- ui.zoom *= 1.5;
+ ui.zoom *= ui.zoom_step_factor;
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
+ rescale_text_items();
rescale_bg_pixmaps();
}
on_viewZoomOut_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ reset_focus();
if (ui.zoom < MIN_ZOOM) return;
- ui.zoom /= 1.5;
+ ui.zoom /= ui.zoom_step_factor;
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
+ rescale_text_items();
rescale_bg_pixmaps();
}
on_viewNormalSize_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ reset_focus();
ui.zoom = DEFAULT_ZOOM;
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
+ rescale_text_items();
rescale_bg_pixmaps();
}
on_viewPageWidth_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ reset_focus();
ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
+ rescale_text_items();
rescale_bg_pixmaps();
}
on_viewFirstPage_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
do_switch_page(0, TRUE, FALSE);
}
on_viewPreviousPage_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
if (ui.pageno == 0) return;
do_switch_page(ui.pageno-1, TRUE, FALSE);
}
on_viewNextPage_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
if (ui.pageno == journal.npages-1) { // create a page at end
if (page_ops_forbidden()) return;
on_journalNewPageEnd_activate(menuitem, user_data);
on_viewLastPage_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
do_switch_page(journal.npages-1, TRUE, FALSE);
}
on_viewShowLayer_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
if (ui.layerno == ui.cur_page->nlayers-1) return;
reset_selection();
ui.layerno++;
on_viewHideLayer_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
if (ui.layerno == -1) return;
reset_selection();
gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
{
struct Page *pg;
+ end_text();
+ reset_focus();
if (page_ops_forbidden()) return;
reset_selection();
pg = new_page(ui.cur_page);
{
struct Page *pg;
+ end_text();
+ reset_focus();
if (page_ops_forbidden()) return;
reset_selection();
pg = new_page(ui.cur_page);
{
struct Page *pg;
+ end_text();
+ reset_focus();
if (page_ops_forbidden()) return;
reset_selection();
pg = new_page((struct Page *)g_list_last(journal.pages)->data);
GList *layerlist, *itemlist;
struct Layer *l;
+ end_text();
+ reset_focus();
if (page_ops_forbidden()) return;
if (journal.npages == 1) return;
reset_selection();
{
struct Layer *l;
+ end_text();
+ reset_focus();
reset_selection();
l = g_new(struct Layer, 1);
l->items = NULL;
{
GList *list;
+ end_text();
+ reset_focus();
if (ui.cur_layer == NULL) return;
reset_selection();
prepare_new_undo();
#define STD_SIZE_LETTER_R 3
#define STD_SIZE_CUSTOM 4
-#define UNIT_CM 0
-#define UNIT_IN 1
-#define UNIT_PX 2
-#define UNIT_PT 3
-
-double unit_sizes[4] = {28.346, 72., 1/DEFAULT_ZOOM, 1.};
+double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
gpointer user_data)
{
int i, response;
+ struct Page *pg;
+ GList *pglist;
+ end_text();
+ reset_focus();
papersize_dialog = create_papersizeDialog();
papersize_width = ui.cur_page->width;
papersize_height = ui.cur_page->height;
- papersize_unit = UNIT_CM;
+ papersize_unit = ui.default_unit;
+ unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
// if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
papersize_std = STD_SIZE_CUSTOM;
for (i=0;i<STD_SIZE_CUSTOM;i++)
response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
gtk_widget_destroy(papersize_dialog);
if (response != GTK_RESPONSE_OK) return;
-
- prepare_new_undo();
- undo->type = ITEM_PAPER_RESIZE;
- undo->page = ui.cur_page;
- undo->val_x = ui.cur_page->width;
- undo->val_y = ui.cur_page->height;
-
- if (papersize_width_valid) ui.cur_page->width = papersize_width;
- if (papersize_height_valid) ui.cur_page->height = papersize_height;
- make_page_clipbox(ui.cur_page);
- update_canvas_bg(ui.cur_page);
+ pg = ui.cur_page;
+ for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
+ if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
+ prepare_new_undo();
+ if (ui.bg_apply_all_pages) {
+ if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
+ if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
+ }
+ undo->type = ITEM_PAPER_RESIZE;
+ undo->page = pg;
+ undo->val_x = pg->width;
+ undo->val_y = pg->height;
+ if (papersize_width_valid) pg->width = papersize_width;
+ if (papersize_height_valid) pg->height = papersize_height;
+ make_page_clipbox(pg);
+ update_canvas_bg(pg);
+ if (!ui.bg_apply_all_pages) break;
+ }
do_switch_page(ui.pageno, TRUE, TRUE);
}
on_papercolorWhite_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_papercolor_activate(menuitem, COLOR_WHITE);
}
on_papercolorYellow_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_papercolor_activate(menuitem, COLOR_YELLOW);
}
on_papercolorPink_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_papercolor_activate(menuitem, COLOR_RED);
}
on_papercolorOrange_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_papercolor_activate(menuitem, COLOR_ORANGE);
}
on_papercolorBlue_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_papercolor_activate(menuitem, COLOR_BLUE);
}
on_papercolorGreen_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_papercolor_activate(menuitem, COLOR_GREEN);
}
on_paperstylePlain_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_paperstyle_activate(menuitem, RULING_NONE);
}
on_paperstyleLined_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_paperstyle_activate(menuitem, RULING_LINED);
}
on_paperstyleRuled_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_paperstyle_activate(menuitem, RULING_RULED);
}
on_paperstyleGraph_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
process_paperstyle_activate(menuitem, RULING_GRAPH);
}
char *filename;
gboolean attach;
+ end_text();
+ reset_focus();
dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
-
+ GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
+
filt_all = gtk_file_filter_new();
gtk_file_filter_set_name(filt_all, "All files");
gtk_file_filter_add_pattern(filt_all, "*");
filt_pspdf = gtk_file_filter_new();
gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
+ gtk_file_filter_add_pattern(filt_pspdf, "*.PS");
gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
+ gtk_file_filter_add_pattern(filt_pspdf, "*.PDF");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
+
+ if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return;
}
if (ui.zoom != DEFAULT_ZOOM) {
ui.zoom = DEFAULT_ZOOM;
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
+ rescale_text_items();
rescale_bg_pixmaps();
}
do_switch_page(ui.pageno, TRUE, TRUE);
{
struct Background *bg;
+ end_text();
+ reset_focus();
reset_selection();
gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
gdk_display_sync(gdk_display_get_default());
if (ui.zoom != DEFAULT_ZOOM) {
ui.zoom = DEFAULT_ZOOM;
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
+ rescale_text_items();
rescale_bg_pixmaps();
}
do_switch_page(ui.pageno, TRUE, TRUE);
on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ gboolean active;
+
+ end_text();
+ reset_focus();
+ active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+ if (active == ui.bg_apply_all_pages) return;
+ ui.bg_apply_all_pages = active;
+ update_page_stuff();
+
+/* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
struct Page *page;
GList *pglist;
update_canvas_bg(page);
}
do_switch_page(ui.pageno, TRUE, TRUE);
+*/
+
}
return;
}
- if (ui.toolno == TOOL_PEN) return;
-
+ if (ui.cur_mapping != 0) return;
+ if (ui.toolno[0] == TOOL_PEN) return;
+
+ end_text();
+ reset_focus();
reset_selection();
- ui.toolno = TOOL_PEN;
- ui.ruler = FALSE;
- ui.cur_brush = ui.brushes+TOOL_PEN;
+ ui.toolno[0] = TOOL_PEN;
+ ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
+ ui.cur_brush->ruler = FALSE;
+ ui.cur_brush->recognizer = FALSE;
+ update_mapping_linkings(TOOL_PEN);
update_tool_buttons();
update_tool_menu();
update_color_menu();
return;
}
- if (ui.toolno == TOOL_ERASER) return;
+ if (ui.cur_mapping != 0) return;
+ if (ui.toolno[0] == TOOL_ERASER) return;
+ end_text();
+ reset_focus();
reset_selection();
- ui.toolno = TOOL_ERASER;
- ui.ruler = FALSE;
- ui.cur_brush = ui.brushes+TOOL_ERASER;
+ ui.toolno[0] = TOOL_ERASER;
+ ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
+ update_mapping_linkings(TOOL_ERASER);
update_tool_buttons();
update_tool_menu();
update_color_menu();
return;
}
- if (ui.toolno == TOOL_HIGHLIGHTER) return;
+ if (ui.cur_mapping != 0) return; // not user-generated
+ if (ui.toolno[0] == TOOL_HIGHLIGHTER) return;
+ end_text();
+ reset_focus();
reset_selection();
- ui.toolno = TOOL_HIGHLIGHTER;
- ui.ruler = FALSE;
- ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
+ ui.toolno[0] = TOOL_HIGHLIGHTER;
+ ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
+ ui.cur_brush->ruler = FALSE;
+ ui.cur_brush->recognizer = FALSE;
+ update_mapping_linkings(TOOL_HIGHLIGHTER);
update_tool_buttons();
update_tool_menu();
update_color_menu();
on_toolsText_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
-
+ if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
+ if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
+ return;
+ } else {
+ if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
+ return;
+ }
+
+ if (ui.cur_mapping != 0) return; // not user-generated
+ if (ui.toolno[0] == TOOL_TEXT) return;
+
+ reset_focus();
+ reset_selection();
+ ui.toolno[0] = TOOL_TEXT;
+ ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
+ update_mapping_linkings(-1);
+ update_tool_buttons();
+ update_tool_menu();
+ update_color_menu();
+ update_cursor();
}
return;
}
- if (ui.toolno == TOOL_SELECTRECT) return;
+ if (ui.cur_mapping != 0) return; // not user-generated
+ if (ui.toolno[0] == TOOL_SELECTRECT) return;
- ui.toolno = TOOL_SELECTRECT;
- ui.ruler = FALSE;
+ end_text();
+ reset_focus();
+ ui.toolno[0] = TOOL_SELECTRECT;
+ update_mapping_linkings(-1);
update_tool_buttons();
update_tool_menu();
update_color_menu();
return;
}
- if (ui.toolno == TOOL_VERTSPACE) return;
+ if (ui.cur_mapping != 0) return; // not user-generated
+ if (ui.toolno[0] == TOOL_VERTSPACE) return;
+ end_text();
+ reset_focus();
reset_selection();
- ui.toolno = TOOL_VERTSPACE;
- ui.ruler = FALSE;
+ ui.toolno[0] = TOOL_VERTSPACE;
+ update_mapping_linkings(-1);
update_tool_buttons();
update_tool_menu();
update_color_menu();
gpointer user_data)
{
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
- ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
+ end_text();
+ reset_focus();
+ ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
+ update_mapping_linkings(TOOL_ERASER);
}
gpointer user_data)
{
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
- ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
+ end_text();
+ reset_focus();
+ ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
+ update_mapping_linkings(TOOL_ERASER);
}
gpointer user_data)
{
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
- ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
+ end_text();
+ reset_focus();
+ ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
+ update_mapping_linkings(TOOL_ERASER);
}
on_toolsTextFont_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
-
-}
-
+ GtkWidget *dialog;
+ gchar *str;
+
+ dialog = gtk_font_selection_dialog_new("Select Font");
+ str = make_cur_font_name();
+ gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(dialog), str);
+ g_free(str);
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
+ gtk_widget_destroy(dialog);
+ reset_focus();
+ return;
+ }
+ str = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+ process_font_sel(str);
+}
void
on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ switch_mapping(0);
+ end_text();
+ reset_focus();
reset_selection();
- g_memmove(ui.brushes+TOOL_PEN, ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
- ui.toolno = TOOL_PEN;
- ui.cur_brush = ui.brushes+TOOL_PEN;
+ g_memmove(&(ui.brushes[0][TOOL_PEN]), ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
+ ui.toolno[0] = TOOL_PEN;
+ ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
+ update_mapping_linkings(TOOL_PEN);
update_tool_buttons();
update_tool_menu();
update_pen_props_menu();
on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ switch_mapping(0);
+ end_text();
+ reset_focus();
reset_selection();
- g_memmove(ui.brushes+TOOL_ERASER, ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
- ui.toolno = TOOL_ERASER;
- ui.cur_brush = ui.brushes+TOOL_ERASER;
+ g_memmove(&(ui.brushes[0][TOOL_ERASER]), ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
+ ui.toolno[0] = TOOL_ERASER;
+ ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
+ update_mapping_linkings(TOOL_ERASER);
update_tool_buttons();
update_tool_menu();
update_eraser_props_menu();
on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ switch_mapping(0);
+ end_text();
+ reset_focus();
reset_selection();
- g_memmove(ui.brushes+TOOL_HIGHLIGHTER, ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
- ui.toolno = TOOL_HIGHLIGHTER;
- ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
+ g_memmove(&(ui.brushes[0][TOOL_HIGHLIGHTER]), ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
+ ui.toolno[0] = TOOL_HIGHLIGHTER;
+ ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
+ update_mapping_linkings(TOOL_HIGHLIGHTER);
update_tool_buttons();
update_tool_menu();
update_highlighter_props_menu();
on_toolsDefaultText_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
-
+ switch_mapping(0);
+ if (ui.toolno[0]!=TOOL_TEXT) end_text();
+ reset_focus();
+ reset_selection();
+ ui.toolno[0] = TOOL_TEXT;
+ ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
+ ui.cur_brush->color_no = ui.default_brushes[TOOL_PEN].color_no;
+ ui.cur_brush->color_rgba = ui.default_brushes[TOOL_PEN].color_rgba;
+ g_free(ui.font_name);
+ ui.font_name = g_strdup(ui.default_font_name);
+ ui.font_size = ui.default_font_size;
+ if (ui.cur_item_type == ITEM_TEXT) {
+ refont_text_item(ui.cur_item, ui.font_name, ui.font_size);
+ }
+ update_font_button();
+ update_mapping_linkings(-1);
+ update_tool_buttons();
+ update_tool_menu();
+ update_color_menu();
+ update_cursor();
}
on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
- if (ui.toolno < NUM_STROKE_TOOLS)
- g_memmove(ui.default_brushes+ui.toolno, ui.brushes+ui.toolno, sizeof(struct Brush));
+ struct Item *it;
+
+ if (ui.cur_mapping!=0) return;
+ if (ui.toolno[0] < NUM_STROKE_TOOLS)
+ g_memmove(ui.default_brushes+ui.toolno[0], &(ui.brushes[0][ui.toolno[0]]), sizeof(struct Brush));
+ if (ui.toolno[0] == TOOL_TEXT) {
+ if (ui.cur_item_type == ITEM_TEXT) {
+ g_free(ui.font_name);
+ ui.font_name = g_strdup(ui.cur_item->font_name);
+ ui.font_size = ui.cur_item->font_size;
+ }
+ else if (ui.selection!=NULL && ui.selection->items!=NULL &&
+ ui.selection->items->next==NULL &&
+ (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT) {
+ g_free(ui.font_name);
+ ui.font_name = g_strdup(it->font_name);
+ ui.font_size = it->font_size;
+ }
+ g_free(ui.default_font_name);
+ ui.default_font_name = g_strdup(ui.font_name);
+ ui.default_font_size = ui.font_size;
+ }
+ end_text();
+ reset_focus();
}
on_toolsRuler_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
- gboolean active;
+ gboolean active, current;
if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
else
active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
- if (active == ui.ruler) return;
+ if (ui.cur_mapping != 0) return;
+ current = (ui.toolno[0] == TOOL_PEN || ui.toolno[0] == TOOL_HIGHLIGHTER) && ui.cur_brush->ruler;
+ if (active == current) return;
- if (active && (ui.toolno!=TOOL_PEN && ui.toolno!=TOOL_HIGHLIGHTER)) {
+ end_text();
+ reset_focus();
+ if (ui.toolno[0]!=TOOL_PEN && ui.toolno[0]!=TOOL_HIGHLIGHTER) {
reset_selection();
- ui.toolno = TOOL_PEN;
- ui.cur_brush = ui.brushes+TOOL_PEN;
+ ui.toolno[0] = TOOL_PEN;
+ ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
update_color_menu();
update_tool_buttons();
update_tool_menu();
update_cursor();
}
- ui.ruler = active;
+ ui.cur_brush->ruler = active;
+ if (active) ui.cur_brush->recognizer = FALSE;
+ update_mapping_linkings(ui.toolno[0]);
update_ruler_indicator();
}
void
-on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
+on_toolsReco_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ gboolean active, current;
+
+ if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
+ active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+ else
+ active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
+ if (ui.cur_mapping != 0) return;
+ current = (ui.toolno[0] == TOOL_PEN || ui.toolno[0] == TOOL_HIGHLIGHTER) && ui.cur_brush->recognizer;
+ if (active == current) return;
+
+ end_text();
+ reset_focus();
+ if (ui.toolno[0]!=TOOL_PEN && ui.toolno[0]!=TOOL_HIGHLIGHTER) {
+ reset_selection();
+ ui.toolno[0] = TOOL_PEN;
+ ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
+ update_color_menu();
+ update_tool_buttons();
+ update_tool_menu();
+ update_cursor();
+ }
+
+ ui.cur_brush->recognizer = active;
+ if (active) {
+ ui.cur_brush->ruler = FALSE;
+ reset_recognizer();
+ }
+ update_mapping_linkings(ui.toolno[0]);
+ update_ruler_indicator();
+}
+
+
+void
+on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ end_text();
+ reset_focus();
+ save_config_to_file();
}
GtkWidget *aboutDialog;
GtkLabel *labelTitle;
+ end_text();
+ reset_focus();
aboutDialog = create_aboutDialog ();
labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
gtk_label_set_markup(labelTitle,
on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
- if (ui.toolno < NUM_STROKE_TOOLS) {
- g_memmove(ui.brushes+ui.toolno, ui.default_brushes+ui.toolno, sizeof(struct Brush));
+ if (ui.toolno[0]==TOOL_TEXT) {
+ on_toolsDefaultText_activate(NULL, NULL);
+ return;
+ }
+ end_text();
+ reset_focus();
+ switch_mapping(0);
+ if (ui.toolno[0] < NUM_STROKE_TOOLS) {
+ g_memmove(&(ui.brushes[0][ui.toolno[0]]), ui.default_brushes+ui.toolno[0], sizeof(struct Brush));
+ update_mapping_linkings(ui.toolno[0]);
update_thickness_buttons();
update_color_buttons();
update_color_menu();
- if (ui.toolno == TOOL_PEN) update_pen_props_menu();
- if (ui.toolno == TOOL_ERASER) update_eraser_props_menu();
- if (ui.toolno == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
+ if (ui.toolno[0] == TOOL_PEN) update_pen_props_menu();
+ if (ui.toolno[0] == TOOL_ERASER) update_eraser_props_menu();
+ if (ui.toolno[0] == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
update_cursor();
}
}
on_buttonFine_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
- process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_FINE);
+ if (ui.cur_mapping != 0) return;
+ process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_FINE);
}
on_buttonMedium_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
- process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_MEDIUM);
+ if (ui.cur_mapping != 0) return;
+ process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_MEDIUM);
}
on_buttonThick_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
- process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_THICK);
+ if (ui.cur_mapping != 0) return;
+ process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_THICK);
}
gboolean page_change;
struct Page *tmppage;
GtkWidget *dialog;
-
- if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
- if (event->button > 3) return FALSE; // no painting with the mouse wheel!
+ int mapping;
+ gboolean is_core;
+ struct Item *item;
- if (ui.use_xinput) {
- if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
+ is_core = (event->device == gdk_device_get_core_pointer());
+ if (!ui.use_xinput && !is_core) return FALSE;
+ if (ui.use_xinput && is_core && ui.discard_corepointer) return FALSE;
+ if (event->button > 3) return FALSE; // no painting with the mouse wheel!
+ if (event->type != GDK_BUTTON_PRESS) return FALSE;
+ // double-clicks may have broken axes member (free'd) due to a bug in GDK
+ if (!is_core) {
// re-get the axis values since Synaptics sends bogus ones
gdk_device_get_state(event->device, event->window, event->axes, NULL);
fix_xinput_coords((GdkEvent *)event);
}
- else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
+#ifdef INPUT_DEBUG
+ printf("DEBUG: ButtonDown (%s) (x,y)=(%.2f,%.2f)\n",
+ is_core?"core":"xinput", event->x, event->y);
+#endif
+ if (!finite(event->x) || !finite(event->y)) return FALSE; // Xorg 7.3 bug
- if ((ui.use_xinput && event->device->source == GDK_SOURCE_ERASER) ||
- (ui.emulate_eraser && event->button >= 2)) {
- ui.saved_toolno = ui.toolno;
- ui.saved_ruler = ui.ruler;
- reset_selection();
- ui.toolno = TOOL_ERASER;
- ui.ruler = FALSE;
- ui.cur_brush = ui.brushes + TOOL_ERASER;
- update_tool_buttons();
- update_tool_menu();
- update_color_menu();
- update_cursor();
+ if (ui.cur_item_type == ITEM_TEXT && !is_event_within_textview(event))
+ end_text();
+ if (ui.cur_item_type == ITEM_STROKE && ui.is_corestroke && !is_core &&
+ ui.cur_path.num_points == 1) {
+ // Xorg 7.3+ sent core event before XInput event: fix initial point
+ ui.is_corestroke = FALSE;
+ get_pointer_coords((GdkEvent *)event, ui.cur_path.coords);
}
+ if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
+
+ ui.is_corestroke = is_core;
+
+ if (ui.use_erasertip && event->device->source == GDK_SOURCE_ERASER)
+ mapping = NUM_BUTTONS;
+ else mapping = event->button-1;
// check whether we're in a page
page_change = FALSE;
// can't paint on the background...
if (ui.cur_layer == NULL) {
- if (ui.saved_toolno >=0) {
- ui.toolno = ui.saved_toolno;
- ui.ruler = ui.saved_ruler;
- ui.saved_toolno = -1;
- if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
- update_tool_buttons();
- update_tool_menu();
- update_color_menu();
- update_cursor();
- }
/* warn */
dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
on_viewShowLayer_activate(NULL, NULL);
- return;
+ return FALSE;
}
+
+ // switch mappings if needed
- // process the event
ui.which_mouse_button = event->button;
+ switch_mapping(mapping);
+
+ // in text tool, clicking in a text area edits it
+ if (ui.toolno[mapping] == TOOL_TEXT) {
+ item = click_is_in_text(ui.cur_layer, pt[0], pt[1]);
+ if (item!=NULL) {
+ reset_selection();
+ start_text((GdkEvent *)event, item);
+ return FALSE;
+ }
+ }
+
+ // if this can be a selection move or resize, then it takes precedence over anything else
+ if (start_resizesel((GdkEvent *)event)) return FALSE;
+ if (start_movesel((GdkEvent *)event)) return FALSE;
+
+ if (ui.toolno[mapping] != TOOL_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
+ reset_selection();
+
+ // process the event
- if (ui.toolno == TOOL_PEN || ui.toolno == TOOL_HIGHLIGHTER ||
- (ui.toolno == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
+ if (ui.toolno[mapping] == TOOL_HAND) {
+ ui.cur_item_type = ITEM_HAND;
+ get_pointer_coords((GdkEvent *)event, ui.hand_refpt);
+ ui.hand_refpt[0] += ui.cur_page->hoffset;
+ ui.hand_refpt[1] += ui.cur_page->voffset;
+ }
+ else if (ui.toolno[mapping] == TOOL_PEN || ui.toolno[mapping] == TOOL_HIGHLIGHTER ||
+ (ui.toolno[mapping] == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
create_new_stroke((GdkEvent *)event);
}
- else if (ui.toolno == TOOL_ERASER) {
+ else if (ui.toolno[mapping] == TOOL_ERASER) {
ui.cur_item_type = ITEM_ERASURE;
do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
}
- else if (ui.toolno == TOOL_SELECTRECT) {
- if (!start_movesel((GdkEvent *)event))
- start_selectrect((GdkEvent *)event);
+ else if (ui.toolno[mapping] == TOOL_SELECTRECT) {
+ start_selectrect((GdkEvent *)event);
}
- else if (ui.toolno == TOOL_VERTSPACE) {
+ else if (ui.toolno[mapping] == TOOL_VERTSPACE) {
start_vertspace((GdkEvent *)event);
}
+ else if (ui.toolno[mapping] == TOOL_TEXT) {
+ start_text((GdkEvent *)event, NULL);
+ }
return FALSE;
}
GdkEventButton *event,
gpointer user_data)
{
+ gboolean is_core;
+
if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
if (event->button != ui.which_mouse_button) return FALSE; // ignore
- if (ui.use_xinput) {
- if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
- fix_xinput_coords((GdkEvent *)event);
- }
- else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
+ is_core = (event->device == gdk_device_get_core_pointer());
+ if (!ui.use_xinput && !is_core) return FALSE;
+ if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
+ if (!is_core) fix_xinput_coords((GdkEvent *)event);
- if (ui.saved_toolno >= 0) {
- ui.toolno = ui.saved_toolno;
- ui.ruler = ui.saved_ruler;
- ui.saved_toolno = -1;
- if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
- update_tool_buttons();
- update_tool_menu();
- update_color_menu();
- update_cursor();
- }
-
if (ui.cur_item_type == ITEM_STROKE) {
finalize_stroke();
+ if (ui.cur_brush->recognizer) recognize_patterns();
}
else if (ui.cur_item_type == ITEM_ERASURE) {
finalize_erasure();
else if (ui.cur_item_type == ITEM_SELECTRECT) {
finalize_selectrect();
}
- else if (ui.cur_item_type == ITEM_MOVESEL) {
+ else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
finalize_movesel();
}
-
+ else if (ui.cur_item_type == ITEM_RESIZESEL) {
+ finalize_resizesel();
+ }
+ else if (ui.cur_item_type == ITEM_HAND) {
+ ui.cur_item_type = ITEM_NONE;
+ }
+
+ switch_mapping(0);
return FALSE;
}
GdkEventKey *event,
gpointer user_data)
{
+ // If zoomed-out and in single page mode, switch pages with PgUp/PgDn.
+ if (!ui.view_continuous &&
+ (0.96 * ui.zoom * ui.cur_page->height <
+ GTK_WIDGET(canvas)->allocation.height)) {
+ if (event->keyval == GDK_Page_Down) {
+ end_text();
+ reset_focus();
+ if (ui.pageno == journal.npages-1) { return FALSE; }
+ do_switch_page(ui.pageno+1, TRUE, FALSE);
+ }
+ if (event->keyval == GDK_Page_Up) {
+ end_text();
+ reset_focus();
+ if (ui.pageno == 0) { return FALSE; }
+ do_switch_page(ui.pageno-1, TRUE, FALSE);
+ }
+ }
return FALSE;
}
GdkEventMotion *event,
gpointer user_data)
{
- gboolean looks_wrong;
+ gboolean looks_wrong, is_core;
double pt[2];
-
- if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
- if (ui.use_xinput) {
- if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
- fix_xinput_coords((GdkEvent *)event);
+ /* we don't care about this event unless some operation is in progress;
+ or if there's a selection (then we might want to change the mouse
+ cursor to indicate the possibility of resizing) */
+ if (ui.cur_item_type == ITEM_NONE && ui.selection==NULL) return FALSE;
+
+ is_core = (event->device == gdk_device_get_core_pointer());
+ if (!ui.use_xinput && !is_core) return FALSE;
+ if (!is_core) fix_xinput_coords((GdkEvent *)event);
+ if (!finite(event->x) || !finite(event->y)) return FALSE; // Xorg 7.3 bug
+
+ if (ui.selection!=NULL && ui.cur_item_type == ITEM_NONE) {
+ get_pointer_coords((GdkEvent *)event, pt);
+ update_cursor_for_resize(pt);
+ return FALSE;
}
- else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
+ if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
+ if (!is_core) ui.is_corestroke = FALSE;
+
+#ifdef INPUT_DEBUG
+ printf("DEBUG: MotionNotify (%s) (x,y)=(%.2f,%.2f)\n",
+ is_core?"core":"xinput", event->x, event->y);
+#endif
+
looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
if (looks_wrong) { /* mouse button shouldn't be up... give up */
if (ui.cur_item_type == ITEM_STROKE) {
finalize_stroke();
+ if (ui.cur_brush->recognizer) recognize_patterns();
}
else if (ui.cur_item_type == ITEM_ERASURE) {
finalize_erasure();
else if (ui.cur_item_type == ITEM_SELECTRECT) {
finalize_selectrect();
}
- else if (ui.cur_item_type == ITEM_MOVESEL) {
+ else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
finalize_movesel();
}
+ else if (ui.cur_item_type == ITEM_RESIZESEL) {
+ finalize_resizesel();
+ }
+ switch_mapping(0);
return FALSE;
}
gnome_canvas_item_set(ui.selection->canvas_item,
"x2", pt[0], "y2", pt[1], NULL);
}
- else if (ui.cur_item_type == ITEM_MOVESEL) {
+ else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
continue_movesel((GdkEvent *)event);
}
+ else if (ui.cur_item_type == ITEM_RESIZESEL) {
+ continue_resizesel((GdkEvent *)event);
+ }
+ else if (ui.cur_item_type == ITEM_HAND) {
+ do_hand((GdkEvent *)event);
+ }
return FALSE;
}
if (ui.in_update_page_stuff) return; // avoid a bad retroaction
- gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop focus on us
+ end_text();
+ reset_focus();
val = gtk_combo_box_get_active(combobox);
if (val == -1) return;
GdkEvent *event,
gpointer user_data)
{
+ end_text();
+ reset_focus();
if (ok_to_close()) gtk_main_quit();
return TRUE;
}
on_optionsUseXInput_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ end_text();
+ reset_focus();
ui.allow_xinput = ui.use_xinput =
gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+
+/* Important note: we'd like ONLY the canvas window itself to receive
+ XInput events, while its child window in the GDK hierarchy (also
+ associated to the canvas widget) receives the core events.
+ This way on_canvas_... will get both types of events -- otherwise,
+ the proximity detection code in GDK is broken and we'll lose core
+ events.
+
+ Up to GTK+ 2.10, gtk_widget_set_extension_events() only sets
+ extension events for the widget's main window itself; in GTK+ 2.11
+ also traverses GDK child windows that belong to the widget
+ and sets their extension events too. We want to avoid that.
+ So we use gdk_input_set_extension_events() directly on the canvas.
+*/
+
+/* // this causes GTK+ 2.11 bugs
+ gtk_widget_set_extension_events(GTK_WIDGET (canvas),
+ ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
+*/
+ gdk_input_set_extension_events(GTK_WIDGET(canvas)->window,
+ GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK,
+ ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
+
+ update_mappings_menu();
}
void
ui.pageno--;
tmppage = g_list_nth_data(journal.pages, ui.pageno);
}
- if (need_update) do_switch_page(ui.pageno, FALSE, FALSE);
+ if (need_update) {
+ end_text();
+ do_switch_page(ui.pageno, FALSE, FALSE);
+ }
+ reset_focus();
return;
}
int val;
if (ui.in_update_page_stuff) return; // avoid a bad retroaction
-
- gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop blink-blink text cursor
+
+ end_text();
+ reset_focus();
val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ struct Page *pg;
+ GList *pglist;
+
+ end_text();
+ reset_focus();
reset_selection();
- prepare_new_undo();
- undo->type = ITEM_NEW_BG_RESIZE;
- undo->page = ui.cur_page;
- undo->bg = ui.cur_page->bg;
- undo->val_x = ui.cur_page->width;
- undo->val_y = ui.cur_page->height;
- ui.cur_page->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
- ui.cur_page->width = ui.default_page.width;
- ui.cur_page->height = ui.default_page.height;
- ui.cur_page->bg->canvas_item = undo->bg->canvas_item;
- undo->bg->canvas_item = NULL;
+ pg = ui.cur_page;
+ for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
+ if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
+ prepare_new_undo();
+ if (ui.bg_apply_all_pages) {
+ if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
+ if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
+ }
+ undo->type = ITEM_NEW_BG_RESIZE;
+ undo->page = pg;
+ undo->bg = pg->bg;
+ undo->val_x = pg->width;
+ undo->val_y = pg->height;
+ pg->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
+ pg->width = ui.default_page.width;
+ pg->height = ui.default_page.height;
+ pg->bg->canvas_item = undo->bg->canvas_item;
+ undo->bg->canvas_item = NULL;
- make_page_clipbox(ui.cur_page);
- update_canvas_bg(ui.cur_page);
+ make_page_clipbox(pg);
+ update_canvas_bg(pg);
+ if (!ui.bg_apply_all_pages) break;
+ }
do_switch_page(ui.pageno, TRUE, TRUE);
}
{
if (ui.cur_page->bg->type != BG_SOLID) return;
+ end_text();
+ reset_focus();
prepare_new_undo();
undo->type = ITEM_NEW_DEFAULT_BG;
undo->val_x = ui.default_page.width;
active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
if (active == ui.fullscreen) return;
+ end_text();
+ reset_focus();
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));
- gtk_widget_hide(GET_COMPONENT("menubar"));
- gtk_widget_hide(GET_COMPONENT("hbox1"));
- }
- else {
- gtk_window_unfullscreen(GTK_WINDOW(winMain));
- gtk_widget_show(GET_COMPONENT("menubar"));
- gtk_widget_show(GET_COMPONENT("hbox1"));
- }
+ 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]);
}
void
-on_optionsEmulateEraser_activate (GtkMenuItem *menuitem,
+on_optionsButtonMappings_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
- ui.emulate_eraser =
+ end_text();
+ reset_focus();
+ ui.use_erasertip =
gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+ update_mappings_menu();
}
active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
if (ui.antialias_bg == active) return;
+ end_text();
+ reset_focus();
ui.antialias_bg = active;
rescale_bg_pixmaps();
}
active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
if (ui.progressive_bg == active) return;
+ end_text();
+ reset_focus();
ui.progressive_bg = active;
if (!ui.progressive_bg) rescale_bg_pixmaps();
}
gboolean success;
GtkWidget *dialog;
+ end_text();
+ reset_focus();
if (!ok_to_close()) return; // user aborted on save confirmation
for (which = 0 ; which < MRU_SIZE; which++) {
delete_mru_entry(which);
}
+
+void
+on_button2Pen_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_PEN);
+}
+
+
+void
+on_button2Eraser_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_ERASER);
+}
+
+
+void
+on_button2Highlighter_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_HIGHLIGHTER);
+}
+
+
+void
+on_button2Text_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_TEXT);
+}
+
+
+void
+on_button2SelectRegion_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_SELECTREGION);
+}
+
+
+void
+on_button2SelectRectangle_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_SELECTRECT);
+}
+
+
+void
+on_button2VerticalSpace_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_VERTSPACE);
+}
+
+
+void
+on_button2LinkBrush_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ int i;
+
+ if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
+ end_text();
+ reset_focus();
+ ui.linked_brush[1] = BRUSH_LINKED;
+ for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
+}
+
+
+void
+on_button2CopyBrush_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
+ end_text();
+ reset_focus();
+ if (ui.toolno[1] >= NUM_STROKE_TOOLS) {
+ ui.linked_brush[1] = BRUSH_STATIC;
+ update_mappings_menu_linkings();
+ return;
+ }
+ ui.linked_brush[1] = BRUSH_COPIED;
+ g_memmove(&(ui.brushes[1][ui.toolno[1]]), &(ui.brushes[0][ui.toolno[1]]), sizeof(struct Brush));
+}
+
+
+void
+on_button3Pen_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_PEN);
+}
+
+
+void
+on_button3Eraser_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_ERASER);
+}
+
+
+void
+on_button3Highlighter_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_HIGHLIGHTER);
+}
+
+
+void
+on_button3Text_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_TEXT);
+}
+
+
+void
+on_button3SelectRegion_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_SELECTREGION);
+}
+
+
+void
+on_button3SelectRectangle_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_SELECTRECT);
+}
+
+
+void
+on_button3VerticalSpace_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_VERTSPACE);
+}
+
+
+void
+on_button3LinkBrush_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ int i;
+
+ if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
+ end_text();
+ reset_focus();
+ ui.linked_brush[2] = BRUSH_LINKED;
+ for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
+}
+
+
+void
+on_button3CopyBrush_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
+ end_text();
+ reset_focus();
+ if (ui.toolno[2] >= NUM_STROKE_TOOLS) {
+ ui.linked_brush[2] = BRUSH_STATIC;
+ update_mappings_menu_linkings();
+ return;
+ }
+ ui.linked_brush[2] = BRUSH_COPIED;
+ g_memmove(&(ui.brushes[2][ui.toolno[2]]), &(ui.brushes[0][ui.toolno[2]]), sizeof(struct Brush));
+}
+
+// the set zoom dialog
+
+GtkWidget *zoom_dialog;
+double zoom_percent;
+
+void
+on_viewSetZoom_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ int response;
+ double test_w, test_h;
+ GtkSpinButton *spinZoom;
+
+ end_text();
+ reset_focus();
+ zoom_dialog = create_zoomDialog();
+ zoom_percent = 100*ui.zoom / DEFAULT_ZOOM;
+ spinZoom = GTK_SPIN_BUTTON(g_object_get_data(G_OBJECT(zoom_dialog), "spinZoom"));
+ gtk_spin_button_set_increments(spinZoom, ui.zoom_step_increment, 5*ui.zoom_step_increment);
+ gtk_spin_button_set_value(spinZoom, zoom_percent);
+ test_w = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
+ test_h = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
+ if (zoom_percent > 99.9 && zoom_percent < 100.1)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "radioZoom100")), TRUE);
+ else if (zoom_percent > test_w-0.1 && zoom_percent < test_w+0.1)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "radioZoomWidth")), TRUE);
+ else if (zoom_percent > test_h-0.1 && zoom_percent < test_h+0.1)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "radioZoomHeight")), TRUE);
+ else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
+ gtk_widget_show(zoom_dialog);
+
+ do {
+ response = gtk_dialog_run(GTK_DIALOG(zoom_dialog));
+ if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
+ ui.zoom = DEFAULT_ZOOM*zoom_percent/100;
+ gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
+ rescale_text_items();
+ rescale_bg_pixmaps();
+ }
+ } while (response == GTK_RESPONSE_APPLY);
+
+ gtk_widget_destroy(zoom_dialog);
+}
+
+
+void
+on_spinZoom_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data)
+{
+ double val;
+
+ val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "spinZoom")));
+ if (val<1) return;
+ if (val<10) val=10.;
+ if (val>1500) val=1500.;
+ if (val<zoom_percent-1 || val>zoom_percent+1)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
+ zoom_percent = val;
+}
+
+
+void
+on_radioZoom_toggled (GtkToggleButton *togglebutton,
+ gpointer user_data)
+{
+ // nothing to do
+}
+
+
+void
+on_radioZoom100_toggled (GtkToggleButton *togglebutton,
+ gpointer user_data)
+{
+ if (!gtk_toggle_button_get_active(togglebutton)) return;
+ zoom_percent = 100.;
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
+}
+
+
+void
+on_radioZoomWidth_toggled (GtkToggleButton *togglebutton,
+ gpointer user_data)
+{
+ if (!gtk_toggle_button_get_active(togglebutton)) return;
+ zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
+}
+
+
+void
+on_radioZoomHeight_toggled (GtkToggleButton *togglebutton,
+ gpointer user_data)
+{
+ if (!gtk_toggle_button_get_active(togglebutton)) return;
+ zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
+ G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
+}
+
+
+void
+on_toolsHand_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
+ if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
+ return;
+ } else {
+ if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
+ return;
+ }
+
+ if (ui.cur_mapping != 0) return;
+ if (ui.toolno[0] == TOOL_HAND) return;
+
+ end_text();
+ reset_focus();
+ reset_selection();
+ ui.toolno[0] = TOOL_HAND;
+ update_mapping_linkings(-1);
+ update_tool_buttons();
+ update_tool_menu();
+ update_color_menu();
+ update_cursor();
+}
+
+
+void
+on_button2Hand_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 1, TOOL_HAND);
+}
+
+
+void
+on_button3Hand_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ process_mapping_activate(menuitem, 2, TOOL_HAND);
+}
+
+
+void
+on_optionsPrintRuling_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ end_text();
+ reset_focus();
+ ui.print_ruling = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+}
+
+void
+on_optionsDiscardCore_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ end_text();
+ reset_focus();
+ ui.discard_corepointer =
+ gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+ update_mappings_menu();
+}
+
+void
+on_fontButton_font_set (GtkFontButton *fontbutton,
+ gpointer user_data)
+{
+ gchar *str;
+
+ str = g_strdup(gtk_font_button_get_font_name(fontbutton));
+ process_font_sel(str);
+}
+
+void
+on_optionsLeftHanded_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ end_text();
+ reset_focus();
+ ui.left_handed = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+ gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(GET_COMPONENT("scrolledwindowMain")),
+ ui.left_handed?GTK_CORNER_TOP_RIGHT:GTK_CORNER_TOP_LEFT);
+}
+
+void
+on_optionsShortenMenus_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ gchar *item, *nextptr;
+ GtkWidget *w;
+
+ end_text();
+ reset_focus();
+ ui.shorten_menus = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+
+ /* go over the item list */
+ item = ui.shorten_menu_items;
+ while (*item==' ') item++;
+ while (*item) {
+ nextptr = strchr(item, ' ');
+ if (nextptr!=NULL) *nextptr = 0;
+ // hide or show the item
+ w = GET_COMPONENT(item);
+ if (w != NULL) {
+ if (ui.shorten_menus) gtk_widget_hide(w);
+ else gtk_widget_show(w);
+ }
+ // next item
+ if (nextptr==NULL) break;
+ *nextptr = ' ';
+ item = nextptr;
+ while (*item==' ') item++;
+ }
+
+ // just in case someone tried to unhide stuff they shouldn't be seeing
+ hide_unimplemented();
+ // maybe we should also make sure the drawing area stays visible ?
+}
+
+void
+on_optionsAutoSavePrefs_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ end_text();
+ reset_focus();
+ ui.auto_save_prefs = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+}
+
+void
+on_optionsPressureSensitive_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ int i;
+ end_text();
+ reset_focus();
+ ui.pressure_sensitivity =
+ gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+ for (i=0; i<=NUM_BUTTONS; i++)
+ ui.brushes[i][TOOL_PEN].variable_width = ui.pressure_sensitivity;
+ update_mappings_menu();
+}
+