gui_main.c

网络爬虫程序

#ifdef DEBUG
  gui_cfg.debug_level_mi = mi = menu_item(gettext("Debug level"));
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gtk_widget_set_sensitive(mi, cfg.debug);

  gui_cfg.debug_level_m = gtk_menu_new();
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi), gui_cfg.debug_level_m);

  for(i = 0; cfg_debug_levels[i].id; i++)
  {
    mi =
      gtk_check_menu_item_new_with_label(gettext(cfg_debug_levels[i].label));
    gtk_menu_append(GTK_MENU(gui_cfg.debug_level_m), mi);
    gtk_widget_show(mi);
    gtk_signal_connect(GTK_OBJECT(mi), "activate",
      GTK_SIGNAL_FUNC(switch_debug_level), (gpointer) cfg_debug_levels[i].id);
  }
  gui_set_debug_level_mi();

  mi = gtk_menu_item_new();
  gtk_menu_append(GTK_MENU(gui_cfg.debug_level_m), mi);
  gtk_widget_show(mi);

  mi = gtk_menu_item_new_with_label(gettext("All"));
  gtk_menu_append(GTK_MENU(gui_cfg.debug_level_m), mi);
  gtk_widget_show(mi);
  gtk_signal_connect(GTK_OBJECT(mi), "activate",
    GTK_SIGNAL_FUNC(set_debug_level), (gpointer) 0xffffffff);

  mi = gtk_menu_item_new_with_label(gettext("None"));
  gtk_menu_append(GTK_MENU(gui_cfg.debug_level_m), mi);
  gtk_widget_show(mi);
  gtk_signal_connect(GTK_OBJECT(mi), "activate",
    GTK_SIGNAL_FUNC(set_debug_level), (gpointer) 0);

  gui_cfg.me_debug = mi =
    gtk_check_menu_item_new_with_label(gettext("Debug"));
  gaccel_bind_widget("config/debug", "activate", mi, NULL, gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);

  gtk_signal_connect(GTK_OBJECT(mi), "toggled",
    GTK_SIGNAL_FUNC(toggle_debug), (gpointer) & cfg.debug);

  gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(mi), cfg.debug);

  mi = gtk_menu_item_new();
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
#endif

  mi = gtk_check_menu_item_new_with_label(gettext("Allow tooltips"));
  gaccel_bind_widget("config/tooltips", "activate", mi, NULL,
    gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(mi),
    !gprop_get_bool_t("tooltips_enabled", &i) || i);

  gtk_signal_connect(GTK_OBJECT(mi), "toggled",
    GTK_SIGNAL_FUNC(ToggleTooltips), NULL);

  mi = gtk_check_menu_item_new_with_label(gettext("Log window autoscroll"));
  gaccel_bind_widget("config/log_sroll", "activate", mi, NULL,
    gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(mi), cfg.log_autoscroll);
  gtk_signal_connect(GTK_OBJECT(mi), "toggled",
    GTK_SIGNAL_FUNC(ToggleBool), (gpointer) & cfg.log_autoscroll);

  mi = gtk_check_menu_item_new_with_label(gettext("Use preferences"));
  gaccel_bind_widget("config/use_pref", "activate", mi, NULL,
    gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(mi), cfg.use_prefs);
  gtk_signal_connect(GTK_OBJECT(mi), "toggled",
    GTK_SIGNAL_FUNC(ToggleBool), (gpointer) & cfg.use_prefs);

  gui_cfg.me_quiet = mi =
    gtk_check_menu_item_new_with_label(gettext("Quiet"));
  gaccel_bind_widget("config/quiet", "activate", mi, NULL, gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);

  gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(mi), cfg.quiet);

  gtk_signal_connect(GTK_OBJECT(mi), "toggled",
    GTK_SIGNAL_FUNC(ToggleBool), (gpointer) & cfg.quiet);

#ifdef HAVE_MT
  gui_cfg.immessages = mi =
    gtk_check_menu_item_new_with_label(gettext("Immediate messages"));
  gaccel_bind_widget("config/immediate_msg", "activate", mi, NULL,
    gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);

  gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(mi), cfg.immessages);

  gtk_signal_connect(GTK_OBJECT(mi), "toggled",
    GTK_SIGNAL_FUNC(ToggleBool), (gpointer) & cfg.immessages);
#endif

  mbb = menu_item(gettext("_Config"));
  gtk_widget_show(mbb);
  gtk_menu_bar_append(GTK_MENU_BAR(mbar), mbb);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(mbb), menu);

/*** ACTION MENU ***/

  menu = gtk_menu_new();
  gtk_widget_realize(menu);

  mi = gtk_tearoff_menu_item_new();
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);

  mi = menu_item(gettext("_Restart"));
  gaccel_bind_widget("action/restart", "activate", mi, NULL,
    gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gui_cfg.mea_rest = mi;

  gtk_signal_connect(GTK_OBJECT(mi), "activate",
    GTK_SIGNAL_FUNC(Start), (gpointer) TRUE);

  mi = menu_item(gettext("Co_ntinue"));
  gaccel_bind_widget("action/continue", "activate", mi, NULL,
    gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gui_cfg.mea_start = mi;

  gtk_signal_connect(GTK_OBJECT(mi), "activate",
    GTK_SIGNAL_FUNC(Start), (gpointer) FALSE);

  mi = menu_item(gettext("Sto_p"));
  gaccel_bind_widget("action/stop", "activate", mi, NULL, gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gui_cfg.mea_stop = mi;

  gtk_signal_connect(GTK_OBJECT(mi), "activate",
    GTK_SIGNAL_FUNC(Stop), (gpointer) NULL);

  mi = menu_item(gettext("_Break"));
  gaccel_bind_widget("action/break", "activate", mi, NULL, gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);
  gui_cfg.mea_break = mi;

  gtk_signal_connect(GTK_OBJECT(mi), "activate",
    GTK_SIGNAL_FUNC(Break), (gpointer) NULL);

  mbb = menu_item(gettext("_Action"));
  gtk_widget_show(mbb);
  gtk_menu_bar_append(GTK_MENU_BAR(mbar), mbb);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(mbb), menu);

  gtk_widget_set_sensitive(gui_cfg.mea_start, FALSE);
  gtk_widget_set_sensitive(gui_cfg.mea_stop, FALSE);
  gtk_widget_set_sensitive(gui_cfg.mea_break, FALSE);

/*** HELP MENU ***/

  menu = gtk_menu_new();
  gtk_widget_realize(menu);

  mi = gtk_tearoff_menu_item_new();
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);

  mi = menu_item(gettext("About ..."));
  gaccel_bind_widget("help/about", "activate", mi, NULL, gui_cfg.toplevel);
  gtk_menu_append(GTK_MENU(menu), mi);
  gtk_widget_show(mi);

  gtk_signal_connect(GTK_OBJECT(mi), "activate",
    GTK_SIGNAL_FUNC(gui_PopupW), (gpointer) PAVUK_ABOUT);

  mbb = menu_item(gettext("_Help"));
  gtk_menu_item_right_justify(GTK_MENU_ITEM(mbb));
  gtk_widget_show(mbb);
  gtk_menu_bar_append(GTK_MENU_BAR(mbar), mbb);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(mbb), menu);
}

static void build_toolbar(GtkWidget * parent)
{
  GtkWidget *row, *hbox;

#if GTK_FACE < 2
  gui_cfg.toolbar = row = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
    GTK_TOOLBAR_BOTH);

  gtk_toolbar_set_button_relief(GTK_TOOLBAR(row), GTK_RELIEF_NONE);
  gtk_toolbar_set_space_size(GTK_TOOLBAR(row), 10);
#else
  gui_cfg.toolbar = row = gtk_toolbar_new();
  gtk_toolbar_set_orientation(GTK_TOOLBAR(gui_cfg.toolbar),
  GTK_ORIENTATION_HORIZONTAL);
  gtk_toolbar_set_style(GTK_TOOLBAR(gui_cfg.toolbar), GTK_TOOLBAR_BOTH);

  /* FIXME - There is no description, how to manage this in GTK 2.x */
  /* gtk_toolbar_set_button_relief(GTK_TOOLBAR(row), GTK_RELIEF_NONE); */
  /* gtk_toolbar_set_space_size(GTK_TOOLBAR(row), 10); */
#endif

  hbox = gtk_handle_box_new();
  gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hbox), GTK_SHADOW_NONE);
  gtk_box_pack_start(GTK_BOX(parent), hbox, FALSE, FALSE, 0);
  gtk_widget_show(hbox);
  gtk_container_add(GTK_CONTAINER(hbox), row);

  gtk_widget_show(row);

  gui_cfg.bt_cfg = guitl_toolbar_button(row, gettext("Config"),
    gettext("Popup config window"), configure_xpm,
    GTK_SIGNAL_FUNC(gui_PopupW), (gpointer) PAVUK_CFGCOMM, cfg.bt_icon_cfg);

  gui_cfg.bt_lim = guitl_toolbar_button(row, gettext("Limits"),
    gettext("Popup limits window"), limits_xpm,
    GTK_SIGNAL_FUNC(gui_PopupW), (gpointer) PAVUK_CFGLIM, cfg.bt_icon_lim);

  gtk_toolbar_append_space(GTK_TOOLBAR(row));

  gui_cfg.bt_bg = guitl_toolbar_button(row, gettext("Go bg"),
    gettext("Destroy window as soon as posible and continue on terminal"),
    gobg_xpm, GTK_SIGNAL_FUNC(Gobg), NULL, cfg.bt_icon_gobg);

  gui_cfg.bt_rest = guitl_toolbar_button(row, gettext("Restart"),
    gettext("Start working on currently set starting URLs"),
    restart_xpm, GTK_SIGNAL_FUNC(Start), (gpointer) TRUE, cfg.bt_icon_rest);

  gui_cfg.bt_start = guitl_toolbar_button(row, gettext("Continue"),
    gettext("Continue after stop or break"), continue_xpm,
    GTK_SIGNAL_FUNC(Start), (gpointer) FALSE, cfg.bt_icon_cont);

  gtk_toolbar_append_space(GTK_TOOLBAR(row));

  gui_cfg.bt_stop = guitl_toolbar_button(row, gettext("Stop"),
    gettext("Finish this transfer and stop"), stop_xpm,
    GTK_SIGNAL_FUNC(Stop), (gpointer) NULL, cfg.bt_icon_stop);

  gui_cfg.bt_break = guitl_toolbar_button(row, gettext("Break"),
    gettext("Break transfer and stop"), break_xpm,
    GTK_SIGNAL_FUNC(Break), (gpointer) NULL, cfg.bt_icon_brk);

  gtk_toolbar_append_space(GTK_TOOLBAR(row));

  gui_cfg.bt_exit = guitl_toolbar_button(row, gettext("Exit"),
    gettext("Immediately quit the program"), exit_xpm,
    GTK_SIGNAL_FUNC(Quit), (gpointer) NULL, cfg.bt_icon_exit);

  gtk_widget_set_sensitive(gui_cfg.bt_start, FALSE);
  gtk_widget_set_sensitive(gui_cfg.bt_stop, FALSE);
  gtk_widget_set_sensitive(gui_cfg.bt_break, FALSE);

}

static void build_minitoolbar(GtkWidget * col)
{
  GtkWidget *tb;
#ifndef HAVE_MT
  GtkWidget *frame;
#endif

  gui_cfg.mini_toolbar = gtk_hbox_new(0, 5);
  gtk_box_pack_start(GTK_BOX(col), gui_cfg.mini_toolbar, FALSE, TRUE, 1);

#ifndef HAVE_MT
  frame = gtk_frame_new(NULL);
  gtk_widget_show(frame);
  gtk_box_pack_start(GTK_BOX(gui_cfg.mini_toolbar), frame, TRUE, TRUE, 4);

  gui_cfg.minitb_label = gtk_entry_new();
  gtk_widget_show(gui_cfg.minitb_label);
  gtk_widget_set_usize(gui_cfg.minitb_label, 400, -1);
  gtk_entry_set_editable(GTK_ENTRY(gui_cfg.minitb_label), FALSE);
  gtk_container_add(GTK_CONTAINER(frame), gui_cfg.minitb_label);
#endif

#if GTK_FACE < 2
  tb = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
  gtk_toolbar_set_button_relief(GTK_TOOLBAR(tb), GTK_RELIEF_NONE);
  gtk_toolbar_set_space_size(GTK_TOOLBAR(tb), 2);
#else
  tb = gtk_toolbar_new();
  gtk_toolbar_set_orientation(GTK_TOOLBAR(gui_cfg.toolbar),
  GTK_ORIENTATION_HORIZONTAL);
  gtk_toolbar_set_style(GTK_TOOLBAR(gui_cfg.toolbar), GTK_TOOLBAR_ICONS);

  /* FIXME - There is no description, how to manage this in GTK 2.x */
  /* gtk_toolbar_set_button_relief(GTK_TOOLBAR(tb), GTK_RELIEF_NONE); */
  /* gtk_toolbar_set_space_size(GTK_TOOLBAR(tb), 2); */
#endif

#ifdef HAVE_MT
  gtk_box_pack_start(GTK_BOX(gui_cfg.mini_toolbar), tb, FALSE, FALSE, 1);
#else
  gtk_box_pack_end(GTK_BOX(gui_cfg.mini_toolbar), tb, FALSE, FALSE, 1);
#endif
  gtk_widget_show(tb);

  gui_cfg.mtb_rest = guitl_toolbar_button(tb, NULL,
    gettext("Restart"), restart_small_xpm,
    GTK_SIGNAL_FUNC(Start), (gpointer) TRUE, cfg.bt_icon_rest_s);

  gui_cfg.mtb_start = guitl_toolbar_button(tb, NULL,
    gettext("Continue"), continue_small_xpm,
    GTK_SIGNAL_FUNC(Start), (gpointer) FALSE, cfg.bt_icon_cont_s);

  gui_cfg.mtb_stop = guitl_toolbar_button(tb, NULL,
    gettext("Stop"), stop_small_xpm,
    GTK_SIGNAL_FUNC(Stop), (gpointer) NULL, cfg.bt_icon_stop_s);

  gui_cfg.mtb_break = guitl_toolbar_button(tb, NULL,
    gettext("Break"), break_small_xpm,
    GTK_SIGNAL_FUNC(Break), (gpointer) NULL, cfg.bt_icon_brk_s);

  guitl_toolbar_button(tb, NULL,
    gettext("Show whole main window"), maximize_small_xpm,
    GTK_SIGNAL_FUNC(DeMiniaturize), (gpointer) col, cfg.bt_icon_mtb_s);

  guitl_toolbar_button(tb, NULL,
    gettext("Quit"), close_small_xpm,
    GTK_SIGNAL_FUNC(Quit), (gpointer) NULL, cfg.bt_icon_exit_s);

  gtk_widget_set_sensitive(gui_cfg.mtb_start, FALSE);
  gtk_widget_set_sensitive(gui_cfg.mtb_stop, FALSE);
  gtk_widget_set_sensitive(gui_cfg.mtb_break, FALSE);
}

static guint gui_logw_list_events(GtkWidget * widget, GdkEvent * event)
{
  GdkEventButton *bevent;

  switch (event->type)
  {
  case GDK_BUTTON_PRESS:
    bevent = (GdkEventButton *) event;
    if(bevent->button == 3)
    {
      gtk_widget_set_sensitive(gui_cfg.logw_copy_me,
        (GTK_CLIST(gui_cfg.logw)->selection != NULL));
      gtk_menu_popup(GTK_MENU(gui_cfg.logw_menu),
        NULL, NULL, NULL, NULL, 3, bevent->time);
    }
    break;
  default:
    break;
  }
  return FALSE;
}

static void logw_save_content_do(GtkWidget * w, GtkWidget * fs)
{
  char *t = NULL;
  const char *p;
  int row, fd;
  int err = FALSE;

  for(row = 0; row < GTK_CLIST(gui_cfg.logw)->rows; row++)
  {
    char *s;
    gtk_clist_get_text(GTK_CLIST(gui_cfg.logw), row, 0, &s);
    t = tl_str_concat(t, s, "\n", NULL);
  }

  p = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs));

  if((fd = open(p, O_WRONLY | O_CREAT | O_TRUNC, 0644)) < 0)
  {
    xperror(p);
    gdk_beep();
    err = TRUE;
  }
  else
  {
    row = strlen(t);
    if(write(fd, t, row) != row)
    {
      xperror(p);
      gdk_beep();
      err = TRUE;
    }
    close(fd);
  }

  _free(t);

  if(!err)
    gtk_widget_destroy(fs);
}

static void logw_save_content(void)
{
  static GtkWidget *fs = NULL;

  if(!fs)
  {
    fs = gtk_file_selection_new(gettext("Pavuk: save log"));
    gtk_signal_connect(GTK_OBJECT(fs), "destroy",
      GTK_SIGNAL_FUNC(gtk_widget_destroyed), &fs);
    gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
      "clicked", GTK_SIGNAL_FUNC(logw_save_content_do), fs);
    gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
      "clicked", GTK_SIGNAL_FUNC(guitl_PopdownW), fs);

  }
  gtk_widget_show(fs);
  if(GTK_WIDGET_REALIZED(fs))
    gdk_window_raise(fs->window);
}

static void logw_select_all(void)
{
  gtk_clist_select_all(GTK_CLIST(gui_cfg.logw));
}

static void logw_clear_selection(void)
{
  gtk_clist_unselect_all(GTK_CLIST(gui_cfg.logw));
}

static void build_logw(GtkWidget * pane)
{
  GtkWidget *swin, *par;
  GtkWidget *mi;

  par = gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(pane), par);
  gtk_widget_show(par);

  gui_cfg.logw = gtk_clist_new(1);
  gtk_clist_set_column_title(GTK_CLIST(gui_cfg.logw), 0, gettext("Log"));
  gtk_clist_column_titles_show(GTK_CLIST(gui_cfg.logw));
  gtk_clist_set_selection_mode(GTK_CLIST(gui_cfg.logw),
    GTK_SELECTION_EXTENDED);
  gtk_widget_set_usize(gui_cfg.logw, -1, 150);
  gtk_clist_set_column_auto_resize(GTK_CLIST(gui_cfg.logw), 0, TRUE);

  gui_cfg.logw_swin = swin = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
    GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
  gtk_box_pack_start(GTK_BOX(par), swin, TRUE, TRUE, 0);
  gtk_widget_show(swin);
  gtk_container_add(GTK_CONTAINER(swin), gui_cfg.logw);