xo-callbacks.c

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

      ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
    ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
    undo->val = -1;
    undo->layer2 = ui.cur_layer;
  }

  update_page_stuff();
}


void
on_journalFlatten_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{

}


// the paper sizes dialog

GtkWidget *papersize_dialog;
int papersize_std, papersize_unit;
double papersize_width, papersize_height;
gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;

#define STD_SIZE_A4 0
#define STD_SIZE_A4R 1
#define STD_SIZE_LETTER 2
#define STD_SIZE_LETTER_R 3
#define STD_SIZE_CUSTOM 4

double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
double std_widths[STD_SIZE_CUSTOM] =  {595.27, 841.89, 612., 792.};
double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};

void
on_journalPaperSize_activate           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  int i, response;
  struct Page *pg;
  GList *pglist;
  
  end_text();
  reset_focus();
  papersize_dialog = create_papersizeDialog();
  papersize_width = ui.cur_page->width;
  papersize_height = ui.cur_page->height;
  papersize_unit = ui.default_unit;
  unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
//  if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
  papersize_std = STD_SIZE_CUSTOM;
  for (i=0;i<STD_SIZE_CUSTOM;i++)
    if (fabs(papersize_width - std_widths[i])<0.1 &&
        fabs(papersize_height - std_heights[i])<0.1)
      { papersize_std = i; papersize_unit = std_units[i]; }
  papersize_need_init = TRUE;
  papersize_width_valid = papersize_height_valid = TRUE;
      
  gtk_widget_show(papersize_dialog);
  on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
       G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
  gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
       
  response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
  gtk_widget_destroy(papersize_dialog);
  if (response != GTK_RESPONSE_OK) return;

  pg = ui.cur_page;
  for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
    if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
    prepare_new_undo();
    if (ui.bg_apply_all_pages) {
      if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
      if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
    }
    undo->type = ITEM_PAPER_RESIZE;
    undo->page = pg;
    undo->val_x = pg->width;
    undo->val_y = pg->height;
    if (papersize_width_valid) pg->width = papersize_width;
    if (papersize_height_valid) pg->height = papersize_height;
    make_page_clipbox(pg);
    update_canvas_bg(pg);
    if (!ui.bg_apply_all_pages) break;
  }
  do_switch_page(ui.pageno, TRUE, TRUE);
}


void
on_papercolorWhite_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_papercolor_activate(menuitem, COLOR_WHITE);
}


void
on_papercolorYellow_activate           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_papercolor_activate(menuitem, COLOR_YELLOW);
}


void
on_papercolorPink_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_papercolor_activate(menuitem, COLOR_RED);
}


void
on_papercolorOrange_activate           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_papercolor_activate(menuitem, COLOR_ORANGE);
}


void
on_papercolorBlue_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_papercolor_activate(menuitem, COLOR_BLUE);
}


void
on_papercolorGreen_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_papercolor_activate(menuitem, COLOR_GREEN);
}


void
on_papercolorOther_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{

}


void
on_paperstylePlain_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_paperstyle_activate(menuitem, RULING_NONE);
}


void
on_paperstyleLined_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_paperstyle_activate(menuitem, RULING_LINED);
}


void
on_paperstyleRuled_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_paperstyle_activate(menuitem, RULING_RULED);
}


void
on_paperstyleGraph_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  end_text();
  reset_focus();
  process_paperstyle_activate(menuitem, RULING_GRAPH);
}


void
on_journalLoadBackground_activate      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  GtkWidget *dialog, *attach_opt;
  struct Background *bg;
  struct Page *pg;
  int pageno;
  GList *bglist, *bglistiter;
  GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
  char *filename;
  gboolean attach;
  
  end_text();
  reset_focus();
  dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
     GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
     GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);

  filt_all = gtk_file_filter_new();
  gtk_file_filter_set_name(filt_all, "All files");
  gtk_file_filter_add_pattern(filt_all, "*");
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);

#if GTK_CHECK_VERSION(2,6,0)

  if (!gtk_check_version(2, 6, 0)) {
    filt_pix = gtk_file_filter_new();
    gtk_file_filter_set_name(filt_pix, "Bitmap files");
    gtk_file_filter_add_pixbuf_formats(filt_pix);
    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
  }
  
#endif

  filt_pspdf = gtk_file_filter_new();
  gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
  gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
  gtk_file_filter_add_pattern(filt_pspdf, "*.PS");
  gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
  gtk_file_filter_add_pattern(filt_pspdf, "*.PDF");
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);

  attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
  gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);

  if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
  
  if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
    gtk_widget_destroy(dialog);
    return;
  }
  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
  attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
  gtk_widget_destroy(dialog);
  
  set_cursor_busy(TRUE);
  bg = attempt_load_pix_bg(filename, attach);
  if (bg != NULL) bglist = g_list_append(NULL, bg);
  else bglist = attempt_load_gv_bg(filename);
  set_cursor_busy(FALSE);
  
  if (bglist == NULL) {
    dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
      GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
      "Error opening background '%s'", filename);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
    g_free(filename);
    return;
  }

  g_free(filename);
  reset_selection();
  pageno = ui.pageno;

  for (bglistiter = bglist, pageno = ui.pageno; 
           bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
    prepare_new_undo();
    if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
    if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;

    bg = (struct Background *)bglistiter->data;
    
    if (pageno == journal.npages) {
      undo->type = ITEM_NEW_PAGE;
      pg = new_page_with_bg(bg, 
              gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
              gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
      journal.pages = g_list_append(journal.pages, pg);
      journal.npages++;
      undo->val = pageno;
      undo->page = pg;
    } else
    {
      pg = g_list_nth_data(journal.pages, pageno);
      undo->type = ITEM_NEW_BG_RESIZE;
      undo->page = pg;
      undo->bg = pg->bg;
      bg->canvas_item = undo->bg->canvas_item;
      undo->bg->canvas_item = NULL;
      undo->val_x = pg->width;
      undo->val_y = pg->height;
      pg->bg = bg;
      pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
      pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
      make_page_clipbox(pg);
      update_canvas_bg(pg);
    }
  }

  g_list_free(bglist);
  if (ui.zoom != DEFAULT_ZOOM) {
    ui.zoom = DEFAULT_ZOOM;
    gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
    rescale_text_items();
    rescale_bg_pixmaps();
  }
  do_switch_page(ui.pageno, TRUE, TRUE);
}

void
on_journalScreenshot_activate          (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  struct Background *bg;
  
  end_text();
  reset_focus();
  reset_selection();
  gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
  gdk_display_sync(gdk_display_get_default());

  if (ui.cursor!=NULL)
    gdk_cursor_unref(ui.cursor);
  ui.cursor = gdk_cursor_new(GDK_TCROSS);

  bg = attempt_screenshot_bg();
    
  gtk_window_deiconify(GTK_WINDOW(winMain));
  update_cursor();
  if (bg==NULL) return;

  prepare_new_undo();
  undo->type = ITEM_NEW_BG_RESIZE;
  undo->page = ui.cur_page;
  undo->bg = ui.cur_page->bg;
  bg->canvas_item = undo->bg->canvas_item;
  undo->bg->canvas_item = NULL;
  undo->val_x = ui.cur_page->width;
  undo->val_y = ui.cur_page->height;

  ui.cur_page->bg = bg;
  ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
  ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;

  make_page_clipbox(ui.cur_page);
  update_canvas_bg(ui.cur_page);

  if (ui.zoom != DEFAULT_ZOOM) {
    ui.zoom = DEFAULT_ZOOM;
    gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
    rescale_text_items();
    rescale_bg_pixmaps();
  }
  do_switch_page(ui.pageno, TRUE, TRUE);
}


void
on_journalApplyAllPages_activate       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  gboolean active;
  
  end_text();
  reset_focus();
  active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
  if (active == ui.bg_apply_all_pages) return;
  ui.bg_apply_all_pages = active;
  update_page_stuff();
  
/* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
  struct Page *page;
  GList *pglist;
  
  if (ui.cur_page->bg->type != BG_SOLID) return;
  reset_selection();
  for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
    page = (struct Page *)pglist->data;
    prepare_new_undo();
    undo->type = ITEM_NEW_BG_RESIZE;
    undo->page = page;
    undo->bg = page->bg;
    undo->val_x = page->width;
    undo->val_y = page->height; 
    if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
    if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
    page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
    page->width = ui.cur_page->width;
    page->height = ui.cur_page->height;
    page->bg->canvas_item = undo->bg->canvas_item;
    undo->bg->canvas_item = NULL;
  
    make_page_clipbox(page);
    update_canvas_bg(page);
  }
  do_switch_page(ui.pageno, TRUE, TRUE);
*/

}


void
on_toolsPen_activate                   (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{