+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <libgnomecanvas/libgnomecanvas.h>
#include <zlib.h>
#include <math.h>
-#include <gdk/gdkx.h>
-#include <X11/Xlib.h>
#include <locale.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <poppler/glib/poppler.h>
+
+#ifndef WIN32
+ #include <gdk/gdkx.h>
+ #include <X11/Xlib.h>
+#endif
#include "xournal.h"
#include "xo-interface.h"
#include "xo-callbacks.h"
#include "xo-misc.h"
#include "xo-file.h"
+#include "xo-paint.h"
+#include "xo-image.h"
-const char *tool_names[NUM_STROKE_TOOLS] = {"pen", "eraser", "highlighter"};
+const char *tool_names[NUM_TOOLS] = {"pen", "eraser", "highlighter", "text", "", "selectrect", "vertspace", "hand", "image"};
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"};
"", "", "", "", "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
}
}
+/* Write image to file: returns true on success, false on error.
+ The image is written as a base64 encoded PNG. */
+
+gboolean write_image(gzFile f, Item *item)
+{
+ gchar *base64_str;
+
+ if (item->image_png == NULL) {
+ if (!gdk_pixbuf_save_to_buffer(item->image, &item->image_png, &item->image_png_len, "png", NULL, NULL)) {
+ item->image_png_len = 0; // failed for some reason, so forget it
+ return FALSE;
+ }
+ }
+
+ base64_str = g_base64_encode(item->image_png, item->image_png_len);
+ gzputs(f, base64_str);
+ g_free(base64_str);
+ return TRUE;
+}
+
+// create pixbuf from base64 encoded PNG, or return NULL on failure
+
+GdkPixbuf *read_pixbuf(const gchar *base64_str, gsize base64_strlen)
+{
+ gchar *base64_str2;
+ gchar *png_buf;
+ gsize png_buflen;
+ GdkPixbuf *pixbuf;
+
+ // We have to copy the string in order to null terminate it, sigh.
+ base64_str2 = g_memdup(base64_str, base64_strlen+1);
+ base64_str2[base64_strlen] = 0;
+ png_buf = g_base64_decode(base64_str2, &png_buflen);
+
+ pixbuf = pixbuf_from_buffer(png_buf, png_buflen);
+
+ g_free(png_buf);
+ g_free(base64_str2);
+ return pixbuf;
+}
+
// saves the journal to a file: returns true on success, false on error
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;
GtkWidget *dialog;
- f = gzopen(filename, "w");
+ f = gzopen(filename, "wb");
if (f==NULL) return FALSE;
chk_attach_names();
setlocale(LC_NUMERIC, "C");
gzprintf(f, "<?xml version=\"1.0\" standalone=\"no\"?>\n"
- "<title>Xournal document - see http://math.mit.edu/~auroux/software/xournal/</title>\n"
- "<xournal version=\"" VERSION "\"/>\n");
+ "<xournal version=\"" VERSION "\">\n"
+ "<title>Xournal document - see http://math.mit.edu/~auroux/software/xournal/</title>\n");
for (pagelist = journal.pages; pagelist!=NULL; pagelist = pagelist->next) {
pg = (struct Page *)pagelist->data;
gzprintf(f, "<page width=\"%.2f\" height=\"%.2f\">\n", pg->width, pg->height);
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) {
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)
+ tmpf = fopen(tmpfn, "wb");
+ if (tmpf != NULL && fwrite(bgpdf.file_contents, 1, bgpdf.file_length, tmpf) == bgpdf.file_length)
success = TRUE;
- g_free(pdfbuf);
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);
}
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;i<item->path->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</stroke>\n");
}
+ if (item->type == ITEM_TEXT) {
+ tmpstr = g_markup_escape_text(item->font_name, -1);
+ gzprintf(f, "<text font=\"%s\" size=\"%.2f\" x=\"%.2f\" y=\"%.2f\" color=\"",
+ tmpstr, item->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);
+ gzputs(f, "\">");
+ gzputs(f, tmpstr); // gzprintf() can't handle > 4095 bytes
+ gzputs(f, "</text>\n");
+ g_free(tmpstr);
+ }
+ if (item->type == ITEM_IMAGE) {
+ gzprintf(f, "<image left=\"%.2f\" top=\"%.2f\" right=\"%.2f\" bottom=\"%.2f\">",
+ item->bbox.left, item->bbox.top, item->bbox.right, item->bbox.bottom);
+ if (!write_image(f, item)) success = FALSE;
+ gzprintf(f, "</image>\n");
+ }
}
gzprintf(f, "</layer>\n");
}
gzprintf(f, "</page>\n");
}
+ gzprintf(f, "</xournal>\n");
gzclose(f);
setlocale(LC_NUMERIC, "");
// free everything...
reset_selection();
+ reset_recognizer();
clear_redo_stack();
clear_undo_stack();
}
// sanitize a string containing floats, in case it may have , instead of .
+// also replace Windows-produced 1.#J by inf
void cleanup_numeric(char *s)
{
- while (*s!=0) { if (*s==',') *s='.'; s++; }
+ while (*s!=0) {
+ if (*s==',') *s='.';
+ if (*s=='1' && s[1]=='.' && s[2]=='#' && s[3]=='J')
+ { *s='i'; s[1]='n'; s[2]='f'; s[3]=' '; }
+ s++;
+ }
}
// the XML parser functions for open_journal()
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,
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")) {
}
// there's also the case of hex (#rrggbbaa) colors
if (tmpPage->bg->color_no == COLOR_OTHER && **attribute_values == '#') {
- tmpPage->bg->color_rgba = strtol(*attribute_values + 1, &ptr, 16);
+ tmpPage->bg->color_rgba = strtoul(*attribute_values + 1, &ptr, 16);
if (*ptr!=0) *error = xoj_invalid();
}
has_attr |= 2;
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);
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
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")) {
}
// 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);
+ tmpItem->brush.color_rgba = strtoul(*attribute_values + 1, &ptr, 16);
if (*ptr!=0) *error = xoj_invalid();
}
has_attr |= 2;
// 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; i<COLOR_MAX; i++)
+ if (!strcmp(*attribute_values, color_names[i])) {
+ tmpItem->brush.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 = strtoul(*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();
+ }
+ else if (!strcmp(element_name, "image")) { // start of a image item
+ if (tmpLayer == NULL || tmpItem != NULL) {
+ *error = xoj_invalid();
+ return;
+ }
+ tmpItem = (struct Item *)g_malloc0(sizeof(struct Item));
+ tmpItem->type = ITEM_IMAGE;
+ tmpItem->canvas_item = NULL;
+ tmpItem->image=NULL;
+ tmpItem->image_png = NULL;
+ tmpItem->image_png_len = 0;
+ tmpLayer->items = g_list_append(tmpLayer->items, tmpItem);
+ tmpLayer->nitems++;
+ // scan for x, y
+ has_attr = 0;
+ while (*attribute_names!=NULL) {
+ if (!strcmp(*attribute_names, "left")) {
+ if (has_attr & 1) *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 |= 1;
+ }
+ else if (!strcmp(*attribute_names, "top")) {
+ if (has_attr & 2) *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 |= 2;
+ }
+ else if (!strcmp(*attribute_names, "right")) {
+ if (has_attr & 4) *error = xoj_invalid();
+ cleanup_numeric((gchar *)*attribute_values);
+ tmpItem->bbox.right = g_ascii_strtod(*attribute_values, &ptr);
+ if (ptr == *attribute_values) *error = xoj_invalid();
+ has_attr |= 4;
+ }
+ else if (!strcmp(*attribute_names, "bottom")) {
+ if (has_attr & 8) *error = xoj_invalid();
+ cleanup_numeric((gchar *)*attribute_values);
+ tmpItem->bbox.bottom = g_ascii_strtod(*attribute_values, &ptr);
+ if (ptr == *attribute_values) *error = xoj_invalid();
+ has_attr |= 8;
+ }
+ else *error = xoj_invalid();
+ attribute_names++;
+ attribute_values++;
}
+ if (has_attr!=15) *error = xoj_invalid();
}
}
update_item_bbox(tmpItem);
tmpItem = NULL;
}
+ if (!strcmp(element_name, "text")) {
+ if (tmpItem == NULL) {
+ *error = xoj_invalid();
+ return;
+ }
+ tmpItem = NULL;
+ }
+ if (!strcmp(element_name, "image")) {
+ if (tmpItem == NULL) {
+ *error = xoj_invalid();
+ return;
+ }
+ tmpItem = NULL;
+ }
}
void xoj_parser_text(GMarkupParseContext *context,
if (ptr == text) break;
text_len -= (ptr - text);
text = ptr;
+ if (!finite_sized(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;
+ }
+ if (!strcmp(element_name, "image")) {
+ tmpItem->image = read_pixbuf(text, text_len);
+ }
}
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_OK, NULL);
-
+#ifdef FILE_DIALOG_SIZE_BUGFIX
+ gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
+#endif
+
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 (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 FALSE;
gzFile f;
char buffer[1000];
int len;
- gchar *tmpfn;
+ gchar *tmpfn, *tmpfn2, *p, *q;
gboolean maybe_pdf;
- f = gzopen(filename, "r");
+ tmpfn = g_strdup_printf("%s.xoj", filename);
+ if (ui.autoload_pdf_xoj && g_file_test(tmpfn, G_FILE_TEST_EXISTS) &&
+ (g_str_has_suffix(filename, ".pdf") || g_str_has_suffix(filename, ".PDF")))
+ {
+ valid = open_journal(tmpfn);
+ g_free(tmpfn);
+ return valid;
+ }
+ g_free(tmpfn);
+
+ f = gzopen(filename, "rb");
if (f==NULL) return FALSE;
+ if (filename[0]=='/') {
+ if (ui.default_path != NULL) g_free(ui.default_path);
+ ui.default_path = g_path_get_dirname(filename);
+ }
context = g_markup_parse_context_new(&parser, 0, NULL, NULL);
valid = TRUE;
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);
else
tmpfn = g_strdup(tmpBg_pdf->filename->s);
valid = init_bgpdf(tmpfn, FALSE, tmpBg_pdf->file_domain);
- // in case the file name became invalid
+ // if file name is invalid: first try in xoj file's directory
+ if (!valid && tmpBg_pdf->file_domain != DOMAIN_ATTACH) {
+ p = g_path_get_dirname(filename);
+ q = g_path_get_basename(tmpfn);
+ tmpfn2 = g_strdup_printf("%s/%s", p, q);
+ g_free(p); g_free(q);
+ valid = init_bgpdf(tmpfn2, FALSE, tmpBg_pdf->file_domain);
+ if (valid) { // change the file name...
+ printf("substituting %s -> %s\n", tmpfn, tmpfn2);
+ g_free(tmpBg_pdf->filename->s);
+ tmpBg_pdf->filename->s = tmpfn2;
+ }
+ else g_free(tmpfn2);
+ }
+ // if file name is invalid: next prompt user
if (!valid && tmpBg_pdf->file_domain != DOMAIN_ATTACH)
if (user_wants_second_chance(&tmpfn)) {
valid = init_bgpdf(tmpfn, FALSE, tmpBg_pdf->file_domain);
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);
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;
}
char *pipename;
int buflen, remnlen, file_pageno;
+ f = fopen(filename, "rb");
+ if (f == NULL) return NULL;
buf = g_malloc(BUFSIZE); // a reasonable buffer size
- f = fopen(filename, "r");
if (fread(buf, 1, 4, f) !=4 ||
(strncmp((char *)buf, "%!PS", 4) && strncmp((char *)buf, "%PDF", 4))) {
fclose(f);
fclose(f);
pipename = g_strdup_printf(GS_CMDLINE, (double)GS_BITMAP_DPI, filename);
- gs_pipe = popen(pipename, "r");
+ gs_pipe = popen(pipename, "rb");
g_free(pipename);
bg_list = NULL;
struct Background *attempt_screenshot_bg(void)
{
+#ifndef WIN32
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();
bg->filename = new_refstring(NULL);
bg->file_domain = DOMAIN_ATTACH;
return bg;
+#else
+ // not implemented under WIN32
+ return FALSE;
+#endif
}
/************** 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)
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;
+ GdkPixmap *pixmap;
+ cairo_t *cr;
+
+ // 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);
+
+ if (ui.poppler_force_cairo) { // poppler -> cairo -> pixmap -> pixbuf
+ pixmap = gdk_pixmap_new(GTK_WIDGET(canvas)->window, scaled_width, scaled_height, -1);
+ cr = gdk_cairo_create(pixmap);
+ cairo_set_source_rgb(cr, 1., 1., 1.);
+ cairo_paint(cr);
+ cairo_scale(cr, scaled_width/width, scaled_height/height);
+ poppler_page_render(pdfpage, cr);
+ cairo_destroy(cr);
+ pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(pixmap),
+ NULL, 0, 0, 0, 0, scaled_width, scaled_height);
+ g_object_unref(pixmap);
+ }
+ else { // directly poppler -> pixbuf: faster, but bitmap font bug
+ pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
+ FALSE, 8, scaled_width, scaled_height);
+ wrapper_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;
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)
+gboolean 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 FALSE; // 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);
+ return TRUE;
}
/* shutdown the PDF reader */
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);
}
- 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 */
+ g_list_free(bgpdf.requests);
+
+ if (bgpdf.file_contents!=NULL) {
+ g_free(bgpdf.file_contents);
+ bgpdf.file_contents = NULL;
+ }
+ 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;
+ gchar *uri;
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;
- 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...
+/* poppler_document_new_from_data() starts at 0.6.1, but we want to
+ be compatible with poppler 0.5.4 = latest in CentOS as of sept 2009 */
+ uri = g_filename_to_uri(pdfname, NULL, NULL);
+ if (!uri) uri = g_strdup_printf("file://%s", pdfname);
+ bgpdf.document = poppler_document_new_from_file(uri, NULL, NULL);
+ g_free(uri);
+/* with poppler 0.6.1 or later, can replace the above 4 lines by:
+ bgpdf.document = poppler_document_new_from_data(bgpdf.file_contents,
+ bgpdf.file_length, NULL, NULL);
+*/
+ if (bgpdf.document == NULL) { shutdown_bgpdf(); return FALSE; }
+
+ if (pdfname[0]=='/' && ui.filename == NULL) {
+ if (ui.default_path!=NULL) g_free(ui.default_path);
+ ui.default_path = g_path_get_dirname(pdfname);
}
+
+ 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)
{
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);
}
}
{
int i;
gboolean anyone = FALSE;
+ gchar *tmp;
for (i=0; i<MRU_SIZE; i++) {
if (ui.mru[i]!=NULL) {
- gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(ui.mrumenu[i]))),
- g_basename(ui.mru[i]));
+ tmp = g_strdup_printf("_%d %s", i+1,
+ g_strjoinv("__", g_strsplit_set(g_basename(ui.mru[i]),"_",-1)));
+ gtk_label_set_text_with_mnemonic(GTK_LABEL(gtk_bin_get_child(GTK_BIN(ui.mrumenu[i]))),
+ tmp);
+ g_free(tmp);
gtk_widget_show(ui.mrumenu[i]);
anyone = TRUE;
}
if (ui.mru[i]!=NULL) fprintf(f, "%s\n", ui.mru[i]);
fclose(f);
}
+
+void init_config_default(void)
+{
+ int i, j;
+
+ DEFAULT_ZOOM = DISPLAY_DPI_DEFAULT/72.0;
+ ui.zoom = ui.startup_zoom = 1.0*DEFAULT_ZOOM;
+ ui.default_page.height = 792.0;
+ ui.default_page.width = 612.0;
+ ui.default_page.bg->type = 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.progressive_bg = TRUE;
+ ui.print_ruling = TRUE;
+ ui.default_unit = UNIT_CM;
+ ui.default_path = NULL;
+ ui.default_image = 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;
+ ui.button_switch_mapping = FALSE;
+ ui.autoload_pdf_xoj = FALSE;
+ ui.poppler_force_cairo = FALSE;
+
+ // 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 GTK_CHECK_VERSION(2,10,0)
+ ui.print_settings = NULL;
+#endif
+
+}
+
+#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; i++) {
+ if (order[i]<0 || order[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", "buttons_switch_mappings",
+ _(" buttons 2 and 3 switch mappings instead of drawing (useful for some tablets) (true/false)"),
+ g_strdup(ui.button_switch_mapping?"true":"false"));
+ update_keyval("general", "autoload_pdf_xoj",
+ _(" automatically load filename.pdf.xoj instead of filename.pdf (true/false)"),
+ g_strdup(ui.autoload_pdf_xoj?"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("general", "poppler_force_cairo",
+ _(" force PDF rendering through cairo (slower but nicer) (true/false)"),
+ g_strdup(ui.poppler_force_cairo?"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"),
+ (ui.default_page.bg->color_no>=0)?
+ g_strdup(bgcolor_names[ui.default_page.bg->color_no]):
+ g_strdup_printf("#%08x", ui.default_page.bg->color_rgba));
+ 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", "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"),
+ (ui.default_brushes[TOOL_PEN].color_no>=0)?
+ g_strdup(color_names[ui.default_brushes[TOOL_PEN].color_no]):
+ g_strdup_printf("#%08x", ui.default_brushes[TOOL_PEN].color_rgba));
+ 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"),
+ (ui.default_brushes[TOOL_HIGHLIGHTER].color_no>=0)?
+ g_strdup(color_names[ui.default_brushes[TOOL_HIGHLIGHTER].color_no]):
+ g_strdup_printf("#%08x", ui.default_brushes[TOOL_HIGHLIGHTER].color_rgba));
+ 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)"),
+ (ui.toolno[1]<NUM_STROKE_TOOLS)?
+ ((ui.brushes[1][ui.toolno[1]].color_no>=0)?
+ g_strdup(color_names[ui.brushes[1][ui.toolno[1]].color_no]):
+ g_strdup_printf("#%08x", ui.brushes[1][ui.toolno[1]].color_rgba)):
+ g_strdup("white"));
+ update_keyval("tools", "btn2_thickness",
+ _(" button 2 brush thickness (pen, eraser, or highlighter only)"),
+ g_strdup_printf("%d", (ui.toolno[1]<NUM_STROKE_TOOLS)?
+ ui.brushes[1][ui.toolno[1]].thickness_no:0));
+ update_keyval("tools", "btn2_ruler",
+ _(" button 2 ruler mode (true/false) (for pen or highlighter only)"),
+ g_strdup(((ui.toolno[1]<NUM_STROKE_TOOLS)?
+ ui.brushes[1][ui.toolno[1]].ruler:FALSE)?"true":"false"));
+ update_keyval("tools", "btn2_recognizer",
+ _(" button 2 shape recognizer mode (true/false) (pen or highlighter only)"),
+ g_strdup(((ui.toolno[1]<NUM_STROKE_TOOLS)?
+ ui.brushes[1][ui.toolno[1]].recognizer:FALSE)?"true":"false"));
+ update_keyval("tools", "btn2_erasermode",
+ _(" button 2 eraser mode (eraser only)"),
+ g_strdup_printf("%d", ui.brushes[1][TOOL_ERASER].tool_options));
+ update_keyval("tools", "btn3_tool",
+ _(" button 3 tool (pen, eraser, highlighter, text, selectrect, vertspace, hand)"),
+ g_strdup(tool_names[ui.toolno[2]]));
+ update_keyval("tools", "btn3_linked",
+ _(" button 3 brush linked to primary brush (true/false) (overrides all other settings)"),
+ g_strdup((ui.linked_brush[2]==BRUSH_LINKED)?"true":"false"));
+ update_keyval("tools", "btn3_color",
+ _(" button 3 brush color (for pen or highlighter only)"),
+ (ui.toolno[2]<NUM_STROKE_TOOLS)?
+ ((ui.brushes[2][ui.toolno[2]].color_no>=0)?
+ g_strdup(color_names[ui.brushes[2][ui.toolno[2]].color_no]):
+ g_strdup_printf("#%08x", ui.brushes[2][ui.toolno[2]].color_rgba)):
+ g_strdup("white"));
+ update_keyval("tools", "btn3_thickness",
+ _(" button 3 brush thickness (pen, eraser, or highlighter only)"),
+ g_strdup_printf("%d", (ui.toolno[2]<NUM_STROKE_TOOLS)?
+ ui.brushes[2][ui.toolno[2]].thickness_no:0));
+ update_keyval("tools", "btn3_ruler",
+ _(" button 3 ruler mode (true/false) (for pen or highlighter only)"),
+ g_strdup(((ui.toolno[2]<NUM_STROKE_TOOLS)?
+ ui.brushes[2][ui.toolno[2]].ruler:FALSE)?"true":"false"));
+ update_keyval("tools", "btn3_recognizer",
+ _(" button 3 shape recognizer mode (true/false) (pen or highlighter only)"),
+ g_strdup(((ui.toolno[2]<NUM_STROKE_TOOLS)?
+ ui.brushes[2][ui.toolno[2]].recognizer:FALSE)?"true":"false"));
+ update_keyval("tools", "btn3_erasermode",
+ _(" button 3 eraser mode (eraser only)"),
+ g_strdup_printf("%d", ui.brushes[2][TOOL_ERASER].tool_options));
+
+ update_keyval("tools", "pen_thicknesses",
+ _(" thickness of the various pens (in points, 1 pt = 1/72 in)"),
+ g_strdup_printf("%.2f;%.2f;%.2f;%.2f;%.2f",
+ predef_thickness[TOOL_PEN][0], predef_thickness[TOOL_PEN][1],
+ predef_thickness[TOOL_PEN][2], predef_thickness[TOOL_PEN][3],
+ predef_thickness[TOOL_PEN][4]));
+ update_keyval("tools", "eraser_thicknesses",
+ _(" thickness of the various erasers (in points, 1 pt = 1/72 in)"),
+ g_strdup_printf("%.2f;%.2f;%.2f",
+ predef_thickness[TOOL_ERASER][1], predef_thickness[TOOL_ERASER][2],
+ predef_thickness[TOOL_ERASER][3]));
+ update_keyval("tools", "highlighter_thicknesses",
+ _(" thickness of the various highlighters (in points, 1 pt = 1/72 in)"),
+ g_strdup_printf("%.2f;%.2f;%.2f",
+ predef_thickness[TOOL_HIGHLIGHTER][1], predef_thickness[TOOL_HIGHLIGHTER][2],
+ predef_thickness[TOOL_HIGHLIGHTER][3]));
+ update_keyval("tools", "default_font",
+ _(" name of the default font"),
+ g_strdup(ui.default_font_name));
+ update_keyval("tools", "default_font_size",
+ _(" default font size"),
+ g_strdup_printf("%.1f", ui.default_font_size));
+
+ buf = g_key_file_to_data(ui.config_data, NULL, NULL);
+ if (buf == NULL) return;
+ f = fopen(ui.configfile, "w");
+ if (f==NULL) { g_free(buf); return; }
+ fputs(buf, f);
+ fclose(f);
+ g_free(buf);
+#endif
+}
+
+#if GLIB_CHECK_VERSION(2,6,0)
+gboolean parse_keyval_float(const gchar *group, const gchar *key, double *val, double inf, double sup)
+{
+ gchar *ret, *end;
+ double conv;
+
+ ret = g_key_file_get_value(ui.config_data, group, key, NULL);
+ if (ret==NULL) return FALSE;
+ conv = g_ascii_strtod(ret, &end);
+ if (*end!=0) { g_free(ret); return FALSE; }
+ g_free(ret);
+ if (conv < inf || conv > 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<n; i++) {
+ conv[i] = g_ascii_strtod(end, &end);
+ if ((i==n-1 && *end!=0) || (i<n-1 && *end!=';') ||
+ (conv[i] < inf) || (conv[i] > sup)) { g_free(ret); return FALSE; }
+ end++;
+ }
+ g_free(ret);
+ for (i=0; i<n; i++) val[i] = conv[i];
+ return TRUE;
+}
+
+gboolean parse_keyval_int(const gchar *group, const gchar *key, int *val, int inf, int sup)
+{
+ gchar *ret, *end;
+ int conv;
+
+ ret = g_key_file_get_value(ui.config_data, group, key, NULL);
+ if (ret==NULL) return FALSE;
+ conv = strtol(ret, &end, 10);
+ if (*end!=0) { g_free(ret); return FALSE; }
+ g_free(ret);
+ if (conv < inf || conv > 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; i<n; i++) {
+ if (!names[i][0]) continue; // "" is for invalid values
+ if (!g_ascii_strcasecmp(ret, names[i]))
+ { *val = i; g_free(ret); return TRUE; }
+ }
+ return FALSE;
+}
+
+gboolean parse_keyval_enum_color(const gchar *group, const gchar *key, int *val, guint *val_rgba,
+ const char **names, const guint *predef_rgba, 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; i<n; i++) {
+ if (!names[i][0]) continue; // "" is for invalid values
+ if (!g_ascii_strcasecmp(ret, names[i]))
+ { *val = i; *val_rgba = predef_rgba[i]; g_free(ret); return TRUE; }
+ }
+ if (ret[0]=='#') {
+ *val = COLOR_OTHER;
+ *val_rgba = strtoul(ret+1, NULL, 16);
+ g_free(ret);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+gboolean parse_keyval_boolean(const gchar *group, const gchar *key, gboolean *val)
+{
+ gchar *ret;
+
+ ret = g_key_file_get_value(ui.config_data, group, key, NULL);
+ if (ret==NULL) return FALSE;
+ if (!g_ascii_strcasecmp(ret, "true"))
+ { *val = TRUE; g_free(ret); return TRUE; }
+ if (!g_ascii_strcasecmp(ret, "false"))
+ { *val = FALSE; g_free(ret); return TRUE; }
+ g_free(ret);
+ return FALSE;
+}
+
+gboolean parse_keyval_string(const gchar *group, const gchar *key, gchar **val)
+{
+ gchar *ret;
+
+ ret = g_key_file_get_value(ui.config_data, group, key, NULL);
+ if (ret==NULL) return FALSE;
+ if (strlen(ret) == 0) {
+ *val = NULL;
+ g_free(ret);
+ }
+ else *val = ret;
+ return TRUE;
+}
+
+gboolean parse_keyval_vorderlist(const gchar *group, const gchar *key, int *order)
+{
+ gchar *ret, *p;
+ int tmp[VBOX_MAIN_NITEMS];
+ int i, n, l;
+
+ ret = g_key_file_get_value(ui.config_data, group, key, NULL);
+ if (ret==NULL) return FALSE;
+
+ for (i=0; i<VBOX_MAIN_NITEMS; i++) tmp[i] = -1;
+ n = 0; p = ret;
+ while (*p==' ') p++;
+ while (*p!=0) {
+ if (n>VBOX_MAIN_NITEMS) return FALSE; // too many items
+ for (i=0; i<VBOX_MAIN_NITEMS; i++) {
+ if (!g_str_has_prefix(p, vorder_usernames[i])) continue;
+ l = strlen(vorder_usernames[i]);
+ if (p[l]==' '||p[l]==0) { p+=l; break; }
+ }
+ if (i>=VBOX_MAIN_NITEMS) { g_free(ret); return FALSE; } // parse error
+ // we found item #i
+ tmp[n++] = i;
+ while (*p==' ') p++;
+ }
+
+ for (n=0; n<VBOX_MAIN_NITEMS; n++) order[n] = tmp[n];
+ g_free(ret);
+ return TRUE;
+}
+
+#endif
+
+void load_config_from_file(void)
+{
+ double f;
+ gboolean b;
+ int i, j;
+ gchar *str;
+
+#if GLIB_CHECK_VERSION(2,6,0)
+ // no support for keyval files before Glib 2.6.0
+ if (glib_minor_version<6) return;
+ ui.config_data = g_key_file_new();
+ if (!g_key_file_load_from_file(ui.config_data, ui.configfile,
+ G_KEY_FILE_KEEP_COMMENTS, NULL)) {
+ g_key_file_free(ui.config_data);
+ ui.config_data = g_key_file_new();
+ g_key_file_set_comment(ui.config_data, NULL, NULL,
+ _(" Xournal configuration file.\n"
+ " This file is generated automatically upon saving preferences.\n"
+ " Use caution when editing this file manually.\n"), NULL);
+ return;
+ }
+
+ // parse keys from the keyfile to set defaults
+ if (parse_keyval_float("general", "display_dpi", &f, 10., 500.))
+ DEFAULT_ZOOM = f/72.0;
+ if (parse_keyval_float("general", "initial_zoom", &f,
+ MIN_ZOOM*100/DEFAULT_ZOOM, MAX_ZOOM*100/DEFAULT_ZOOM))
+ ui.zoom = ui.startup_zoom = DEFAULT_ZOOM*f/100.0;
+ parse_keyval_boolean("general", "window_maximize", &ui.maximize_at_start);
+ parse_keyval_boolean("general", "window_fullscreen", &ui.fullscreen);
+ parse_keyval_int("general", "window_width", &ui.window_default_width, 10, 5000);
+ parse_keyval_int("general", "window_height", &ui.window_default_height, 10, 5000);
+ parse_keyval_int("general", "scrollbar_speed", &ui.scrollbar_step_increment, 1, 5000);
+ parse_keyval_int("general", "zoom_dialog_increment", &ui.zoom_step_increment, 1, 500);
+ parse_keyval_float("general", "zoom_step_factor", &ui.zoom_step_factor, 1., 5.);
+ parse_keyval_boolean("general", "view_continuous", &ui.view_continuous);
+ parse_keyval_boolean("general", "use_xinput", &ui.allow_xinput);
+ parse_keyval_boolean("general", "discard_corepointer", &ui.discard_corepointer);
+ parse_keyval_boolean("general", "use_erasertip", &ui.use_erasertip);
+ parse_keyval_boolean("general", "buttons_switch_mappings", &ui.button_switch_mapping);
+ parse_keyval_boolean("general", "autoload_pdf_xoj", &ui.autoload_pdf_xoj);
+ parse_keyval_string("general", "default_path", &ui.default_path);
+ parse_keyval_boolean("general", "pressure_sensitivity", &ui.pressure_sensitivity);
+ parse_keyval_float("general", "width_minimum_multiplier", &ui.width_minimum_multiplier, 0., 10.);
+ parse_keyval_float("general", "width_maximum_multiplier", &ui.width_maximum_multiplier, 0., 10.);
+
+ parse_keyval_vorderlist("general", "interface_order", ui.vertical_order[0]);
+ parse_keyval_vorderlist("general", "interface_fullscreen", ui.vertical_order[1]);
+ parse_keyval_boolean("general", "interface_lefthanded", &ui.left_handed);
+ parse_keyval_boolean("general", "shorten_menus", &ui.shorten_menus);
+ if (parse_keyval_string("general", "shorten_menu_items", &str))
+ if (str!=NULL) { g_free(ui.shorten_menu_items); ui.shorten_menu_items = str; }
+ parse_keyval_float("general", "highlighter_opacity", &ui.hiliter_opacity, 0., 1.);
+ parse_keyval_boolean("general", "autosave_prefs", &ui.auto_save_prefs);
+ parse_keyval_boolean("general", "poppler_force_cairo", &ui.poppler_force_cairo);
+
+ parse_keyval_float("paper", "width", &ui.default_page.width, 1., 5000.);
+ parse_keyval_float("paper", "height", &ui.default_page.height, 1., 5000.);
+ parse_keyval_enum_color("paper", "color",
+ &(ui.default_page.bg->color_no), &(ui.default_page.bg->color_rgba),
+ bgcolor_names, predef_bgcolors_rgba, COLOR_MAX);
+ 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", "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_color("tools", "pen_color",
+ &(ui.brushes[0][TOOL_PEN].color_no), &(ui.brushes[0][TOOL_PEN].color_rgba),
+ color_names, predef_colors_rgba, 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_color("tools", "highlighter_color",
+ &(ui.brushes[0][TOOL_HIGHLIGHTER].color_no), &(ui.brushes[0][TOOL_HIGHLIGHTER].color_rgba),
+ color_names, predef_colors_rgba, 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_color("tools", "btn2_color",
+ &(ui.brushes[1][ui.toolno[1]].color_no), &(ui.brushes[1][ui.toolno[1]].color_rgba),
+ color_names, predef_colors_rgba, COLOR_MAX);
+ }
+ if (ui.toolno[1]<NUM_STROKE_TOOLS)
+ parse_keyval_int("tools", "btn2_thickness", &(ui.brushes[1][ui.toolno[1]].thickness_no), 0, 4);
+ if (ui.toolno[1]==TOOL_ERASER)
+ parse_keyval_int("tools", "btn2_erasermode", &(ui.brushes[1][TOOL_ERASER].tool_options), 0, 2);
+ }
+ if (ui.linked_brush[2]!=BRUSH_LINKED) {
+ if (ui.toolno[2]==TOOL_PEN || ui.toolno[2]==TOOL_HIGHLIGHTER) {
+ parse_keyval_boolean("tools", "btn3_ruler", &(ui.brushes[2][ui.toolno[2]].ruler));
+ parse_keyval_boolean("tools", "btn3_recognizer", &(ui.brushes[2][ui.toolno[2]].recognizer));
+ parse_keyval_enum_color("tools", "btn3_color",
+ &(ui.brushes[2][ui.toolno[2]].color_no), &(ui.brushes[2][ui.toolno[2]].color_rgba),
+ color_names, predef_colors_rgba, COLOR_MAX);
+ }
+ if (ui.toolno[2]<NUM_STROKE_TOOLS)
+ parse_keyval_int("tools", "btn3_thickness", &(ui.brushes[2][ui.toolno[2]].thickness_no), 0, 4);
+ if (ui.toolno[2]==TOOL_ERASER)
+ parse_keyval_int("tools", "btn3_erasermode", &(ui.brushes[2][TOOL_ERASER].tool_options), 0, 2);
+ }
+ parse_keyval_floatlist("tools", "pen_thicknesses", predef_thickness[TOOL_PEN], 5, 0.01, 1000.0);
+ parse_keyval_floatlist("tools", "eraser_thicknesses", predef_thickness[TOOL_ERASER]+1, 3, 0.01, 1000.0);
+ parse_keyval_floatlist("tools", "highlighter_thicknesses", predef_thickness[TOOL_HIGHLIGHTER]+1, 3, 0.01, 1000.0);
+ if (parse_keyval_string("tools", "default_font", &str))
+ if (str!=NULL) { g_free(ui.default_font_name); ui.default_font_name = str; }
+ parse_keyval_float("tools", "default_font_size", &ui.default_font_size, 1., 200.);
+#endif
+}
projects / xournal.git / blobdiff