form.c

网络爬虫程序

    w = NULL;

    switch (ffi->type)
    {
    case FORM_T_TEXT:
      w = gtk_entry_new();
      if(ffi->maxlen)
        gtk_entry_set_max_length(GTK_ENTRY(w), ffi->maxlen);
      if(ffi->width)
        gtk_widget_set_usize(w,
          ffi->width * 10 /*gdk_string_width(w->style->font, "xxx") */ , -1);
      break;
    case FORM_T_PASSWORD:
      w = gtk_entry_new();
      if(ffi->maxlen)
        gtk_entry_set_max_length(GTK_ENTRY(w), ffi->maxlen);
      if(ffi->width)
        gtk_widget_set_usize(w,
          ffi->width * 10 /*gdk_string_width(w->style->font, "xxx") */ , -1);
      gtk_entry_set_visibility(GTK_ENTRY(w), FALSE);
      break;
    case FORM_T_CHECKBOX:
      if(ffi->text)
        p = ffi->text;
      else if(ptr->next &&
        (((form_field_info *) ptr->next->data)->type == FORM_T_NONFORM))
      {
        p = ((form_field_info *) ptr->next->data)->text;
        ptr = ptr->next;
      }
      else
        p = "check";

      w = gtk_check_button_new_with_label(p);
      gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(w), ffi->checked);
      break;
    case FORM_T_RADIO:
      {
        GSList *rg = NULL;

        ptr2 = ptr->prev;
        while(ptr2)
        {
          form_field_info *tffi = (form_field_info *) ptr2->data;

          if(ffi->type == tffi->type &&
            tffi->name && ffi->name && !strcmp(tffi->name, ffi->name))
          {
            rg = gtk_radio_button_group(GTK_RADIO_BUTTON(tffi->widget));
            break;
          }
          ptr2 = ptr2->prev;
        }
        if(ffi->text)
          p = ffi->text;
        else if(ptr->next &&
          (((form_field_info *) ptr->next->data)->type == FORM_T_NONFORM))
        {
          p = ((form_field_info *) ptr->next->data)->text;
          ptr = ptr->next;
        }
        else
          p = "radio";

        w = gtk_radio_button_new_with_label(rg, p);
        gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(w), ffi->checked);
      }
      break;
    case FORM_T_SUBMIT:
    case FORM_T_IMAGE:
      if(ffi->name)
        p = ffi->name;
      else
        p = "Submit";
      w = gtk_button_new_with_label(p);

      gtk_signal_connect(GTK_OBJECT(w), "clicked",
        GTK_SIGNAL_FUNC(form_submit_cb), fi);
      break;
    case FORM_T_RESET:
      if(ffi->name)
        p = ffi->name;
      else
        p = "Reset";
      w = gtk_button_new_with_label(p);

      gtk_signal_connect(GTK_OBJECT(w), "clicked",
        GTK_SIGNAL_FUNC(form_reset_cb), fi);
      break;
    case FORM_T_FILE:
      w = gtk_entry_new();
      break;
    case FORM_T_HIDDEN:
      break;
    case FORM_T_BUTTON:
      if(ffi->default_value)
        p = ffi->default_value;
      else
        p = "Button";
      w = gtk_button_new_with_label(p);
      break;
    case FORM_T_SELECT:
      w = form_render_selection(ffi);
      break;
    case FORM_T_TEXTAREA:
#if GTK_FACE < 2
      w = gtk_text_new(NULL, NULL);
#else
      w = gtk_text_view_new();
#endif
      gtk_widget_set_usize(w, 250, 150);
#if GTK_FACE < 2
      gtk_text_set_editable(GTK_TEXT(w), ffi->readonly);
#else
      gtk_text_view_set_editable(GTK_TEXT_VIEW(w), ffi->readonly);
#endif
      break;
    case FORM_T_UNKNOWN:
    case FORM_T_OPTGROUP:
    case FORM_T_OPTION:
      xprintf(0, gettext("Unsupported form type in context: %d\n"),
        ffi->type);
      break;
    case FORM_T_NONFORM:
      w = gtk_label_new(ffi->text);
      break;
    }
    if(w)
    {
      gtk_box_pack_start(GTK_BOX(box), w, FALSE, FALSE, 1);
      gtk_widget_show(w);
      gtk_object_set_user_data(GTK_OBJECT(w), ffi);
      gtk_widget_set_sensitive(w, !ffi->disabled);
      if(!ffi->widget)
        ffi->widget = w;
    }
  }

  return box;
}

struct form_edit_dlg_t
{
  GtkWidget *top;
  GtkWidget *tab;
  GtkWidget *url_list;
  GtkWidget *action;
  GtkWidget *method;
  GtkWidget *encoding;
  GtkWidget *swin;
  GtkWidget *form;
  GtkWidget *formnr;
  GtkWidget *fs;
  form_info *formdata;
  char *docdata;
  int doclen;
  long formsnum;
  url *parent_url;
};

static void PopdownW(GtkObject * object, gpointer func_data)
{
  gtk_widget_hide(GTK_WIDGET(func_data));
}

static void form_edit_dlg_refresh_list(GtkWidget * w,
  struct form_edit_dlg_t *fedlg)
{
  int i;

  gtk_clist_freeze(GTK_CLIST(fedlg->url_list));
  gtk_clist_clear(GTK_CLIST(fedlg->url_list));
  LOCK_CFG_URLHASH;
  for(i = 0; i < cfg.url_hash_tbl->size; i++)
  {
    dllist *ptr = cfg.url_hash_tbl->nodes[i];

    while(ptr)
    {
      url *urlp = (url *) ptr->data;

      if(urlp->status & URL_HAVE_FORMS)
      {
        char *urlstr;
        int row;

        urlstr = url_to_urlstr(urlp, FALSE);
        row = gtk_clist_append(GTK_CLIST(fedlg->url_list), &urlstr);
        gtk_clist_set_row_data(GTK_CLIST(fedlg->url_list), row, urlp);
        _free(urlstr);
      }

      ptr = ptr->next;
    }
  }
  UNLOCK_CFG_URLHASH;
  gtk_clist_thaw(GTK_CLIST(fedlg->url_list));
}

static void form_edit_dlg_browse(struct form_edit_dlg_t *fedlg)
{
  GtkWidget *hbox, *vbox, *label, *swin, *button;

  hbox = gtk_hbox_new(FALSE, 2);
  gtk_widget_show(hbox);
  label = gtk_label_new(gettext("Browse"));
  gtk_notebook_append_page(GTK_NOTEBOOK(fedlg->tab), hbox, label);

  swin = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_box_pack_start(GTK_BOX(hbox), swin, TRUE, TRUE, 2);
  gtk_widget_show(swin);

  fedlg->url_list = gtk_clist_new(1);
  gtk_clist_set_column_auto_resize(GTK_CLIST(fedlg->url_list), 0, TRUE);
  gtk_clist_set_selection_mode(GTK_CLIST(fedlg->url_list),
    GTK_SELECTION_BROWSE);
  gtk_clist_set_column_title(GTK_CLIST(fedlg->url_list), 0,
    gettext("URLs with forms"));
  gtk_clist_column_titles_show(GTK_CLIST(fedlg->url_list));
  gtk_container_add(GTK_CONTAINER(swin), fedlg->url_list);
  gtk_widget_show(fedlg->url_list);

  vbox = gtk_vbox_new(FALSE, 2);
  gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 2);
  gtk_widget_show(vbox);

  button =
    guitl_pixmap_button(restart_small_xpm, NULL, gettext("Refresh URL list"));
  gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 10);
  gtk_widget_show(button);

  gtk_signal_connect(GTK_OBJECT(button), "clicked",
    GTK_SIGNAL_FUNC(form_edit_dlg_refresh_list), fedlg);
}

static void form_edit_dlg_switch_form(GtkWidget * w,
  struct form_edit_dlg_t *fedlg)
{
  char *formdata;
  int formlen;
  long nr = (long) gtk_object_get_user_data(GTK_OBJECT(w));

  if(fedlg->formdata)
  {
    form_free(fedlg->formdata);
    fedlg->formdata = NULL;
    gtk_widget_destroy(fedlg->form);
    gtk_label_set(GTK_LABEL(fedlg->method), "");
    gtk_label_set(GTK_LABEL(fedlg->encoding), "");
    gtk_label_set(GTK_LABEL(fedlg->action), "");
  }

  formdata = form_get_text(nr, fedlg->docdata, fedlg->doclen, &formlen);

  if(!formdata)
    return;

  fedlg->formdata = form_parse(formdata, formlen);
  fedlg->formdata->parent_url = fedlg->parent_url;

  gtk_label_set(GTK_LABEL(fedlg->method),
    (fedlg->formdata->method ==
      FORM_M_GET) ? "GET" : (fedlg->formdata->method ==
      FORM_M_POST) ? "POST" : gettext("unknown"));
  gtk_label_set(GTK_LABEL(fedlg->encoding),
    (fedlg->formdata->encoding ==
      FORM_E_URLENCODED) ? "application/x-www-form-urlencoded" : (fedlg->
      formdata->encoding ==
      FORM_E_MULTIPART) ? "multipart/form-data" : gettext("unknown"));
  gtk_label_set(GTK_LABEL(fedlg->action), fedlg->formdata->action);

  fedlg->form = gtk_vbox_new(FALSE, 2);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(fedlg->swin),
    fedlg->form);
  gtk_widget_show(fedlg->form);

  form_render(fedlg->formdata, fedlg->form);
  /* FIXME: The following line showed up to be wrong after ansification,
     thought I have no idea what to do with it.
     form_reset(NULL, fedlg); */
}

static char *form_load_doc(char *docfile, int *doclen)
{
  char *retv = NULL;
  char buf[1024];
  int fd;
  int len;

  *doclen = 0;
  if(!docfile)
    return NULL;

  if((fd = open(docfile, O_BINARY | O_RDONLY)) < 0)
  {
    xperror(docfile);
    return NULL;
  }

  while((len = read(fd, buf, sizeof(buf))) > 0)
  {
    retv = _realloc(retv, *doclen + len + 1);
    memmove(retv + *doclen, buf, len);
    *doclen += len;
  }

  if(len < 0)
    xperror(docfile);

  close(fd);

  return retv;
}

static int form_edit_dlg_load_html_file(char *filename,
  struct form_edit_dlg_t *fedlg)
{
  GtkWidget *menu, *fmi = NULL;

  if(fedlg->formdata)
  {
    form_free(fedlg->formdata);
    fedlg->formdata = NULL;
    gtk_widget_destroy(fedlg->form);
    gtk_label_set(GTK_LABEL(fedlg->method), "");
    gtk_label_set(GTK_LABEL(fedlg->encoding), "");
    gtk_label_set(GTK_LABEL(fedlg->action), "");
  }
  if(filename)
    fedlg->docdata = form_load_doc(filename, &fedlg->doclen);

  if(!fedlg->docdata)
    return -1;

  menu = gtk_menu_new();
  for(fedlg->formsnum = 0;; fedlg->formsnum++)
  {
    int formlen;
    char *formdata;
    GtkWidget *mi;
    char pom[10];

    formdata =
      form_get_text(fedlg->formsnum, fedlg->docdata, fedlg->doclen, &formlen);

    if(!formdata)
      break;

    _free(formdata);

    sprintf(pom, "%ld", fedlg->formsnum);
    mi = gtk_menu_item_new_with_label(pom);
    gtk_object_set_user_data(GTK_OBJECT(mi), (gpointer) fedlg->formsnum);
    gtk_signal_connect(GTK_OBJECT(mi), "activate",
      GTK_SIGNAL_FUNC(form_edit_dlg_switch_form), fedlg);
    gtk_widget_show(mi);
    gtk_menu_append(GTK_MENU(menu), mi);

    if(!fedlg->formsnum)
      fmi = mi;
  }

  gtk_option_menu_set_menu(GTK_OPTION_MENU(fedlg->formnr), menu);

  if(!fedlg->formsnum)
    return -1;

  gtk_option_menu_set_history(GTK_OPTION_MENU(fedlg->formnr), 0);
  form_edit_dlg_switch_form(fmi, fedlg);

  return 0;
}

static void form_edit_dlg_switch_page(GtkWidget * w, GtkNotebookPage * pg,
  gint pgnr, struct form_edit_dlg_t *fedlg)
{
  if(pgnr == 1)
  {
    if(fedlg->docdata)
    {
      _free(fedlg->docdata);
      gtk_widget_destroy(GTK_OPTION_MENU(fedlg->formnr)->menu);
    }
    if(GTK_CLIST(fedlg->url_list)->selection)
    {
      url *urlp;

      urlp = (url *) gtk_clist_get_row_data(GTK_CLIST(fedlg->url_list),
        GPOINTER_TO_INT(GTK_CLIST(fedlg->url_list)->selection->data));

      fedlg->parent_url = urlp;
      form_edit_dlg_load_html_file(url_to_filename(urlp, FALSE), fedlg);
    }
  }
}

static void form_edit_dlg_load_file_ok(GtkWidget * w,
  struct form_edit_dlg_t *fedlg)
{
  char *p =
    (gchar *) gtk_file_selection_get_filename(GTK_FILE_SELECTION(fedlg->fs));

  fedlg->parent_url = NULL;
  form_edit_dlg_load_html_file(p, fedlg);
  gtk_widget_destroy(fedlg->fs);
}

static void form_edit_dlg_load_file(GtkWidget * w,
  struct form_edit_dlg_t *fedlg)
{
  if(!fedlg->fs)
  {
    fedlg->fs = gtk_file_selection_new(gettext("Pavuk: load form file"));

    gtk_signal_connect(GTK_OBJECT(fedlg->fs), "destroy",
      GTK_SIGNAL_FUNC(gtk_widget_destroyed), &fedlg->fs);

    gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fedlg->fs)->ok_button),
      "clicked", GTK_SIGNAL_FUNC(form_edit_dlg_load_file_ok), fedlg);

    gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fedlg->fs)->
        cancel_button), "clicked", GTK_SIGNAL_FUNC(PopdownW), fedlg->fs);
  }
  gtk_widget_show(fedlg->fs);
  if(GTK_WIDGET_REALIZED(fedlg->fs))
    gdk_window_raise(fedlg->fs->window);
}

static void form_edit_dlg_fill(struct form_edit_dlg_t *fedlg)
{
  GtkWidget *label, *button, *vbox, *pbox, *frame;
  GtkWidget *menu;

  vbox = gtk_vbox_new(FALSE, 2);
  gtk_widget_show(vbox);
  label = gtk_label_new(gettext("Fill forms"));
  gtk_notebook_append_page(GTK_NOTEBOOK(fedlg->tab), vbox, label);

  pbox = gtk_table_new(2, 4, FALSE);
  gtk_box_pack_start(GTK_BOX(vbox), pbox, FALSE, FALSE, 2);
  gtk_widget_show(pbox);

  label = gtk_label_new(gettext("Form number: "));
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_table_attach(GTK_TABLE(pbox), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 2,
    2);
  gtk_widget_show(label);

  fedlg->formnr = gtk_option_menu_new();
  gtk_widget_set_usize(fedlg->formnr, 45, -1);
  gtk_table_attach(GTK_TABLE(pbox), fedlg->formnr, 1, 2, 0, 1, GTK_SHRINK,
    GTK_SHRINK, 2, 2);
  menu = gtk_menu_new();
  gtk_option_menu_set_menu(GTK_OPTION_MENU(fedlg->formnr), menu);
  gtk_widget_show(fedlg->formnr);

  label = gtk_label_new(gettext("Action URL: "));
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_table_attach(GTK_TABLE(pbox), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 2,
    2);
  gtk_widget_show(label);

  fedlg->action = gtk_label_new("");
  gtk_table_attach(GTK_TABLE(pbox), fedlg->action, 1, 2, 1, 2, GTK_FILL,
    GTK_FILL, 2, 2);
  gtk_widget_show(fedlg->action);

  label = gtk_label_new(gettext("Request method: "));
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_table_attach(GTK_TABLE(pbox), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 2,
    2);
  gtk_widget_show(label);

  fedlg->method = gtk_label_new("");
  gtk_table_attach(GTK_TABLE(pbox), fedlg->method, 1, 2, 2, 3, GTK_FILL,
    GTK_FILL, 2, 2);
  gtk_widget_show(fedlg->method);

  label = gtk_label_new(gettext("Request encoding: "));
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_table_attach(GTK_TABLE(pbox), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 2,
    2);
  gtk_widget_show(label);

  fedlg->encoding = gtk_label_new("");
  gtk_table_attach(GTK_TABLE(pbox), fedlg->encoding, 1, 2, 3, 4, GTK_FILL,
    GTK_FILL, 2, 2);
  gtk_widget_show(fedlg->encoding);

  frame = gtk_frame_new(gettext("HTML form content"));
  gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 2);
  gtk_widget_show(frame);

  fedlg->swin = gtk_scrolled_window_new(NULL, NULL);
  gtk_widget_set_usize(fedlg->swin, 400, 200);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(fedlg->swin),
    GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
  gtk_container_add(GTK_CONTAINER(frame), fedlg->swin);
  gtk_widget_show(fedlg->swin);

  pbox = gtk_hbutton_box_new();
  gtk_box_pack_start(GTK_BOX(vbox), pbox, FALSE, FALSE, 2);
  gtk_widget_show(pbox);

  button = guitl_pixmap_button(load_xpm, NULL, gettext("Load HTML file ..."));
  gtk_container_add(GTK_CONTAINER(pbox), button);
  gtk_widget_show(button);

  gtk_signal_connect(GTK_OBJECT(button), "clicked",
    GTK_SIGNAL_FUNC(form_edit_dlg_load_file), fedlg);

}

static void form_edit_dlg_close(GtkWidget * w, struct form_edit_dlg_t *fedlg)
{
  gtk_widget_hide(fedlg->top);
  _free(fedlg->docdata);
  if(fedlg->formdata)
  {
    form_free(fedlg->formdata);
    fedlg->formdata = NULL;
    gtk_widget_destroy(fedlg->form);
  }
  gtk_notebook_set_page(GTK_NOTEBOOK(fedlg->tab), 0);
}

static struct form_edit_dlg_t fedlg_info =
  { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };

void form_edit_dlg_clear(void)
{
  if(!fedlg_info.top)
    return;

  if(!MT_IS_MAIN_THREAD())
  {
    GDK_THREADS_ENTER();
  }

  form_edit_dlg_refresh_list(NULL, &fedlg_info);
  fedlg_info.parent_url = NULL;
  form_edit_dlg_load_html_file(NULL, &fedlg_info);

  if(!MT_IS_MAIN_THREAD())
  {
    GDK_THREADS_LEAVE();
  }
}

void form_edit_dlg(void)
{
  if(!fedlg_info.top)
  {
    GtkWidget *tbox, *bbox, *button;

    fedlg_info.top = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(fedlg_info.top),
      gettext("Pavuk: HTML forms editor"));
    gtk_signal_connect(GTK_OBJECT(fedlg_info.top), "destroy",
      GTK_SIGNAL_FUNC(gtk_widget_destroyed), &fedlg_info.top);

    tbox = gtk_vbox_new(FALSE, 2);
    gtk_container_add(GTK_CONTAINER(fedlg_info.top), tbox);
    gtk_widget_show(tbox);

    fedlg_info.tab = gtk_notebook_new();
    gtk_box_pack_start(GTK_BOX(tbox), fedlg_info.tab, TRUE, TRUE, 2);
    gtk_widget_show(fedlg_info.tab);

    form_edit_dlg_browse(&fedlg_info);
    form_edit_dlg_fill(&fedlg_info);

    gtk_signal_connect(GTK_OBJECT(fedlg_info.tab), "switch_page",
      GTK_SIGNAL_FUNC(form_edit_dlg_switch_page), &fedlg_info);

    bbox = gtk_hbutton_box_new();
    gtk_box_pack_start(GTK_BOX(tbox), bbox, FALSE, FALSE, 2);
    gtk_widget_show(bbox);

    button = guitl_pixmap_button(cancel_xpm, NULL, gettext("Close"));
    gtk_container_add(GTK_CONTAINER(bbox), button);
    gtk_widget_show(button);

    gtk_signal_connect(GTK_OBJECT(button), "clicked",
      GTK_SIGNAL_FUNC(form_edit_dlg_close), &fedlg_info);
  }
  form_edit_dlg_refresh_list(NULL, &fedlg_info);
  gtk_widget_show(fedlg_info.top);
  if(GTK_WIDGET_REALIZED(fedlg_info.top))
    gdk_window_raise(fedlg_info.top->window);
}

#endif /* GTK_FACE */