X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=src%2Fxo-file.c;h=7d2786036f38feb0e4a1231e176ba97d7f2dcca4;hb=e648cece76b671b5b0e165acc6d14178e8de1000;hp=a052475c94b7c217f6d5b14b67f348ea284d9563;hpb=b3fe26e023d4f1cafbadd383574bc0971291f784;p=xournal.git diff --git a/src/xo-file.c b/src/xo-file.c index a052475..7d27860 100644 --- a/src/xo-file.c +++ b/src/xo-file.c @@ -13,6 +13,10 @@ #include #include #include +#include +#include +#include +#include #include "xournal.h" #include "xo-interface.h" @@ -20,8 +24,9 @@ #include "xo-callbacks.h" #include "xo-misc.h" #include "xo-file.h" +#include "xo-paint.h" -const char *tool_names[NUM_STROKE_TOOLS] = {"pen", "eraser", "highlighter"}; +const char *tool_names[NUM_TOOLS] = {"pen", "eraser", "highlighter", "text", "", "selectrect", "vertspace", "hand"}; const char *color_names[COLOR_MAX] = {"black", "blue", "red", "green", "gray", "lightblue", "lightgreen", "magenta", "orange", "yellow", "white"}; const char *bgtype_names[3] = {"solid", "pixmap", "pdf"}; @@ -29,6 +34,8 @@ const char *bgcolor_names[COLOR_MAX] = {"", "blue", "pink", "green", "", "", "", "", "orange", "yellow", "white"}; const char *bgstyle_names[4] = {"plain", "lined", "ruled", "graph"}; const char *file_domain_names[3] = {"absolute", "attach", "clone"}; +const char *unit_names[4] = {"cm", "in", "px", "pt"}; +int PDFTOPPM_PRINTING_DPI, GS_BITMAP_DPI; // creates a new empty journal @@ -70,9 +77,7 @@ gboolean save_journal(const char *filename) struct Layer *layer; struct Item *item; int i, is_clone; - char *tmpfn; - gchar *pdfbuf; - gsize pdflen; + char *tmpfn, *tmpstr; gboolean success; FILE *tmpf; GList *pagelist, *layerlist, *itemlist, *list; @@ -81,10 +86,12 @@ gboolean save_journal(const char *filename) f = gzopen(filename, "w"); if (f==NULL) return FALSE; chk_attach_names(); + + setlocale(LC_NUMERIC, "C"); gzprintf(f, "\n" - "Xournal document - see http://math.mit.edu/~auroux/software/xournal/\n" - "\n"); + "\n" + "Xournal document - see http://math.mit.edu/~auroux/software/xournal/\n"); for (pagelist = journal.pages; pagelist!=NULL; pagelist = pagelist->next) { pg = (struct Page *)pagelist->data; gzprintf(f, "\n", pg->width, pg->height); @@ -112,14 +119,16 @@ gboolean save_journal(const char *filename) if (!gdk_pixbuf_save(pg->bg->pixbuf, tmpfn, "png", NULL, NULL)) { dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - "Could not write background '%s'. Continuing anyway.", tmpfn); + _("Could not write background '%s'. Continuing anyway."), tmpfn); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } g_free(tmpfn); } + tmpstr = g_markup_escape_text(pg->bg->filename->s, -1); gzprintf(f, "domain=\"%s\" filename=\"%s\" ", - file_domain_names[pg->bg->file_domain], pg->bg->filename->s); + file_domain_names[pg->bg->file_domain], tmpstr); + g_free(tmpstr); } } else if (pg->bg->type == BG_PDF) { @@ -132,25 +141,26 @@ gboolean save_journal(const char *filename) if (pg->bg->file_domain == DOMAIN_ATTACH) { tmpfn = g_strdup_printf("%s.%s", filename, pg->bg->filename->s); success = FALSE; - if (bgpdf.status != STATUS_NOT_INIT && - g_file_get_contents(bgpdf.tmpfile_copy, &pdfbuf, &pdflen, NULL)) + if (bgpdf.status != STATUS_NOT_INIT && bgpdf.file_contents != NULL) { tmpf = fopen(tmpfn, "w"); - if (tmpf != NULL && fwrite(pdfbuf, 1, pdflen, tmpf) == pdflen) + if (tmpf != NULL && fwrite(bgpdf.file_contents, 1, bgpdf.file_length, tmpf) == bgpdf.file_length) success = TRUE; fclose(tmpf); } if (!success) { dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - "Could not write background '%s'. Continuing anyway.", tmpfn); + _("Could not write background '%s'. Continuing anyway."), tmpfn); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } g_free(tmpfn); } + tmpstr = g_markup_escape_text(pg->bg->filename->s, -1); gzprintf(f, "domain=\"%s\" filename=\"%s\" ", - file_domain_names[pg->bg->file_domain], pg->bg->filename->s); + file_domain_names[pg->bg->file_domain], tmpstr); + g_free(tmpstr); } gzprintf(f, "pageno=\"%d\" ", pg->bg->file_page_seq); } @@ -167,17 +177,37 @@ gboolean save_journal(const char *filename) gzputs(f, color_names[item->brush.color_no]); else gzprintf(f, "#%08x", item->brush.color_rgba); - gzprintf(f, "\" width=\"%.2f\">\n", item->brush.thickness); + gzprintf(f, "\" width=\"%.2f", item->brush.thickness); + if (item->brush.variable_width) + for (i=0;ipath->num_points-1;i++) + gzprintf(f, " %.2f", item->widths[i]); + gzprintf(f, "\">\n"); for (i=0;i<2*item->path->num_points;i++) gzprintf(f, "%.2f ", item->path->coords[i]); gzprintf(f, "\n\n"); } + if (item->type == ITEM_TEXT) { + tmpstr = g_markup_escape_text(item->font_name, -1); + gzprintf(f, "font_size, item->bbox.left, item->bbox.top); + g_free(tmpstr); + if (item->brush.color_no >= 0) + gzputs(f, color_names[item->brush.color_no]); + else + gzprintf(f, "#%08x", item->brush.color_rgba); + tmpstr = g_markup_escape_text(item->text, -1); + gzprintf(f, "\">%s\n", tmpstr); + g_free(tmpstr); + } } gzprintf(f, "\n"); } gzprintf(f, "\n"); } + gzprintf(f, "\n"); gzclose(f); + setlocale(LC_NUMERIC, ""); + return TRUE; } @@ -200,6 +230,13 @@ gboolean close_journal(void) use new_journal() to reinitialize them */ } +// sanitize a string containing floats, in case it may have , instead of . + +void cleanup_numeric(char *s) +{ + while (*s!=0) { if (*s==',') *s='.'; s++; } +} + // the XML parser functions for open_journal() struct Journal tmpJournal; @@ -211,7 +248,7 @@ struct Background *tmpBg_pdf; GError *xoj_invalid(void) { - return g_error_new(G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "Invalid file contents"); + return g_error_new(G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("Invalid file contents")); } void xoj_parser_start_element(GMarkupParseContext *context, @@ -219,9 +256,10 @@ void xoj_parser_start_element(GMarkupParseContext *context, const gchar **attribute_values, gpointer user_data, GError **error) { int has_attr, i; - char *ptr; + char *ptr, *tmpptr; struct Background *tmpbg; char *tmpbg_filename; + gdouble val; GtkWidget *dialog; if (!strcmp(element_name, "title") || !strcmp(element_name, "xournal")) { @@ -252,13 +290,15 @@ void xoj_parser_start_element(GMarkupParseContext *context, while (*attribute_names!=NULL) { if (!strcmp(*attribute_names, "width")) { if (has_attr & 1) *error = xoj_invalid(); - tmpPage->width = strtod(*attribute_values, &ptr); + cleanup_numeric((gchar *)*attribute_values); + tmpPage->width = g_ascii_strtod(*attribute_values, &ptr); if (ptr == *attribute_values) *error = xoj_invalid(); has_attr |= 1; } else if (!strcmp(*attribute_names, "height")) { if (has_attr & 2) *error = xoj_invalid(); - tmpPage->height = strtod(*attribute_values, &ptr); + cleanup_numeric((gchar *)*attribute_values); + tmpPage->height = g_ascii_strtod(*attribute_values, &ptr); if (ptr == *attribute_values) *error = xoj_invalid(); has_attr |= 2; } @@ -358,7 +398,7 @@ void xoj_parser_start_element(GMarkupParseContext *context, if (tmpPage->bg->pixbuf == NULL) { dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, - "Could not open background '%s'. Setting background to white.", + _("Could not open background '%s'. Setting background to white."), tmpbg_filename); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); @@ -373,7 +413,7 @@ void xoj_parser_start_element(GMarkupParseContext *context, else if (!strcmp(*attribute_names, "pageno")) { if (tmpPage->bg->type != BG_PDF || (has_attr & 32)) { *error = xoj_invalid(); return; } - tmpPage->bg->file_page_seq = strtod(*attribute_values, &ptr); + tmpPage->bg->file_page_seq = strtol(*attribute_values, &ptr, 10); if (ptr == *attribute_values) *error = xoj_invalid(); has_attr |= 32; } @@ -407,6 +447,7 @@ void xoj_parser_start_element(GMarkupParseContext *context, tmpItem->type = ITEM_STROKE; tmpItem->path = NULL; tmpItem->canvas_item = NULL; + tmpItem->widths = NULL; tmpLayer->items = g_list_append(tmpLayer->items, tmpItem); tmpLayer->nitems++; // scan for tool, color, and width attributes @@ -414,8 +455,23 @@ void xoj_parser_start_element(GMarkupParseContext *context, while (*attribute_names!=NULL) { if (!strcmp(*attribute_names, "width")) { if (has_attr & 1) *error = xoj_invalid(); - tmpItem->brush.thickness = strtod(*attribute_values, &ptr); + cleanup_numeric((gchar *)*attribute_values); + tmpItem->brush.thickness = g_ascii_strtod(*attribute_values, &ptr); if (ptr == *attribute_values) *error = xoj_invalid(); + i = 0; + while (*ptr!=0) { + realloc_cur_widths(i+1); + ui.cur_widths[i] = g_ascii_strtod(ptr, &tmpptr); + if (tmpptr == ptr) break; + ptr = tmpptr; + i++; + } + tmpItem->brush.variable_width = (i>0); + if (i>0) { + tmpItem->brush.variable_width = TRUE; + tmpItem->widths = (gdouble *) g_memdup(ui.cur_widths, i*sizeof(gdouble)); + ui.cur_path.num_points = i+1; + } has_attr |= 1; } else if (!strcmp(*attribute_names, "color")) { @@ -451,11 +507,73 @@ void xoj_parser_start_element(GMarkupParseContext *context, // finish filling the brush info tmpItem->brush.thickness_no = 0; // who cares ? tmpItem->brush.tool_options = 0; // who cares ? + tmpItem->brush.ruler = FALSE; + tmpItem->brush.recognizer = FALSE; if (tmpItem->brush.tool_type == TOOL_HIGHLIGHTER) { if (tmpItem->brush.color_no >= 0) - tmpItem->brush.color_rgba &= HILITER_ALPHA_MASK; + tmpItem->brush.color_rgba &= ui.hiliter_alpha_mask; } } + else if (!strcmp(element_name, "text")) { // start of a text item + if (tmpLayer == NULL || tmpItem != NULL) { + *error = xoj_invalid(); + return; + } + tmpItem = (struct Item *)g_malloc0(sizeof(struct Item)); + tmpItem->type = ITEM_TEXT; + tmpItem->canvas_item = NULL; + tmpLayer->items = g_list_append(tmpLayer->items, tmpItem); + tmpLayer->nitems++; + // scan for font, size, x, y, and color attributes + has_attr = 0; + while (*attribute_names!=NULL) { + if (!strcmp(*attribute_names, "font")) { + if (has_attr & 1) *error = xoj_invalid(); + tmpItem->font_name = g_strdup(*attribute_values); + has_attr |= 1; + } + else if (!strcmp(*attribute_names, "size")) { + if (has_attr & 2) *error = xoj_invalid(); + cleanup_numeric((gchar *)*attribute_values); + tmpItem->font_size = g_ascii_strtod(*attribute_values, &ptr); + if (ptr == *attribute_values) *error = xoj_invalid(); + has_attr |= 2; + } + else if (!strcmp(*attribute_names, "x")) { + if (has_attr & 4) *error = xoj_invalid(); + cleanup_numeric((gchar *)*attribute_values); + tmpItem->bbox.left = g_ascii_strtod(*attribute_values, &ptr); + if (ptr == *attribute_values) *error = xoj_invalid(); + has_attr |= 4; + } + else if (!strcmp(*attribute_names, "y")) { + if (has_attr & 8) *error = xoj_invalid(); + cleanup_numeric((gchar *)*attribute_values); + tmpItem->bbox.top = g_ascii_strtod(*attribute_values, &ptr); + if (ptr == *attribute_values) *error = xoj_invalid(); + has_attr |= 8; + } + else if (!strcmp(*attribute_names, "color")) { + if (has_attr & 16) *error = xoj_invalid(); + tmpItem->brush.color_no = COLOR_OTHER; + for (i=0; ibrush.color_no = i; + tmpItem->brush.color_rgba = predef_colors_rgba[i]; + } + // there's also the case of hex (#rrggbbaa) colors + if (tmpItem->brush.color_no == COLOR_OTHER && **attribute_values == '#') { + tmpItem->brush.color_rgba = strtol(*attribute_values + 1, &ptr, 16); + if (*ptr!=0) *error = xoj_invalid(); + } + has_attr |= 16; + } + else *error = xoj_invalid(); + attribute_names++; + attribute_values++; + } + if (has_attr!=31) *error = xoj_invalid(); + } } void xoj_parser_end_element(GMarkupParseContext *context, @@ -484,6 +602,13 @@ void xoj_parser_end_element(GMarkupParseContext *context, update_item_bbox(tmpItem); tmpItem = NULL; } + if (!strcmp(element_name, "text")) { + if (tmpItem == NULL) { + *error = xoj_invalid(); + return; + } + tmpItem = NULL; + } } void xoj_parser_text(GMarkupParseContext *context, @@ -495,20 +620,32 @@ void xoj_parser_text(GMarkupParseContext *context, element_name = g_markup_parse_context_get_element(context); if (element_name == NULL) return; if (!strcmp(element_name, "stroke")) { + cleanup_numeric((gchar *)text); ptr = text; n = 0; while (text_len > 0) { realloc_cur_path(n/2 + 1); - ui.cur_path.coords[n] = strtod(text, (char **)(&ptr)); + ui.cur_path.coords[n] = g_ascii_strtod(text, (char **)(&ptr)); if (ptr == text) break; text_len -= (ptr - text); text = ptr; + if (!finite(ui.cur_path.coords[n])) { + if (n>=2) ui.cur_path.coords[n] = ui.cur_path.coords[n-2]; + else ui.cur_path.coords[n] = 0; + } n++; } - if (n<4 || n&1) { *error = xoj_invalid(); return; } + if (n<4 || n&1 || + (tmpItem->brush.variable_width && (n!=2*ui.cur_path.num_points))) + { *error = xoj_invalid(); return; } // wrong number of points tmpItem->path = gnome_canvas_points_new(n/2); g_memmove(tmpItem->path->coords, ui.cur_path.coords, n*sizeof(double)); } + if (!strcmp(element_name, "text")) { + tmpItem->text = g_malloc(text_len+1); + g_memmove(tmpItem->text, text, text_len); + tmpItem->text[text_len]=0; + } } gboolean user_wants_second_chance(char **filename) @@ -519,25 +656,25 @@ gboolean user_wants_second_chance(char **filename) dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_YES_NO, - "Could not open background '%s'.\nSelect another file?", + _("Could not open background '%s'.\nSelect another file?"), *filename); response = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); if (response != GTK_RESPONSE_YES) return FALSE; - dialog = gtk_file_chooser_dialog_new("Open PDF", GTK_WINDOW (winMain), + 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"); + gtk_file_filter_set_name(filt_all, _("All files")); gtk_file_filter_add_pattern(filt_all, "*"); filt_pdf = gtk_file_filter_new(); - gtk_file_filter_set_name(filt_pdf, "PDF files"); + gtk_file_filter_set_name(filt_pdf, _("PDF files")); 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 (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { + if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) { gtk_widget_destroy(dialog); return FALSE; } @@ -600,7 +737,7 @@ gboolean open_journal(char *filename) close_journal(); while (bgpdf.status != STATUS_NOT_INIT) 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(); return init_bgpdf(filename, TRUE, DOMAIN_ABSOLUTE); @@ -632,7 +769,7 @@ gboolean open_journal(char *filename) bgpdf.filename = refstring_ref(tmpBg_pdf->filename); } else { dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL, - GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Could not open background '%s'.", + GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not open background '%s'."), tmpfn); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); @@ -645,11 +782,12 @@ gboolean open_journal(char *filename) ui.layerno = ui.cur_page->nlayers-1; ui.cur_layer = (struct Layer *)(g_list_last(ui.cur_page->layers)->data); ui.saved = TRUE; - ui.zoom = DEFAULT_ZOOM; + ui.zoom = ui.startup_zoom; update_file_name(g_strdup(filename)); gnome_canvas_set_pixels_per_unit(canvas, ui.zoom); make_canvas_items(); update_page_stuff(); + rescale_bg_pixmaps(); // this requests the PDF pages if need be gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0); return TRUE; } @@ -692,8 +830,9 @@ GList *attempt_load_gv_bg(char *filename) char *pipename; int buflen, remnlen, file_pageno; - buf = g_malloc(BUFSIZE); // a reasonable buffer size f = fopen(filename, "r"); + if (f == NULL) return NULL; + buf = g_malloc(BUFSIZE); // a reasonable buffer size if (fread(buf, 1, 4, f) !=4 || (strncmp((char *)buf, "%!PS", 4) && strncmp((char *)buf, "%PDF", 4))) { fclose(f); @@ -752,10 +891,8 @@ struct Background *attempt_screenshot_bg(void) struct Background *bg; GdkPixbuf *pix; XEvent x_event; - GError *error = NULL; GdkWindow *window; - int x,y,w,h, status; - unsigned int tmp; + int x,y,w,h; Window x_root, x_win; x_root = gdk_x11_get_default_root_xwindow(); @@ -791,23 +928,6 @@ struct Background *attempt_screenshot_bg(void) /************** pdf annotation ***************/ -/* free tmp directory */ - -void end_bgpdf_shutdown(void) -{ - if (bgpdf.tmpdir!=NULL) { - if (bgpdf.tmpfile_copy!=NULL) { - g_unlink(bgpdf.tmpfile_copy); - g_free(bgpdf.tmpfile_copy); - bgpdf.tmpfile_copy = NULL; - } - g_rmdir(bgpdf.tmpdir); - g_free(bgpdf.tmpdir); - bgpdf.tmpdir = NULL; - } - bgpdf.status = STATUS_NOT_INIT; -} - /* cancel a request */ void cancel_bgpdf_request(struct BgPdfRequest *req) @@ -816,45 +936,50 @@ void cancel_bgpdf_request(struct BgPdfRequest *req) list_link = g_list_find(bgpdf.requests, req); if (list_link == NULL) return; - if (list_link->prev == NULL && bgpdf.pid > 0) { - // this is being processed: kill the child but don't remove the request yet - if (bgpdf.status == STATUS_RUNNING) bgpdf.status = STATUS_ABORTED; - kill(bgpdf.pid, SIGHUP); -// printf("Cancelling a request - killing %d\n", bgpdf.pid); - } - else { - // remove the request - bgpdf.requests = g_list_delete_link(bgpdf.requests, list_link); - g_free(req); -// printf("Cancelling a request - no kill needed\n"); - } + // remove the request + bgpdf.requests = g_list_delete_link(bgpdf.requests, list_link); + g_free(req); } -/* sigchld callback */ +/* process a bg PDF request from the queue, and recurse */ -void bgpdf_child_handler(GPid pid, gint status, gpointer data) +gboolean bgpdf_scheduler_callback(gpointer data) { struct BgPdfRequest *req; struct BgPdfPage *bgpg; - gchar *ppm_name; GdkPixbuf *pixbuf; - - if (bgpdf.requests == NULL) return; + GtkWidget *dialog; + PopplerPage *pdfpage; + gdouble height, width; + int scaled_height, scaled_width; + + // if all requests have been cancelled, remove ourselves from main loop + if (bgpdf.requests == NULL) { bgpdf.pid = 0; return FALSE; } + if (bgpdf.status == STATUS_NOT_INIT) + { printf("DEBUG: BGPDF not initialized??\n"); bgpdf.pid = 0; return FALSE; } + req = (struct BgPdfRequest *)bgpdf.requests->data; - - ppm_name = g_strdup_printf("%s/p-%06d.ppm", bgpdf.tmpdir, req->pageno); -// printf("Child %d finished, should look for %s... \n", pid, ppm_name); - - if (bgpdf.status == STATUS_ABORTED || bgpdf.status == STATUS_SHUTDOWN) - pixbuf = NULL; - else - pixbuf = gdk_pixbuf_new_from_file(ppm_name, NULL); - unlink(ppm_name); - g_free(ppm_name); + // use poppler to generate the page + pixbuf = NULL; + pdfpage = poppler_document_get_page(bgpdf.document, req->pageno-1); + if (pdfpage) { +// printf("DEBUG: Processing request for page %d at %f dpi\n", req->pageno, req->dpi); + set_cursor_busy(TRUE); + poppler_page_get_size(pdfpage, &width, &height); + scaled_width = (int) (req->dpi * width/72); + scaled_height = (int) (req->dpi * height/72); + pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, + FALSE, 8, scaled_width, scaled_height); + poppler_page_render_to_pixbuf( + pdfpage, 0, 0, scaled_width, scaled_height, + req->dpi/72, 0, pixbuf); + g_object_unref(pdfpage); + set_cursor_busy(FALSE); + } + // process the generated pixbuf... if (pixbuf != NULL) { // success -// printf("success\n"); while (req->pageno > bgpdf.npages) { bgpg = g_new(struct BgPdfPage, 1); bgpg->pixbuf = NULL; @@ -865,125 +990,49 @@ void bgpdf_child_handler(GPid pid, gint status, gpointer data) if (bgpg->pixbuf!=NULL) gdk_pixbuf_unref(bgpg->pixbuf); bgpg->pixbuf = pixbuf; bgpg->dpi = req->dpi; - if (req->initial_request && bgpdf.create_pages) { - bgpdf_create_page_with_bg(req->pageno, bgpg); - // create page n, resize it, set its bg - all without any undo effect - } else { - if (!req->is_printing) bgpdf_update_bg(req->pageno, bgpg); - // look for all pages with this bg, and update their bg pixmaps - } - } - else { -// printf("failed or aborted\n"); - bgpdf.create_pages = FALSE; - req->initial_request = FALSE; - } - - bgpdf.pid = 0; - g_spawn_close_pid(pid); - - if (req->initial_request) - req->pageno++; // try for next page - else - bgpdf.requests = g_list_delete_link(bgpdf.requests, bgpdf.requests); - - if (bgpdf.status == STATUS_SHUTDOWN) { - end_bgpdf_shutdown(); - return; - } - - bgpdf.status = STATUS_IDLE; - if (bgpdf.requests != NULL) bgpdf_spawn_child(); -} - -/* spawn a child to process the head request */ - -void bgpdf_spawn_child(void) -{ - struct BgPdfRequest *req; - GPid pid; - gchar pageno_str[10], dpi_str[10]; - gchar *pdf_filename = bgpdf.tmpfile_copy; - gchar *ppm_root = g_strdup_printf("%s/p", bgpdf.tmpdir); - gchar *argv[]= PDFTOPPM_ARGV; - GtkWidget *dialog; - - if (bgpdf.requests == NULL) return; - req = (struct BgPdfRequest *)bgpdf.requests->data; - if (req->pageno > bgpdf.npages+1 || - (!req->initial_request && req->pageno <= bgpdf.npages && - req->dpi == ((struct BgPdfPage *)g_list_nth_data(bgpdf.pages, req->pageno-1))->dpi)) - { // ignore this request - it's redundant, or in outer space - bgpdf.pid = 0; - bgpdf.status = STATUS_IDLE; - bgpdf.requests = g_list_delete_link(bgpdf.requests, bgpdf.requests); - g_free(ppm_root); - if (bgpdf.requests != NULL) bgpdf_spawn_child(); - return; - } - g_snprintf(pageno_str, 10, "%d", req->pageno); - g_snprintf(dpi_str, 10, "%d", req->dpi); -/* printf("Processing request for page %d at %d dpi -- in %s\n", - req->pageno, req->dpi, ppm_root); */ - if (!g_spawn_async(NULL, argv, NULL, - G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH, - NULL, NULL, &pid, NULL)) - { - // couldn't spawn... abort this request, try next one maybe ? -// printf("Couldn't spawn\n"); - bgpdf.pid = 0; - bgpdf.status = STATUS_IDLE; - bgpdf.requests = g_list_delete_link(bgpdf.requests, bgpdf.requests); - g_free(ppm_root); + bgpg->pixel_height = scaled_height; + bgpg->pixel_width = scaled_width; + bgpdf_update_bg(req->pageno, bgpg); // update all pages that have this bg + } else { // failure if (!bgpdf.has_failed) { dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL, - GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Unable to start PDF loader %s.", argv[0]); + GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Unable to render one or more PDF pages.")); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } bgpdf.has_failed = TRUE; - if (bgpdf.requests != NULL) bgpdf_spawn_child(); - return; - } + } -// printf("Spawned process %d\n", pid); - bgpdf.pid = pid; - bgpdf.status = STATUS_RUNNING; - g_child_watch_add(pid, bgpdf_child_handler, NULL); - g_free(ppm_root); + bgpdf.requests = g_list_delete_link(bgpdf.requests, bgpdf.requests); + if (bgpdf.requests != NULL) return TRUE; // remain in the idle loop + bgpdf.pid = 0; + return FALSE; // we're done } /* make a request */ -void add_bgpdf_request(int pageno, double zoom, gboolean printing) +void add_bgpdf_request(int pageno, double zoom) { struct BgPdfRequest *req, *cmp_req; GList *list; - if (bgpdf.status == STATUS_NOT_INIT || bgpdf.status == STATUS_SHUTDOWN) - return; // don't accept requests in those modes... + if (bgpdf.status == STATUS_NOT_INIT) + return; // don't accept requests req = g_new(struct BgPdfRequest, 1); - req->is_printing = printing; - if (printing) req->dpi = PDFTOPPM_PRINTING_DPI; - else req->dpi = (int)floor(72*zoom+0.5); -// printf("Enqueuing request for page %d at %d dpi\n", pageno, req->dpi); - if (pageno >= 1) { - // cancel any request this may supersede - for (list = bgpdf.requests; list != NULL; ) { - cmp_req = (struct BgPdfRequest *)list->data; - list = list->next; - if (!cmp_req->initial_request && cmp_req->pageno == pageno && - cmp_req->is_printing == printing) - cancel_bgpdf_request(cmp_req); - } - req->pageno = pageno; - req->initial_request = FALSE; - } else { - req->pageno = 1; - req->initial_request = TRUE; + req->pageno = pageno; + req->dpi = 72*zoom; +// printf("DEBUG: Enqueuing request for page %d at %f dpi\n", pageno, req->dpi); + + // cancel any request this may supersede + for (list = bgpdf.requests; list != NULL; ) { + cmp_req = (struct BgPdfRequest *)list->data; + list = list->next; + if (cmp_req->pageno == pageno) cancel_bgpdf_request(cmp_req); } + + // make the request bgpdf.requests = g_list_append(bgpdf.requests, req); - if (!bgpdf.pid) bgpdf_spawn_child(); + if (!bgpdf.pid) bgpdf.pid = g_idle_add(bgpdf_scheduler_callback, NULL); } /* shutdown the PDF reader */ @@ -993,103 +1042,107 @@ void shutdown_bgpdf(void) GList *list; struct BgPdfPage *pdfpg; struct BgPdfRequest *req; + + if (bgpdf.status == STATUS_NOT_INIT) return; - if (bgpdf.status == STATUS_NOT_INIT || bgpdf.status == STATUS_SHUTDOWN) return; + // cancel all requests and free data structures refstring_unref(bgpdf.filename); for (list = bgpdf.pages; list != NULL; list = list->next) { pdfpg = (struct BgPdfPage *)list->data; if (pdfpg->pixbuf!=NULL) gdk_pixbuf_unref(pdfpg->pixbuf); + g_free(pdfpg); } g_list_free(bgpdf.pages); - bgpdf.status = STATUS_SHUTDOWN; - for (list = g_list_last(bgpdf.requests); list != NULL; ) { + for (list = bgpdf.requests; list != NULL; list = list->next) { req = (struct BgPdfRequest *)list->data; - list = list->prev; - cancel_bgpdf_request(req); + g_free(req); + } + g_list_free(bgpdf.requests); + + if (bgpdf.file_contents!=NULL) { + g_free(bgpdf.file_contents); + bgpdf.file_contents = NULL; } - if (!bgpdf.pid) end_bgpdf_shutdown(); - /* The above will ultimately remove all requests and kill the child if needed. - The child will set status to STATUS_NOT_INIT, clear the requests list, - empty tmpdir, ... except if there's no child! */ - /* note: it could look like there's a race condition here - if a child - terminates and a new request is enqueued while we are destroying the - queue - but actually the child handler callback is NOT a signal - callback, so execution of this function is atomic */ + if (bgpdf.document!=NULL) { + g_object_unref(bgpdf.document); + bgpdf.document = NULL; + } + + bgpdf.status = STATUS_NOT_INIT; } + +// initialize PDF background rendering + gboolean init_bgpdf(char *pdfname, gboolean create_pages, int file_domain) { - FILE *f; - gchar *filebuf; - gsize filelen; + int i, n_pages; + struct Background *bg; + struct Page *pg; + PopplerPage *pdfpage; + gdouble width, height; if (bgpdf.status != STATUS_NOT_INIT) return FALSE; - bgpdf.tmpfile_copy = NULL; - bgpdf.tmpdir = mkdtemp(g_strdup(TMPDIR_TEMPLATE)); - if (!bgpdf.tmpdir) return FALSE; - // make a local copy and check if it's a PDF - if (!g_file_get_contents(pdfname, &filebuf, &filelen, NULL)) - { end_bgpdf_shutdown(); return FALSE; } - if (filelen < 4 || strncmp(filebuf, "%PDF", 4)) - { g_free(filebuf); end_bgpdf_shutdown(); return FALSE; } - bgpdf.tmpfile_copy = g_strdup_printf("%s/bg.pdf", bgpdf.tmpdir); - f = fopen(bgpdf.tmpfile_copy, "w"); - if (f == NULL || fwrite(filebuf, 1, filelen, f) != filelen) - { g_free(filebuf); end_bgpdf_shutdown(); return FALSE; } - fclose(f); - g_free(filebuf); - bgpdf.status = STATUS_IDLE; - bgpdf.pid = 0; + + // make a copy of the file in memory and check it's a PDF + if (!g_file_get_contents(pdfname, &(bgpdf.file_contents), &(bgpdf.file_length), NULL)) + return FALSE; + if (bgpdf.file_length < 4 || strncmp(bgpdf.file_contents, "%PDF", 4)) + { g_free(bgpdf.file_contents); bgpdf.file_contents = NULL; return FALSE; } + + // init bgpdf data structures and open poppler document + bgpdf.status = STATUS_READY; bgpdf.filename = new_refstring((file_domain == DOMAIN_ATTACH) ? "bg.pdf" : pdfname); bgpdf.file_domain = file_domain; bgpdf.npages = 0; bgpdf.pages = NULL; bgpdf.requests = NULL; - bgpdf.create_pages = create_pages; + bgpdf.pid = 0; bgpdf.has_failed = FALSE; - add_bgpdf_request(-1, DEFAULT_ZOOM, FALSE); // request all pages - return TRUE; -} -// create page n, resize it, set its bg -void bgpdf_create_page_with_bg(int pageno, struct BgPdfPage *bgpg) -{ - struct Page *pg; - struct Background *bg; + bgpdf.document = poppler_document_new_from_data(bgpdf.file_contents, bgpdf.file_length, NULL, NULL); + if (bgpdf.document == NULL) shutdown_bgpdf(); - if (journal.npages < pageno) { - bg = g_new(struct Background, 1); - bg->canvas_item = NULL; - } else { - pg = (struct Page *)g_list_nth_data(journal.pages, pageno-1); - bg = pg->bg; - if (bg->type != BG_SOLID) return; - // don't mess with a page the user has modified significantly... - } + if (!create_pages) return TRUE; // we're done - bg->type = BG_PDF; - bg->pixbuf = gdk_pixbuf_ref(bgpg->pixbuf); - bg->filename = refstring_ref(bgpdf.filename); - bg->file_domain = bgpdf.file_domain; - bg->file_page_seq = pageno; - bg->pixbuf_scale = DEFAULT_ZOOM; - bg->pixbuf_dpi = bgpg->dpi; - - if (journal.npages < pageno) { - pg = new_page_with_bg(bg, - gdk_pixbuf_get_width(bg->pixbuf)*72.0/bg->pixbuf_dpi, - gdk_pixbuf_get_height(bg->pixbuf)*72.0/bg->pixbuf_dpi); - journal.pages = g_list_append(journal.pages, pg); - journal.npages++; - } else { - pg->width = gdk_pixbuf_get_width(bgpg->pixbuf)*72.0/bg->pixbuf_dpi; - pg->height = gdk_pixbuf_get_height(bgpg->pixbuf)*72.0/bg->pixbuf_dpi; - make_page_clipbox(pg); - update_canvas_bg(pg); + // create pages with correct sizes if requested + n_pages = poppler_document_get_n_pages(bgpdf.document); + for (i=1; i<=n_pages; i++) { + pdfpage = poppler_document_get_page(bgpdf.document, i-1); + if (!pdfpage) continue; + if (journal.npages < i) { + bg = g_new(struct Background, 1); + bg->canvas_item = NULL; + pg = NULL; + } else { + pg = (struct Page *)g_list_nth_data(journal.pages, i-1); + bg = pg->bg; + } + bg->type = BG_PDF; + bg->filename = refstring_ref(bgpdf.filename); + bg->file_domain = bgpdf.file_domain; + bg->file_page_seq = i; + bg->pixbuf = NULL; + bg->pixbuf_scale = 0; + poppler_page_get_size(pdfpage, &width, &height); + g_object_unref(pdfpage); + if (pg == NULL) { + pg = new_page_with_bg(bg, width, height); + journal.pages = g_list_append(journal.pages, pg); + journal.npages++; + } else { + pg->width = width; + pg->height = height; + make_page_clipbox(pg); + update_canvas_bg(pg); + } } update_page_stuff(); + rescale_bg_pixmaps(); // this actually requests the pages !! + return TRUE; } + // look for all journal pages with given pdf bg, and update their bg pixmaps void bgpdf_update_bg(int pageno, struct BgPdfPage *bgpg) { @@ -1101,9 +1154,697 @@ void bgpdf_update_bg(int pageno, struct BgPdfPage *bgpg) if (pg->bg->type == BG_PDF && pg->bg->file_page_seq == pageno) { if (pg->bg->pixbuf!=NULL) gdk_pixbuf_unref(pg->bg->pixbuf); pg->bg->pixbuf = gdk_pixbuf_ref(bgpg->pixbuf); - pg->bg->pixbuf_dpi = bgpg->dpi; + pg->bg->pixel_width = bgpg->pixel_width; + pg->bg->pixel_height = bgpg->pixel_height; update_canvas_bg(pg); } } } +// initialize the recent files list +void init_mru(void) +{ + int i; + gsize lfptr; + char s[5]; + GIOChannel *f; + gchar *str; + GIOStatus status; + + g_strlcpy(s, "mru0", 5); + for (s[3]='0', i=0; i0) { + str[lfptr] = 0; + ui.mru[i] = str; + i++; + } + } + if (f) { + g_io_channel_shutdown(f, FALSE, NULL); + g_io_channel_unref(f); + } + update_mru_menu(); +} + +void update_mru_menu(void) +{ + int i; + gboolean anyone = FALSE; + gchar *tmp; + + for (i=0; i=1; j--) ui.mru[j] = ui.mru[j-1]; + ui.mru[0] = g_strdup(name); + update_mru_menu(); +} + +void delete_mru_entry(int which) +{ + int i; + + if (ui.mru[which]!=NULL) g_free(ui.mru[which]); + for (i=which+1;itype = BG_SOLID; + ui.default_page.bg->color_no = COLOR_WHITE; + ui.default_page.bg->color_rgba = predef_bgcolors_rgba[COLOR_WHITE]; + ui.default_page.bg->ruling = RULING_LINED; + ui.view_continuous = TRUE; + ui.allow_xinput = TRUE; + ui.discard_corepointer = FALSE; + ui.left_handed = FALSE; + ui.shorten_menus = FALSE; + ui.shorten_menu_items = g_strdup(DEFAULT_SHORTEN_MENUS); + ui.auto_save_prefs = FALSE; + ui.bg_apply_all_pages = FALSE; + ui.use_erasertip = FALSE; + ui.window_default_width = 720; + ui.window_default_height = 480; + ui.maximize_at_start = FALSE; + ui.fullscreen = FALSE; + ui.scrollbar_step_increment = 30; + ui.zoom_step_increment = 1; + ui.zoom_step_factor = 1.5; + ui.antialias_bg = TRUE; + ui.progressive_bg = TRUE; + ui.print_ruling = TRUE; + ui.default_unit = UNIT_CM; + ui.default_path = NULL; + ui.default_font_name = g_strdup(DEFAULT_FONT); + ui.default_font_size = DEFAULT_FONT_SIZE; + ui.pressure_sensitivity = FALSE; + ui.width_minimum_multiplier = 0.0; + ui.width_maximum_multiplier = 1.25; + + // the default UI vertical order + ui.vertical_order[0][0] = 1; + ui.vertical_order[0][1] = 2; + ui.vertical_order[0][2] = 3; + ui.vertical_order[0][3] = 0; + ui.vertical_order[0][4] = 4; + ui.vertical_order[1][0] = 2; + ui.vertical_order[1][1] = 3; + ui.vertical_order[1][2] = 0; + ui.vertical_order[1][3] = ui.vertical_order[1][4] = -1; + + ui.toolno[0] = ui.startuptool = TOOL_PEN; + for (i=1; i<=NUM_BUTTONS; i++) { + ui.toolno[i] = TOOL_ERASER; + } + for (i=0; i<=NUM_BUTTONS; i++) + ui.linked_brush[i] = BRUSH_LINKED; + ui.brushes[0][TOOL_PEN].color_no = COLOR_BLACK; + ui.brushes[0][TOOL_ERASER].color_no = COLOR_WHITE; + ui.brushes[0][TOOL_HIGHLIGHTER].color_no = COLOR_YELLOW; + for (i=0; i < NUM_STROKE_TOOLS; i++) { + ui.brushes[0][i].thickness_no = THICKNESS_MEDIUM; + ui.brushes[0][i].tool_options = 0; + ui.brushes[0][i].ruler = FALSE; + ui.brushes[0][i].recognizer = FALSE; + ui.brushes[0][i].variable_width = FALSE; + } + for (i=0; i< NUM_STROKE_TOOLS; i++) + for (j=1; j<=NUM_BUTTONS; j++) + g_memmove(&(ui.brushes[j][i]), &(ui.brushes[0][i]), sizeof(struct Brush)); + + // predef_thickness is already initialized as a global variable + GS_BITMAP_DPI = 144; + PDFTOPPM_PRINTING_DPI = 150; + + ui.hiliter_opacity = 0.5; +} + +#if GLIB_CHECK_VERSION(2,6,0) + +void update_keyval(const gchar *group_name, const gchar *key, + const gchar *comment, gchar *value) +{ + gboolean has_it = g_key_file_has_key(ui.config_data, group_name, key, NULL); + cleanup_numeric(value); + g_key_file_set_value(ui.config_data, group_name, key, value); + g_free(value); + if (!has_it) g_key_file_set_comment(ui.config_data, group_name, key, comment, NULL); +} + +#endif + +const char *vorder_usernames[VBOX_MAIN_NITEMS+1] = + {"drawarea", "menu", "main_toolbar", "pen_toolbar", "statusbar", NULL}; + +gchar *verbose_vertical_order(int *order) +{ + gchar buf[80], *p; // longer than needed + int i; + + p = buf; + for (i=0; i=VBOX_MAIN_NITEMS) continue; + if (p!=buf) *(p++) = ' '; + p = g_stpcpy(p, vorder_usernames[order[i]]); + } + return g_strdup(buf); +} + +void save_config_to_file(void) +{ + gchar *buf; + FILE *f; + +#if GLIB_CHECK_VERSION(2,6,0) + // no support for keyval files before Glib 2.6.0 + if (glib_minor_version<6) return; + + // save some data... + ui.maximize_at_start = (gdk_window_get_state(winMain->window) & GDK_WINDOW_STATE_MAXIMIZED); + if (!ui.maximize_at_start && !ui.fullscreen) + gdk_drawable_get_size(winMain->window, + &ui.window_default_width, &ui.window_default_height); + + update_keyval("general", "display_dpi", + _(" the display resolution, in pixels per inch"), + g_strdup_printf("%.2f", DEFAULT_ZOOM*72)); + update_keyval("general", "initial_zoom", + _(" the initial zoom level, in percent"), + g_strdup_printf("%.2f", 100*ui.zoom/DEFAULT_ZOOM)); + update_keyval("general", "window_maximize", + _(" maximize the window at startup (true/false)"), + g_strdup(ui.maximize_at_start?"true":"false")); + update_keyval("general", "window_fullscreen", + _(" start in full screen mode (true/false)"), + g_strdup(ui.fullscreen?"true":"false")); + update_keyval("general", "window_width", + _(" the window width in pixels (when not maximized)"), + g_strdup_printf("%d", ui.window_default_width)); + update_keyval("general", "window_height", + _(" the window height in pixels"), + g_strdup_printf("%d", ui.window_default_height)); + update_keyval("general", "scrollbar_speed", + _(" scrollbar step increment (in pixels)"), + g_strdup_printf("%d", ui.scrollbar_step_increment)); + update_keyval("general", "zoom_dialog_increment", + _(" the step increment in the zoom dialog box"), + g_strdup_printf("%d", ui.zoom_step_increment)); + update_keyval("general", "zoom_step_factor", + _(" the multiplicative factor for zoom in/out"), + g_strdup_printf("%.3f", ui.zoom_step_factor)); + update_keyval("general", "view_continuous", + _(" document view (true = continuous, false = single page)"), + g_strdup(ui.view_continuous?"true":"false")); + update_keyval("general", "use_xinput", + _(" use XInput extensions (true/false)"), + g_strdup(ui.allow_xinput?"true":"false")); + update_keyval("general", "discard_corepointer", + _(" discard Core Pointer events in XInput mode (true/false)"), + g_strdup(ui.discard_corepointer?"true":"false")); + update_keyval("general", "use_erasertip", + _(" always map eraser tip to eraser (true/false)"), + g_strdup(ui.use_erasertip?"true":"false")); + update_keyval("general", "default_path", + _(" default path for open/save (leave blank for current directory)"), + g_strdup((ui.default_path!=NULL)?ui.default_path:"")); + update_keyval("general", "pressure_sensitivity", + _(" use pressure sensitivity to control pen stroke width (true/false)"), + g_strdup(ui.pressure_sensitivity?"true":"false")); + update_keyval("general", "width_minimum_multiplier", + _(" minimum width multiplier"), + g_strdup_printf("%.2f", ui.width_minimum_multiplier)); + update_keyval("general", "width_maximum_multiplier", + _(" maximum width multiplier"), + g_strdup_printf("%.2f", ui.width_maximum_multiplier)); + update_keyval("general", "interface_order", + _(" interface components from top to bottom\n valid values: drawarea menu main_toolbar pen_toolbar statusbar"), + verbose_vertical_order(ui.vertical_order[0])); + update_keyval("general", "interface_fullscreen", + _(" interface components in fullscreen mode, from top to bottom"), + verbose_vertical_order(ui.vertical_order[1])); + update_keyval("general", "interface_lefthanded", + _(" interface has left-handed scrollbar (true/false)"), + g_strdup(ui.left_handed?"true":"false")); + update_keyval("general", "shorten_menus", + _(" hide some unwanted menu or toolbar items (true/false)"), + g_strdup(ui.shorten_menus?"true":"false")); + update_keyval("general", "shorten_menu_items", + _(" interface items to hide (customize at your own risk!)\n see source file xo-interface.c for a list of item names"), + g_strdup(ui.shorten_menu_items)); + update_keyval("general", "highlighter_opacity", + _(" highlighter opacity (0 to 1, default 0.5)\n warning: opacity level is not saved in xoj files!"), + g_strdup_printf("%.2f", ui.hiliter_opacity)); + update_keyval("general", "autosave_prefs", + _(" auto-save preferences on exit (true/false)"), + g_strdup(ui.auto_save_prefs?"true":"false")); + + update_keyval("paper", "width", + _(" the default page width, in points (1/72 in)"), + g_strdup_printf("%.2f", ui.default_page.width)); + update_keyval("paper", "height", + _(" the default page height, in points (1/72 in)"), + g_strdup_printf("%.2f", ui.default_page.height)); + update_keyval("paper", "color", + _(" the default paper color"), + g_strdup(bgcolor_names[ui.default_page.bg->color_no])); + update_keyval("paper", "style", + _(" the default paper style (plain, lined, ruled, or graph)"), + g_strdup(bgstyle_names[ui.default_page.bg->ruling])); + update_keyval("paper", "apply_all", + _(" apply paper style changes to all pages (true/false)"), + g_strdup(ui.bg_apply_all_pages?"true":"false")); + update_keyval("paper", "default_unit", + _(" preferred unit (cm, in, px, pt)"), + g_strdup(unit_names[ui.default_unit])); + update_keyval("paper", "print_ruling", + _(" include paper ruling when printing or exporting to PDF (true/false)"), + g_strdup(ui.print_ruling?"true":"false")); + update_keyval("paper", "antialias_bg", + _(" antialiased bitmap backgrounds (true/false)"), + g_strdup(ui.antialias_bg?"true":"false")); + update_keyval("paper", "progressive_bg", + _(" just-in-time update of page backgrounds (true/false)"), + g_strdup(ui.progressive_bg?"true":"false")); + update_keyval("paper", "gs_bitmap_dpi", + _(" bitmap resolution of PS/PDF backgrounds rendered using ghostscript (dpi)"), + g_strdup_printf("%d", GS_BITMAP_DPI)); + update_keyval("paper", "pdftoppm_printing_dpi", + _(" bitmap resolution of PDF backgrounds when printing with libgnomeprint (dpi)"), + g_strdup_printf("%d", PDFTOPPM_PRINTING_DPI)); + + update_keyval("tools", "startup_tool", + _(" selected tool at startup (pen, eraser, highlighter, selectrect, vertspace, hand)"), + g_strdup(tool_names[ui.startuptool])); + update_keyval("tools", "pen_color", + _(" default pen color"), + g_strdup(color_names[ui.default_brushes[TOOL_PEN].color_no])); + update_keyval("tools", "pen_thickness", + _(" default pen thickness (fine = 1, medium = 2, thick = 3)"), + g_strdup_printf("%d", ui.default_brushes[TOOL_PEN].thickness_no)); + update_keyval("tools", "pen_ruler", + _(" default pen is in ruler mode (true/false)"), + g_strdup(ui.default_brushes[TOOL_PEN].ruler?"true":"false")); + update_keyval("tools", "pen_recognizer", + _(" default pen is in shape recognizer mode (true/false)"), + g_strdup(ui.default_brushes[TOOL_PEN].recognizer?"true":"false")); + update_keyval("tools", "eraser_thickness", + _(" default eraser thickness (fine = 1, medium = 2, thick = 3)"), + g_strdup_printf("%d", ui.default_brushes[TOOL_ERASER].thickness_no)); + update_keyval("tools", "eraser_mode", + _(" default eraser mode (standard = 0, whiteout = 1, strokes = 2)"), + g_strdup_printf("%d", ui.default_brushes[TOOL_ERASER].tool_options)); + update_keyval("tools", "highlighter_color", + _(" default highlighter color"), + g_strdup(color_names[ui.default_brushes[TOOL_HIGHLIGHTER].color_no])); + update_keyval("tools", "highlighter_thickness", + _(" default highlighter thickness (fine = 1, medium = 2, thick = 3)"), + g_strdup_printf("%d", ui.default_brushes[TOOL_HIGHLIGHTER].thickness_no)); + update_keyval("tools", "highlighter_ruler", + _(" default highlighter is in ruler mode (true/false)"), + g_strdup(ui.default_brushes[TOOL_HIGHLIGHTER].ruler?"true":"false")); + update_keyval("tools", "highlighter_recognizer", + _(" default highlighter is in shape recognizer mode (true/false)"), + g_strdup(ui.default_brushes[TOOL_HIGHLIGHTER].recognizer?"true":"false")); + update_keyval("tools", "btn2_tool", + _(" button 2 tool (pen, eraser, highlighter, text, selectrect, vertspace, hand)"), + g_strdup(tool_names[ui.toolno[1]])); + update_keyval("tools", "btn2_linked", + _(" button 2 brush linked to primary brush (true/false) (overrides all other settings)"), + g_strdup((ui.linked_brush[1]==BRUSH_LINKED)?"true":"false")); + update_keyval("tools", "btn2_color", + _(" button 2 brush color (for pen or highlighter only)"), + g_strdup((ui.toolno[1] sup) return FALSE; + *val = conv; + return TRUE; +} + +gboolean parse_keyval_floatlist(const gchar *group, const gchar *key, double *val, int n, double inf, double sup) +{ + gchar *ret, *end; + double conv[5]; + int i; + + if (n>5) return FALSE; + ret = g_key_file_get_value(ui.config_data, group, key, NULL); + if (ret==NULL) return FALSE; + end = ret; + for (i=0; i sup)) { g_free(ret); return FALSE; } + end++; + } + g_free(ret); + for (i=0; i sup) return FALSE; + *val = conv; + return TRUE; +} + +gboolean parse_keyval_enum(const gchar *group, const gchar *key, int *val, const char **names, int n) +{ + gchar *ret; + int i; + + ret = g_key_file_get_value(ui.config_data, group, key, NULL); + if (ret==NULL) return FALSE; + for (i=0; iVBOX_MAIN_NITEMS) return FALSE; // too many items + for (i=0; i=VBOX_MAIN_NITEMS) { g_free(ret); return FALSE; } // parse error + // we found item #i + tmp[n++] = i; + while (*p==' ') p++; + } + + for (n=0; ncolor_no), bgcolor_names, COLOR_MAX); + ui.default_page.bg->color_rgba = predef_bgcolors_rgba[ui.default_page.bg->color_no]; + parse_keyval_enum("paper", "style", &(ui.default_page.bg->ruling), bgstyle_names, 4); + parse_keyval_boolean("paper", "apply_all", &ui.bg_apply_all_pages); + parse_keyval_enum("paper", "default_unit", &ui.default_unit, unit_names, 4); + parse_keyval_boolean("paper", "antialias_bg", &ui.antialias_bg); + parse_keyval_boolean("paper", "progressive_bg", &ui.progressive_bg); + parse_keyval_boolean("paper", "print_ruling", &ui.print_ruling); + parse_keyval_int("paper", "gs_bitmap_dpi", &GS_BITMAP_DPI, 1, 1200); + parse_keyval_int("paper", "pdftoppm_printing_dpi", &PDFTOPPM_PRINTING_DPI, 1, 1200); + + parse_keyval_enum("tools", "startup_tool", &ui.startuptool, tool_names, NUM_TOOLS); + ui.toolno[0] = ui.startuptool; + parse_keyval_enum("tools", "pen_color", &(ui.brushes[0][TOOL_PEN].color_no), color_names, COLOR_MAX); + parse_keyval_int("tools", "pen_thickness", &(ui.brushes[0][TOOL_PEN].thickness_no), 0, 4); + parse_keyval_boolean("tools", "pen_ruler", &(ui.brushes[0][TOOL_PEN].ruler)); + parse_keyval_boolean("tools", "pen_recognizer", &(ui.brushes[0][TOOL_PEN].recognizer)); + parse_keyval_int("tools", "eraser_thickness", &(ui.brushes[0][TOOL_ERASER].thickness_no), 1, 3); + parse_keyval_int("tools", "eraser_mode", &(ui.brushes[0][TOOL_ERASER].tool_options), 0, 2); + parse_keyval_enum("tools", "highlighter_color", &(ui.brushes[0][TOOL_HIGHLIGHTER].color_no), color_names, COLOR_MAX); + parse_keyval_int("tools", "highlighter_thickness", &(ui.brushes[0][TOOL_HIGHLIGHTER].thickness_no), 0, 4); + parse_keyval_boolean("tools", "highlighter_ruler", &(ui.brushes[0][TOOL_HIGHLIGHTER].ruler)); + parse_keyval_boolean("tools", "highlighter_recognizer", &(ui.brushes[0][TOOL_HIGHLIGHTER].recognizer)); + ui.brushes[0][TOOL_PEN].variable_width = ui.pressure_sensitivity; + for (i=0; i< NUM_STROKE_TOOLS; i++) + for (j=1; j<=NUM_BUTTONS; j++) + g_memmove(&(ui.brushes[j][i]), &(ui.brushes[0][i]), sizeof(struct Brush)); + + parse_keyval_enum("tools", "btn2_tool", &(ui.toolno[1]), tool_names, NUM_TOOLS); + if (parse_keyval_boolean("tools", "btn2_linked", &b)) + ui.linked_brush[1] = b?BRUSH_LINKED:BRUSH_STATIC; + parse_keyval_enum("tools", "btn3_tool", &(ui.toolno[2]), tool_names, NUM_TOOLS); + if (parse_keyval_boolean("tools", "btn3_linked", &b)) + ui.linked_brush[2] = b?BRUSH_LINKED:BRUSH_STATIC; + if (ui.linked_brush[1]!=BRUSH_LINKED) { + if (ui.toolno[1]==TOOL_PEN || ui.toolno[1]==TOOL_HIGHLIGHTER) { + parse_keyval_boolean("tools", "btn2_ruler", &(ui.brushes[1][ui.toolno[1]].ruler)); + parse_keyval_boolean("tools", "btn2_recognizer", &(ui.brushes[1][ui.toolno[1]].recognizer)); + parse_keyval_enum("tools", "btn2_color", &(ui.brushes[1][ui.toolno[1]].color_no), color_names, COLOR_MAX); + } + if (ui.toolno[1]