GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
if (ui.filename!=NULL) {
- if (ui.filename[0] == '/')
- gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
- else
- gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), ui.filename);
- } else {
+ gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
+ gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
+ }
+ else
+ if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
+ && bgpdf.filename != NULL) {
+ filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
+ gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
+ gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
+ g_free(filename);
+ }
+ else {
curtime = time(NULL);
strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
case GNOME_PRINT_RANGE_RANGE:
gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
+ fromPage--;
+ toPage--;
break;
default:
fromPage = 0;
}
else
in_fn = g_strdup_printf("%s.pdf", ui.filename);
- if (in_fn[0] == '/')
- gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
- gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), in_fn);
+ gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
+ gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
} else {
curtime = time(NULL);
strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
GList *list, *itemlist;
struct UndoErasureData *erasure;
struct Item *it;
+ struct Brush tmp_brush;
struct Background *tmp_bg;
double tmp_x, tmp_y;
make_page_clipbox(undo->page);
}
update_canvas_bg(undo->page);
- do_switch_page(g_list_index(journal.pages, undo->page), TRUE);
+ do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
}
else if (undo->type == ITEM_NEW_DEFAULT_BG) {
tmp_bg = ui.default_page.bg;
// so do_switch_page() won't try to remap the layers of the defunct page
if (ui.pageno >= undo->val) ui.pageno--;
if (ui.pageno < 0) ui.pageno = 0;
- do_switch_page(ui.pageno, TRUE);
+ do_switch_page(ui.pageno, TRUE, TRUE);
}
else if (undo->type == ITEM_DELETE_PAGE) {
journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
journal.npages++;
make_canvas_items(); // re-create the canvas items
- do_switch_page(undo->val, TRUE);
+ do_switch_page(undo->val, TRUE, TRUE);
}
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_PASTE) {
for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
undo->layer->group = NULL;
undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
undo->page->nlayers--;
- do_switch_page(ui.pageno, FALSE); // don't stay with bad cur_layer info
+ do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
}
else if (undo->type == ITEM_DELETE_LAYER) {
// special case of -1: deleted the last layer, created a new one
"width-units", it->brush.thickness, NULL);
}
}
- do_switch_page(ui.pageno, FALSE); // show the restored layer & others...
+ do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
+ }
+ else if (undo->type == ITEM_REPAINTSEL) {
+ for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
+ itemlist = itemlist->next, list = list->next) {
+ it = (struct Item *)itemlist->data;
+ 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)
+ gnome_canvas_item_set(it->canvas_item,
+ "fill-color-rgba", it->brush.color_rgba,
+ "width-units", it->brush.thickness, NULL);
+ }
}
// move item from undo to redo stack
GList *list, *itemlist, *target;
struct UndoErasureData *erasure;
struct Item *it;
+ struct Brush tmp_brush;
struct Background *tmp_bg;
struct Layer *l;
double tmp_x, tmp_y;
make_page_clipbox(redo->page);
}
update_canvas_bg(redo->page);
- do_switch_page(g_list_index(journal.pages, redo->page), TRUE);
+ do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
}
else if (redo->type == ITEM_NEW_DEFAULT_BG) {
tmp_bg = ui.default_page.bg;
journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
journal.npages++;
- do_switch_page(redo->val, TRUE);
+ do_switch_page(redo->val, TRUE, TRUE);
}
else if (redo->type == ITEM_DELETE_PAGE) {
// unmap all the canvas items
if (ui.pageno > undo->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);
+ 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_PASTE) {
for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
redo->page->bg->canvas_item);
redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
redo->page->nlayers++;
- do_switch_page(ui.pageno, FALSE);
+ do_switch_page(ui.pageno, FALSE, FALSE);
}
else if (redo->type == ITEM_DELETE_LAYER) {
gtk_object_destroy(GTK_OBJECT(redo->layer->group));
redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
redo->page->nlayers++;
}
- do_switch_page(ui.pageno, FALSE);
+ do_switch_page(ui.pageno, FALSE, FALSE);
+ }
+ else if (redo->type == ITEM_REPAINTSEL) {
+ for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
+ itemlist = itemlist->next, list = list->next) {
+ it = (struct Item *)itemlist->data;
+ 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)
+ gnome_canvas_item_set(it->canvas_item,
+ "fill-color-rgba", it->brush.color_rgba,
+ "width-units", it->brush.thickness, NULL);
+ }
}
// move item from redo to undo stack
{
GtkAdjustment *v_adj;
double yscroll;
+ struct Page *pg;
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
if (ui.view_continuous) return;
ui.view_continuous = TRUE;
v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
- yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
+ pg = ui.cur_page;
+ yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
update_page_stuff();
- gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
+ gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
// force a refresh
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
}
on_viewFirstPage_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
- do_switch_page(0, TRUE);
+ do_switch_page(0, TRUE, FALSE);
}
gpointer user_data)
{
if (ui.pageno == 0) return;
- do_switch_page(ui.pageno-1, TRUE);
+ do_switch_page(ui.pageno-1, TRUE, FALSE);
}
on_journalNewPageEnd_activate(menuitem, user_data);
return;
}
- do_switch_page(ui.pageno+1, TRUE);
+ do_switch_page(ui.pageno+1, TRUE, FALSE);
}
on_viewLastPage_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
- do_switch_page(journal.npages-1, TRUE);
+ do_switch_page(journal.npages-1, TRUE, FALSE);
}
pg = new_page(ui.cur_page);
journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
journal.npages++;
- do_switch_page(ui.pageno, TRUE);
+ do_switch_page(ui.pageno, TRUE, TRUE);
prepare_new_undo();
undo->type = ITEM_NEW_PAGE;
pg = new_page(ui.cur_page);
journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
journal.npages++;
- do_switch_page(ui.pageno+1, TRUE);
+ do_switch_page(ui.pageno+1, TRUE, TRUE);
prepare_new_undo();
undo->type = ITEM_NEW_PAGE;
pg = new_page((struct Page *)g_list_last(journal.pages)->data);
journal.pages = g_list_append(journal.pages, pg);
journal.npages++;
- do_switch_page(journal.npages-1, TRUE);
+ do_switch_page(journal.npages-1, TRUE, TRUE);
prepare_new_undo();
undo->type = ITEM_NEW_PAGE;
if (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);
+ do_switch_page(ui.pageno, TRUE, TRUE);
}
gpointer user_data)
{
int i, response;
+ struct Page *pg;
+ GList *pglist;
papersize_dialog = create_papersizeDialog();
papersize_width = ui.cur_page->width;
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);
- do_switch_page(ui.pageno, TRUE);
+ 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);
}
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
rescale_bg_pixmaps();
}
- do_switch_page(ui.pageno, TRUE);
+ do_switch_page(ui.pageno, TRUE, TRUE);
}
void
gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
rescale_bg_pixmaps();
}
- do_switch_page(ui.pageno, TRUE);
+ do_switch_page(ui.pageno, TRUE, TRUE);
}
on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ gboolean active;
+
+ 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;
+
+ if (ui.cur_page->bg->type != BG_SOLID) return;
+ reset_selection();
+ for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
+ page = (struct Page *)pglist->data;
+ prepare_new_undo();
+ undo->type = ITEM_NEW_BG_RESIZE;
+ undo->page = page;
+ undo->bg = page->bg;
+ undo->val_x = page->width;
+ undo->val_y = page->height;
+ if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
+ if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
+ page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
+ page->width = ui.cur_page->width;
+ page->height = ui.cur_page->height;
+ page->bg->canvas_item = undo->bg->canvas_item;
+ undo->bg->canvas_item = NULL;
+
+ make_page_clipbox(page);
+ 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;
+
reset_selection();
- ui.toolno = TOOL_PEN;
- ui.ruler = FALSE;
- ui.cur_brush = ui.brushes+TOOL_PEN;
+ ui.toolno[0] = TOOL_PEN;
+ ui.ruler[0] = FALSE;
+ ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
+ 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;
reset_selection();
- ui.toolno = TOOL_ERASER;
- ui.ruler = FALSE;
- ui.cur_brush = ui.brushes+TOOL_ERASER;
+ ui.toolno[0] = TOOL_ERASER;
+ ui.ruler[0] = FALSE;
+ 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;
reset_selection();
- ui.toolno = TOOL_HIGHLIGHTER;
- ui.ruler = FALSE;
- ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
+ ui.toolno[0] = TOOL_HIGHLIGHTER;
+ ui.ruler[0] = FALSE;
+ ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
+ update_mapping_linkings(TOOL_HIGHLIGHTER);
update_tool_buttons();
update_tool_menu();
update_color_menu();
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;
+ ui.toolno[0] = TOOL_SELECTRECT;
+ ui.ruler[0] = FALSE;
+ 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;
reset_selection();
- ui.toolno = TOOL_VERTSPACE;
- ui.ruler = FALSE;
+ ui.toolno[0] = TOOL_VERTSPACE;
+ ui.ruler[0] = FALSE;
+ 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;
+ 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;
+ 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;
+ ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
+ update_mapping_linkings(TOOL_ERASER);
}
on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
+ switch_mapping(0);
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]);
+ ui.ruler[0] = FALSE;
+ 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);
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]);
+ ui.ruler[0] = FALSE;
+ 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);
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]);
+ ui.ruler[0] = FALSE;
+ update_mapping_linkings(TOOL_HIGHLIGHTER);
update_tool_buttons();
update_tool_menu();
update_highlighter_props_menu();
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));
+ 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));
}
else
active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
- if (active == ui.ruler) return;
+ if (ui.cur_mapping != 0) return;
+ if (active == ui.ruler[0]) return;
- if (active && (ui.toolno!=TOOL_PEN && ui.toolno!=TOOL_HIGHLIGHTER)) {
+ if (active && (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.ruler[0] = active;
+ update_mapping_linkings(ui.toolno[0]);
update_ruler_indicator();
}
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));
+ 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));
+ ui.ruler[0] = FALSE;
+ 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;
+ int mapping;
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!
}
else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
- 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.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;
ui.pageno++;
tmppage = g_list_nth_data(journal.pages, ui.pageno);
}
- if (page_change) do_switch_page(ui.pageno, FALSE);
+ if (page_change) do_switch_page(ui.pageno, FALSE, 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 "
on_viewShowLayer_activate(NULL, NULL);
return;
}
+
+ // switch mappings if needed
- // process the event
ui.which_mouse_button = event->button;
+ switch_mapping(mapping);
+
+ // if this can be a selection move, then it takes precedence over anything else
+ if (start_movesel((GdkEvent *)event)) return FALSE;
- 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_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
+ reset_selection();
+
+ // process the event
+
+ 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);
}
return FALSE;
}
else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
- 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();
}
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();
}
-
+
+ switch_mapping(0);
return FALSE;
}
GdkEventExpose *event,
gpointer user_data)
{
-
+ if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
return FALSE;
}
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();
}
+ 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);
}
return FALSE;
}
-
void
on_comboLayer_changed (GtkComboBox *combobox,
gpointer user_data)
ui.pageno--;
tmppage = g_list_nth_data(journal.pages, ui.pageno);
}
- if (need_update) do_switch_page(ui.pageno, FALSE);
+ if (need_update) do_switch_page(ui.pageno, FALSE, FALSE);
return;
}
if (val == ui.pageno) return;
if (val < 0) val = 0;
if (val > journal.npages-1) val = journal.npages-1;
- do_switch_page(val, TRUE);
+ do_switch_page(val, TRUE, FALSE);
}
make_page_clipbox(ui.cur_page);
update_canvas_bg(ui.cur_page);
- do_switch_page(ui.pageno, TRUE);
+ do_switch_page(ui.pageno, TRUE, TRUE);
}
void
-on_optionsEmulateEraser_activate (GtkMenuItem *menuitem,
+on_optionsButtonMappings_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
- ui.emulate_eraser =
+ ui.use_erasertip =
gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
+ update_mappings_menu();
}
if (!ui.progressive_bg) rescale_bg_pixmaps();
}
+
+void
+on_mru_activate (GtkMenuItem *menuitem,
+ gpointer user_data)
+{
+ int which;
+ gboolean success;
+ GtkWidget *dialog;
+
+ if (!ok_to_close()) return; // user aborted on save confirmation
+
+ for (which = 0 ; which < MRU_SIZE; which++) {
+ if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
+ }
+ if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
+
+ set_cursor_busy(TRUE);
+ success = open_journal(ui.mru[which]);
+ set_cursor_busy(FALSE);
+ if (success) return;
+
+ /* open failed */
+ dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", ui.mru[which]);
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+ 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)
+{
+
+}
+
+
+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;
+ 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;
+ 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));
+ ui.ruler[1] = ui.ruler[0];
+ if (ui.toolno[1]!=TOOL_PEN && ui.toolno[1]!=TOOL_HIGHLIGHTER)
+ ui.ruler[1] = FALSE;
+}
+
+
+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)
+{
+
+}
+
+
+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;
+ 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;
+ 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));
+ ui.ruler[2] = ui.ruler[0];
+ if (ui.toolno[2]!=TOOL_PEN && ui.toolno[2]!=TOOL_HIGHLIGHTER)
+ ui.ruler[2] = FALSE;
+}
+
projects / xournal.git / blobdiff