xo-file.c

高手写的手写代码!欢迎大家下载,共同交流,如果有问题,请联系我!谢谢!

  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("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",
    " progressive scaling of bitmap 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", "startup_ruler",
    " ruler mode at startup (true/false) (for pen or highlighter only)",
    g_strdup(ui.startupruler?"true":"false"));
  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", "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", "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_ruler",
    " button 2 ruler mode (true/false) (for pen or highlighter only)",
    g_strdup(ui.ruler[1]?"true":"false"));
  update_keyval("tools", "btn2_color",
    " button 2 brush color (for pen or highlighter only)",
    g_strdup((ui.toolno[1]<NUM_STROKE_TOOLS)?
               color_names[ui.brushes[1][ui.toolno[1]].color_no]:"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_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_ruler",
    " button 3 ruler mode (true/false) (for pen or highlighter only)",
    g_strdup(ui.ruler[2]?"true":"false"));
  update_keyval("tools", "btn3_color",
    " button 3 brush color (for pen or highlighter only)",
    g_strdup((ui.toolno[2]<NUM_STROKE_TOOLS)?
               color_names[ui.brushes[2][ui.toolno[2]].color_no]:"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_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_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, found, 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_string("general", "default_path", &ui.default_path);
  parse_keyval_vorderlist("general", "interface_order", ui.vertical_order[0]);
  parse_keyval_vorderlist("general", "interface_fullscreen", ui.vertical_order[1]);
  parse_keyval_float("general", "highlighter_opacity", &ui.hiliter_opacity, 0., 1.);
  
  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("paper", "color", &(ui.default_page.bg->color_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;
  if (ui.startuptool == TOOL_PEN || ui.startuptool == TOOL_HIGHLIGHTER) {
    parse_keyval_boolean("tools", "startup_ruler", &ui.startupruler);
    ui.ruler[0] = ui.startupruler;
  }
  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_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);
  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;
  for (i=1; i<=NUM_BUTTONS; i++)
    if (ui.toolno[i]==TOOL_PEN || ui.toolno[i]==TOOL_HIGHLIGHTER)
      ui.ruler[i] = ui.ruler[0];
  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.ruler[1]));
      parse_keyval_enum("tools", "btn2_color", &(ui.brushes[1][ui.toolno[1]].color_no), color_names, 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.ruler[2]));
      parse_keyval_enum("tools", "btn3_color", &(ui.brushes[2][ui.toolno[2]].color_no), color_names, 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"