gui_main.c

网络爬虫程序

}

#ifdef HAVE_XMU
static Atom XA_MOZILLA_URL = None;
static Atom XA_MOZILLA_NAME = None;

static void AddBrowserURL(GtkWidget * w)
{
  url_info *ui;
  char *p = gtk_object_get_data(GTK_OBJECT(w), "url");

  if(p)
  {
    ui = url_info_new(p);
    if(gui_cfg.config_shell)
    {
      url_info *cui;
      int row = gtk_clist_append(GTK_CLIST(gui_cfg.url_list), &p);
      cui = url_info_duplicate(ui);
      gtk_clist_set_row_data_full(GTK_CLIST(gui_cfg.url_list), row, cui,
        (GtkDestroyNotify) url_info_free);
    }

    cfg.request = dllist_append(cfg.request, (dllist_t) ui);


#ifdef DEBUG
    if(cfg.debug)
      xprintf(0, gettext("Fetched URL from browser : %s\n"), p);
#endif
  }
}

static char *get_string_atom_value(Display * dpy, Window win, Atom atom)
{
  int result;
  Atom actual_type;
  int actual_format;
  unsigned long nitems, bytes_after;
  unsigned char *data = 0;

  result = XGetWindowProperty(dpy, win, atom,
    0, (65536 / sizeof(long)), False,
    XA_STRING, &actual_type, &actual_format, &nitems, &bytes_after, &data);

  if((result == Success) && data && data[0])
  {
    return g_strdup(data);
  }
  return NULL;
}

static void fill_browser_menu(GtkWidget * menu)
{
  Window root, parent, *chld;
  int num;
  int i;
  Display *dpy = GDK_DISPLAY();

  if(!XA_MOZILLA_URL)
    XA_MOZILLA_URL = XInternAtom(dpy, "_MOZILLA_URL", False);
  if(!XA_MOZILLA_NAME)
    XA_MOZILLA_NAME = XInternAtom(dpy, "WM_ICON_NAME", False);

  XGrabServer(dpy);
  XQueryTree(dpy, GDK_ROOT_WINDOW(), &root, &parent, &chld, &num);

  for(i = 0; i < num; i++)
  {
    Window cw = XmuClientWindow(dpy, chld[i]);
    GtkWidget *mi;
    char *u, *l;

    u = get_string_atom_value(dpy, cw, XA_MOZILLA_URL);
    if(u)
    {
      l = get_string_atom_value(dpy, cw, XA_MOZILLA_NAME);
      mi = gtk_menu_item_new_with_label(l + 10);
      g_free(l);
      gtk_menu_append(GTK_MENU(menu), mi);
      gtk_widget_show(mi);
      gtk_signal_connect(GTK_OBJECT(mi), "activate",
        GTK_SIGNAL_FUNC(AddBrowserURL), NULL);
      gtk_object_set_data_full(GTK_OBJECT(mi), "url", u, g_free);
    }
  }
  XUngrabServer(dpy);
  XSync(dpy, False);
  if(chld)
    XFree(chld);
}

static void BrowserMenuPopup(GtkWidget * w)
{
  while(GTK_MENU_SHELL(w)->children)
  {
    gtk_widget_destroy(GTK_WIDGET(GTK_MENU_SHELL(w)->children->data));
  }
  fill_browser_menu(w);
}
#endif

static void SwitchMode(GtkObject * object, gpointer func_data)
{
  cfg.mode = (int) func_data;

  if(cfg.done && cfg.mode_started)
  {
    if(cfg.mode != cfg.prev_mode)
    {
      gtk_widget_set_sensitive(gui_cfg.bt_start, FALSE);
      gtk_widget_set_sensitive(gui_cfg.mea_start, FALSE);
      gtk_widget_set_sensitive(gui_cfg.mtb_start, FALSE);
    }
    else
    {
      gtk_widget_set_sensitive(gui_cfg.bt_start, TRUE);
      gtk_widget_set_sensitive(gui_cfg.mea_start, TRUE);
      gtk_widget_set_sensitive(gui_cfg.mtb_start, TRUE);
    }
  }
}

static void StartRecurse(int restart)
{
  gui_start_download(TRUE);
  cfg.processing = TRUE;

#ifndef HAVE_MT
  if(restart || cfg.mode != cfg.prev_mode || !cfg.mode_started)
  {
    absi_restart();
  }
  else
  {
    absi_cont();
  }

  if(cfg.xi_face)
    gui_finish_download(TRUE);
#else
  {
    pthread_attr_t tattr;

    pthread_attr_init(&tattr);
    pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM);
    pthread_attr_setstacksize(&tattr, MT_STACK_SIZE);

    if(restart || cfg.mode != cfg.prev_mode || !cfg.mode_started)
    {
      if(pthread_create(&cfg.mainthread, &tattr, (void *) absi_restart, NULL))
      {
        xperror("Create main thread");
        gui_finish_download(TRUE);
      }
    }
    else
    {
      if(pthread_create(&cfg.mainthread, &tattr, (void *) absi_cont, NULL))
      {
        xperror("Create main thread");
        gui_finish_download(TRUE);
      }
    }
  }
#endif

}

static void Start(GtkObject * object, gpointer func_data)
{
  if(cfg.processing)
  {
    gdk_beep();
    return;
  }

  gui_action = func_data ? GUI_ACT_RESTART : GUI_ACT_CONTINUE;

  gtk_main_quit();
}

static void Stop(GtkObject * object, gpointer func_data)
{
  cfg.stop = TRUE;
}

static void Break(GtkObject * object, gpointer func_data)
{
  cfg.rbreak = TRUE;
  cfg.stop = TRUE;
  errno = EINTR;

#ifdef HAVE_MT
  if(cfg.processing)
  {
    int i;

    for(i = 0; i < cfg.allthreadsnr; i++)
    {
      pthread_kill(cfg.allthreads[i], SIGINT);
    }
/*
    pthread_join(cfg.mainthread, NULL);
*/
  }
#else
  _Xt_EscLoop;
#endif
}

static void Quit(GtkObject * object, gpointer func_data)
{
  if(!gui_cfg._go_bg && !_restart_iface)
  {
#ifdef HAVE_MT
    if(cfg.processing)
    {
      int i;

      for(i = 0; i < cfg.allthreadsnr; i++)
      {
        pthread_kill(cfg.allthreads[i], SIGQUIT);
        pthread_join(cfg.allthreads[i], NULL);
      }

      pthread_kill(cfg.mainthread, SIGQUIT);
      pthread_join(cfg.mainthread, NULL);
    }
#endif

    if(cfg.use_prefs)
      cfg_dump_pref();

    gkey_save();

    gtk_exit(0);
  }
}

static void Gobg(GtkObject * object, gpointer func_data)
{
  gui_cfg._go_bg = TRUE;

  if(cfg.use_prefs)
    cfg_dump_pref();

  gkey_save();

  if(!cfg.processing)
  {
    gui_action = GUI_ACT_GOBG;
    gtk_main_quit();
  }
}

static const struct
{
  char *label;
  char *accel;
  char *prope;
  GtkToolbarStyle tbtype;
} tbar_setup_rec[] =
{
  {gettext_nop("Both"), "config/tb_both", "tb_both_e", GTK_TOOLBAR_BOTH},
  {gettext_nop("Icons only"), "config/tb_icons", "tb_icons_e",
    GTK_TOOLBAR_ICONS},
  {gettext_nop("Text only"), "config/tb_text", "tb_text_e", GTK_TOOLBAR_TEXT}
};

#ifdef HAVE_MT

static const struct
{
  char *label;
  char *accel;
  char *prope;
  char *propw;
  int width;
} statusbar_col_rec[] =
{
  {gettext_nop("Nr."), NULL, NULL, "status_col_nr_width", 20},
  {gettext_nop("URL"), "config/sb_url", "status_col_url_e",
    "status_col_url_width", 150},
  {gettext_nop("Status"), "config/sb_status", "status_col_status_e",
    "status_col_status_width", 150},
  {gettext_nop("Size"), "config/sb_size", "status_col_size_e",
    "status_col_size_width", 150},
  {gettext_nop("Transfer rate"), "config/sb_rate", "status_col_rate_e",
    "status_col_rate_width", 60},
  {gettext_nop("Elapsed time"), "config/sb_et", "status_col_et_e",
    "status_col_et_width", 80},
  {gettext_nop("Remaining time"), "config/sb_rt", "status_col_rt_e",
    "status_col_rt_width", 80}
};

static void statusbar_col_set(GtkObject * object, gpointer func_data)
{
  gtk_clist_set_column_visibility(GTK_CLIST(gui_cfg.status_list),
    (int) func_data, GTK_CHECK_MENU_ITEM(object)->active);

  gprop_set_bool_t(statusbar_col_rec[(int) func_data].prope,
    GTK_CHECK_MENU_ITEM(object)->active);
}
#endif

static void toolbar_set(GtkObject * object, gpointer func_data)
{
  int i;

  if(GTK_CHECK_MENU_ITEM(object)->active)
  {
    gtk_toolbar_set_style(GTK_TOOLBAR(gui_cfg.toolbar),
      tbar_setup_rec[(int) func_data].tbtype);

    if(cfg.done)
    {
      for(i = 0; i < (sizeof(tbar_setup_rec) / sizeof(tbar_setup_rec[0]));
        i++)
      {
        gprop_set_bool_t(tbar_setup_rec[i].prope, i == (int) func_data);
      }
    }

    gtk_widget_queue_resize(GTK_WIDGET(gui_cfg.toolbar)->parent);
  }
}

static void toolbar_onoff(GtkWidget * object, gpointer func_data)
{
  GtkWidget *w;

  gprop_set_bool_t("tb_onoff", GTK_CHECK_MENU_ITEM(object)->active);

  w = GTK_WIDGET(gui_cfg.toolbar)->parent;

  if(GTK_CHECK_MENU_ITEM(object)->active)
    gtk_widget_show(w);
  else
    gtk_widget_hide(w);

  gtk_widget_queue_resize(gui_cfg.toplevel);
}

#ifdef DEBUG
static void switch_debug_level(GtkWidget * w, gpointer data)
{
  int dl = (int) data;

  if(GTK_CHECK_MENU_ITEM(w)->active)
    cfg.debug_level |= dl;
  else
    cfg.debug_level &= ~dl;
}

static void toggle_debug(GtkWidget * w, gpointer data)
{
  cfg.debug = GTK_CHECK_MENU_ITEM(w)->active;

  gtk_widget_set_sensitive(gui_cfg.debug_level_mi, cfg.debug);
  gtk_widget_set_sensitive(gui_cfg.debug_level_m, cfg.debug);
}

static void set_debug_level(GtkWidget * w, gpointer data)
{
  int l = (int) data;
  cfg.debug_level = l;
  gui_set_debug_level_mi();
}
#endif

static void ToggleTooltips(GtkWidget * w)
{
  int have = GTK_CHECK_MENU_ITEM(w)->active;

  gprop_set_bool_t("tooltips_enabled", have);
  if(have)
    gtk_tooltips_enable(gui_cfg.help_tooltips);
  else
    gtk_tooltips_disable(gui_cfg.help_tooltips);
}

static void build_menu(GtkWidget * parent)
{
  GtkWidget *mbar, *menu, *mbb, *mi, *hbox, *lbox;
  GSList *rg;
  GtkWidget *smenu, *button;
  int i;

  lbox = gtk_hbox_new(FALSE, 1);
  gtk_widget_show(lbox);

  button = guitl_pixmap_button(minimize_small_xpm, cfg.bt_icon_mtb, NULL);
  gtk_box_pack_end(GTK_BOX(lbox), button, FALSE, TRUE, 1);
  gtk_signal_connect(GTK_OBJECT(button), "clicked",
    GTK_SIGNAL_FUNC(Miniaturize), (gpointer) parent);
  gtk_widget_show(button);

  mbar = gtk_menu_bar_new();
  gtk_box_pack_start(GTK_BOX(lbox), mbar, TRUE, TRUE, 1);
  gtk_widget_show(mbar);

  gui_cfg.accel_group = gtk_accel_group_new();

  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, TRUE, 0);
  gtk_box_reorder_child(GTK_BOX(parent), hbox, 0);
  gtk_widget_show(hbox);
  gtk_container_add(GTK_CONTAINER(hbox), lbox);


/*** FILE 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("Open _URL ..."));
  gaccel_bind_widget("file/open_url", "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_CFGCOMM);

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

  mi = menu_item(gettext("Append URL ..."));
  gaccel_bind_widget("file/add_url", "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_build_addurl), (gpointer) NULL);

  mi = menu_item(gettext("Fetch URL from Clipboard"));
  gaccel_bind_widget("file/fetch_url", "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(FetchCBUrl), (gpointer) NULL);
  gtk_signal_connect(GTK_OBJECT(mi), "selection_received",
    GTK_SIGNAL_FUNC(FetchURL), (gpointer) NULL);
#ifdef HAVE_XMU
  smenu = gtk_menu_new();