gui_main.c

网络爬虫程序

/***************************************************************************/
/*    This code is part of WWW grabber called pavuk                        */
/*    Copyright (c) 1997 - 2001 Stefan Ondrejicka                          */
/*    Distributed under GPL 2 or later                                     */
/***************************************************************************/

#include "config.h"
#include "gui.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>

#ifdef GTK_FACE

#ifdef __CYGWIN__
#include <windows.h>
#include "pavukrc.h"
#include <gdk/gdkx.h>
#else /* !__CYGWIN__ */
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#ifdef HAVE_XMU
#include <X11/Xmu/WinUtil.h>
#endif
#include <gdk/gdkx.h>
#endif /* !__CYGWIN__ */

#include "gaccel.h"
#include "gkeys.h"
#include "gprop.h"

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include "gui_api.h"
#include "gauthinfo.h"
#include "form.h"
#include "tools.h"
#include "uconfig.h"
#include "ainterface.h"
#include "recurse.h"
#include "icons.h"
#include "stats.h"
#include "dns.h"
#include "times.h"

#include "icons/configure.xpm"
#include "icons/limits.xpm"
#include "icons/gobg.xpm"
#include "icons/exit.xpm"
#include "icons/stop.xpm"
#include "icons/break.xpm"
#include "icons/continue.xpm"
#include "icons/restart.xpm"
#include "icons/break_small.xpm"
#include "icons/close_small.xpm"
#include "icons/continue_small.xpm"
#include "icons/maximize_small.xpm"
#include "icons/minimize_small.xpm"
#include "icons/restart_small.xpm"
#include "icons/stop_small.xpm"

Gtk_nfo gui_cfg;

static bool_t _restart_iface = TRUE;
#ifdef GETTEXT_NLS
static char *last_lang = NULL;
#endif
static bool_t miniaturized = FALSE;
static bool_t resizing = FALSE;

#ifdef HAVE_MT
static GtkWidget *logw_pane = NULL;
#endif

static enum
{
  GUI_ACT_GOBG,
  GUI_ACT_RESTART,
  GUI_ACT_CONTINUE,
  GUI_ACT_CHANGELANG,

  GUI_ACT_NONE
} gui_action = GUI_ACT_NONE;

const GtkTargetEntry dragtypes[] = {
  {"STRING", 0, 0},
  {"text/plain", 0, 0},
  {"application/x-rootwin-drop", 0, 1}
};

#ifdef DEBUG
void gui_set_debug_level_mi(void)
{
  int i;
  GList *ch = GTK_MENU_SHELL(gui_cfg.debug_level_m)->children;

  for(i = 0; cfg_debug_levels[i].id; i++)
  {
    if(ch)
    {
      gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(ch->data),
        (cfg.debug_level & cfg_debug_levels[i].id) != 0);
      ch = ch->next;
    }
  }
}
#endif

static GtkWidget *menu_item(gchar * field)
{
  GtkWidget *item, *label;
  guint accelerator_key;

  item = gtk_menu_item_new();

  label = gtk_accel_label_new(field);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_container_add(GTK_CONTAINER(item), label);
  gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(label), item);
  gtk_widget_show(label);

  accelerator_key = gtk_label_parse_uline(GTK_LABEL(label), field);

  if(accelerator_key != GDK_VoidSymbol)
  {
    gtk_widget_add_accelerator(item,
#if GTK_FACE < 2
      "activate_item",
#else
      "activate",
#endif
      gui_cfg.accel_group, accelerator_key, GDK_MOD1_MASK, GTK_ACCEL_LOCKED);
  }

  return item;
}

static void ResetCfg(GtkObject * object, gpointer func_data)
{
  cfg_set_all_to_default();

  cfg.xi_face = TRUE;

  if(gui_cfg.cfg_limits)
    xset_cfg_values_lim();
  if(gui_cfg.config_shell)
    xset_cfg_values_comm();

  if(cfg.use_prefs)
    cfg_dump_pref();
}

static void Save_rc(GtkObject * object, gpointer func_data)
{
  char pom[PATH_MAX];

  snprintf(pom, sizeof(pom), "%s/.pavukrc", cfg.path_to_home);
  cfg_dump(pom);
}

#ifdef GETTEXT_NLS
static void ChangeLang(GtkObject * object, gpointer func_data)
{
  if(!cfg.done)
    return;

  if(last_lang && func_data && !strcmp(last_lang, func_data))
    return;
  else if(!last_lang && !func_data)
    return;

  if(cfg.processing)
  {
    gdk_beep();
    xprintf(1,
      gettext("Unable to change language during processing time!\n"));
    return;
  }


  _free(cfg.language);
  cfg.language = tl_strdup((char *) func_data);

  _INIT_NLS _free(last_lang);
  last_lang = tl_strdup((char *) func_data);

  _restart_iface = TRUE;
  gui_action = GUI_ACT_CHANGELANG;
  gtk_main_quit();
}
#endif

/*** DROP SIGNAL HANDLER ***/
void gui_window_drop_url(GtkWidget * widget, GdkDragContext * context,
  gint x, gint y, GtkSelectionData * seldata, guint info, guint time,
  gpointer data)
{
  gchar *drag_url;
  gchar *p_seldata;
  url_info *ui;
  char *pp[2];

  if(!seldata || !seldata->data)
  {
    gtk_drag_finish(context, FALSE, FALSE, time);
    return;
  }

  p_seldata = (gchar *) seldata->data;

  /* strip away '\n' */
  drag_url = tl_strndup(p_seldata, strcspn(p_seldata, "\r\n"));

  ui = url_info_new(drag_url);
  if(gui_cfg.config_shell)
  {
    url_info *cui;
    int row;

    pp[0] = drag_url;
    pp[1] = NULL;

    row = gtk_clist_append(GTK_CLIST(gui_cfg.url_list), pp);
    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("Dropped URL : %s\n"), drag_url);
#endif

  _free(drag_url);

  gtk_drag_finish(context, TRUE, FALSE, time);
}

static void DeMiniaturize(GtkObject * object, gpointer func_data)
{
  gint w, h;
  char pom[128];

  miniaturized = FALSE;
  resizing = TRUE;

  gtk_widget_hide(GTK_WIDGET(gui_cfg.mini_toolbar));
  gtk_widget_show(GTK_WIDGET(gui_cfg.main_window_hide));
  gtk_widget_show(GTK_WIDGET(gui_cfg.logw_swin));

  w = -1;
  h = -1;
  snprintf(pom, sizeof(pom), "(%s)-toplevel_n_width", cfg.language ? cfg.language : "C");
  gprop_get_int(pom, &w);
  snprintf(pom, sizeof(pom), "(%s)-toplevel_n_height", cfg.language ? cfg.language : "C");
  gprop_get_int(pom, &h);
  gtk_window_set_default_size(GTK_WINDOW(gui_cfg.toplevel), w, h);

#ifdef HAVE_MT
  if(gprop_get_int("logw_height", &h))
    gtk_paned_set_position(GTK_PANED(logw_pane), h);
#endif

  resizing = FALSE;
}

static void Miniaturize(GtkObject * object, gpointer func_data)
{
  gint w, h;
  char pom[128];

  miniaturized = TRUE;
  resizing = TRUE;

  gtk_widget_show(GTK_WIDGET(gui_cfg.mini_toolbar));
  gtk_widget_hide(GTK_WIDGET(gui_cfg.main_window_hide));
  gtk_widget_hide(GTK_WIDGET(gui_cfg.logw_swin));

  w = -1;
  h = -1;
  snprintf(pom, sizeof(pom), "(%s)-toplevel_m_width", cfg.language ? cfg.language : "C");
  gprop_get_int(pom, &w);
  snprintf(pom, sizeof(pom), "(%s)-toplevel_m_height", cfg.language ? cfg.language : "C");
  gprop_get_int(pom, &h);
  gtk_window_set_default_size(GTK_WINDOW(gui_cfg.toplevel), w, h);

#ifdef HAVE_MT
  if(gprop_get_int("logw_height", &h))
    gtk_paned_set_position(GTK_PANED(logw_pane), 0);
#endif
  resizing = FALSE;
}

void gui_PopdownWC(GtkObject * object, gpointer func_data)
{
  GtkWidget *w = (GtkWidget *) func_data;
  int rv = 0;

  if(w == gui_cfg.cfg_limits)
    rv = xget_cfg_values_lim();
  if(w == gui_cfg.config_shell)
    rv = xget_cfg_values_comm();

  if(!rv)
  {
    gtk_widget_hide(w);
    if(cfg.use_prefs)
      cfg_dump_pref();
  }
  else
    gdk_beep();
}

void gui_PopupW(GtkObject * object, gpointer func_data)
{
  int which = (int) func_data;

  switch (which)
  {
  case PAVUK_ABOUT:
    gui_build_about(TRUE);
    break;
  case PAVUK_CFGCOMM:
    gui_build_config_common(TRUE);
    break;
  case PAVUK_CFGSCH:
    gui_build_scheduler(TRUE);
    {
      time_t t = time(NULL);
      struct tm *ltime;

      LOCK_TIME;
      ltime = new_tm(localtime(&t));
      UNLOCK_TIME;

      ltime->tm_year += 1900;

      gtk_calendar_select_month(GTK_CALENDAR(gui_cfg.calendar), ltime->tm_mon,
        ltime->tm_year);
      gtk_calendar_select_day(GTK_CALENDAR(gui_cfg.calendar), ltime->tm_mday);
      gtk_spin_button_set_value(GTK_SPIN_BUTTON(gui_cfg.hour_label),
        (gfloat) ltime->tm_hour);
      gtk_spin_button_set_value(GTK_SPIN_BUTTON(gui_cfg.min_label),
        (gfloat) ltime->tm_min);
      gtk_entry_set_text(GTK_ENTRY(gui_cfg.sched_cmd), cfg.sched_cmd);

      free(ltime);
    }
    break;
  case PAVUK_CFGLIM:
    gui_build_config_limits(TRUE);
    break;
#ifdef WITH_TREE
  case PAVUK_TREE:
    gui_build_tree_preview(TRUE);
    break;
#endif
  case PAVUK_SCNLD:
    gui_build_scenario_loader(TRUE);
    break;
  case PAVUK_SCNADD:
    gui_build_scenario_adder(TRUE);
    break;
  case PAVUK_SCNSV:
    gui_build_scenario_saver(TRUE);
    break;
#ifdef HAVE_MOZJS
  case PAVUK_JSCONS:
    gui_pjs_console(TRUE);
    break;
#endif
  default:
    xprintf(1, gettext("Unknown window to popup"));
  }
}

static void ClearLog(GtkObject * object, gpointer func_data)
{
  LOCK_GTKLOG;
  gtk_clist_clear(GTK_CLIST(gui_cfg.logw));
  UNLOCK_GTKLOG;
}

static void ToggleBool(GtkObject * object, gpointer func_data)
{
  bool_t *v = (bool_t *) func_data;

  if(GTK_IS_CHECK_MENU_ITEM(object))
    *v = GTK_CHECK_MENU_ITEM(object)->active;

  if(GTK_IS_TOGGLE_BUTTON(object) || GTK_IS_CHECK_BUTTON(object))
    *v = GTK_TOGGLE_BUTTON(object)->active;
}

static void OpenURL(GtkObject * object, gpointer func_data)
{
  gtk_notebook_set_page(GTK_NOTEBOOK(gui_cfg.cb_comcfg), 0);
}

static void FetchURL(GtkWidget * widget, GtkSelectionData * selection_data,
  gpointer data)
{
  char *p, *cb_url;
  url_info *ui;

  if(selection_data->length <= 0)
  {
    gdk_beep();
    return;
  }

  p = tl_strndup((char *) selection_data->data, selection_data->length);
  cb_url = tl_strndup(p, strcspn(p, "\r\n"));
  _free(p);

  ui = url_info_new(cb_url);
  if(gui_cfg.config_shell)
  {
    url_info *cui;
    int row = gtk_clist_append(GTK_CLIST(gui_cfg.url_list), &cb_url);
    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 clipboard : %s\n"), cb_url);
#endif

  _free(cb_url);
}

static void FetchCBUrl(GtkObject * object, gpointer func_data)
{
  GdkAtom atom;

  atom = gdk_atom_intern("TEXT", FALSE);

  gtk_selection_convert(GTK_WIDGET(object), GDK_SELECTION_PRIMARY, atom,
    GDK_CURRENT_TIME);