form.c

网络爬虫程序

      {
        fstag = TRUE;

        plastformtag = lastformtag;
        lastformtag = form_parse_optiontag(stack);
        lastformtag->multiple = selectgroup->multiple;
        if(optgroup)
        {
          optgroup->infos = dllist_append(optgroup->infos,
          (dllist_t)lastformtag);
        }
        else
        {
          selectgroup->infos = dllist_append(selectgroup->infos,
          (dllist_t) lastformtag);
        }
      }
      else if(selectgroup && lastformtag && IS_TAG("/OPTION"))
      {
        if(tr && lastformtag->type == FORM_T_OPTION)
        {
          text[tr] = '\0';
          sp = text;
          while(*sp && tl_ascii_isspace(*sp))
            sp++;
          if(!lastformtag->text && *sp)
          {
            int l = strcspn(sp, "\r\n");
            lastformtag->text = tl_strndup(sp, l);
            memmove(text, sp + l, strlen(sp + l + 1));
            tr = strlen(text);
          }
          else
            tr = 0;
          /*
             <OPTION VALUE="somevalue">sometext</OPTION>
             <OPTION>somevalue</OPTION>
             If no value given, then take value from text
             - PJS
           */
          if(!lastformtag->default_value)
          {
            lastformtag->default_value = tl_strdup(lastformtag->text);
          }
        }
      }
      else if(retv && IS_TAG("TEXTAREA"))
      {
        fstag = TRUE;

        plastformtag = lastformtag;
        lastformtag = form_parse_textareatag(stack);

        retv->infos = dllist_append(retv->infos, (dllist_t)lastformtag);
      }
      else if(retv && lastformtag && IS_TAG("/TEXTAREA"))
      {
        if(tr && lastformtag->type == FORM_T_TEXTAREA)
        {
          text[tr] = '\0';
          sp = text;
          while(*sp && tl_ascii_isspace(*sp))
            sp++;
          if(!lastformtag->default_value && *sp)
            lastformtag->default_value = tl_strdup(sp);
          tr = 0;
        }
      }
      else if(IS_TAG("BR"))
      {
        TEXPAND(1);
        text[tr] = '\n';
        tr++;
      }

      if(fstag && tr)
      {
        char *sp;

        text[tr] = '\0';
        sp = text;
        while(*sp && tl_ascii_isspace(*sp))
          sp++;

        if(*sp && plastformtag)
        {
          if(plastformtag->type == FORM_T_RADIO ||
            plastformtag->type == FORM_T_CHECKBOX ||
            plastformtag->type == FORM_T_OPTION)
          {
            int ln = strcspn(sp, "\r\n");
            if(!plastformtag->text)
              plastformtag->text = tl_strndup(sp, ln);
            sp += ln;
            sp += strspn(sp, "\r\n \t");
          }
        }
        if(*sp)
        {
          form_field_info *ffi;
          dllist *last;


          ffi = form_field_info_new();
          ffi->type = FORM_T_NONFORM;
          ffi->text = tl_strdup(sp);

          if(optgroup)
          {
            last = dllist_last(optgroup->infos);
            optgroup->infos =
              dllist_insert_before(optgroup->infos, last, (dllist_t) ffi);
          }
          else if(selectgroup)
          {
            last = dllist_last(selectgroup->infos);
            selectgroup->infos =
              dllist_insert_before(selectgroup->infos, last, (dllist_t) ffi);
          }
          else
          {
            last = dllist_last(retv->infos);
            retv->infos = dllist_insert_before(retv->infos, last,
            (dllist_t) ffi);
          }
        }
        tr = 0;
      }
    }
    else if(tagstart)
    {
      SEXPAND(1);
      stack[sr] = form_text[i];
      sr++;
    }
    else
    {
      TEXPAND(1);
      text[tr] = form_text[i];
      tr++;
    }
  }
  if(retv)
  {
    retv->text = form_text;

    if(tr)
    {
      text[tr] = '\0';
      sp = text;
      while(*sp && tl_ascii_isspace(*sp))
        sp++;

      if(*sp)
      {
        form_field_info *ffi;

        ffi = form_field_info_new();
        ffi->type = FORM_T_NONFORM;
        ffi->text = tl_strdup(sp);

        retv->infos = dllist_append(retv->infos, (dllist_t)ffi);
      }
    }
  }

  _free(stack);
  _free(text);
  return retv;
}

void form_get_default_successful(char *name, dllist * fields, dllist ** retv)
{
  dllist *ptr;

  ptr = fields;
  while(ptr)
  {
    form_field_info *ffi = (form_field_info *) ptr->data;
    char *n, *v;

    n = NULL;
    v = NULL;
    switch (ffi->type)
    {
    case FORM_T_TEXT:
    case FORM_T_PASSWORD:
    case FORM_T_FILE:
    case FORM_T_TEXTAREA:
    case FORM_T_HIDDEN:
      n = ffi->name;
      v = tl_strdup(ffi->default_value);
      break;
    case FORM_T_RADIO:
    case FORM_T_CHECKBOX:
      if(ffi->checked)
      {
        n = ffi->name;
        v = tl_strdup(ffi->default_value);
      }
      break;
    case FORM_T_OPTION:
      if(ffi->selected)
      {
        n = ffi->name ? ffi->name : name;
        v = tl_strdup(ffi->default_value);
      }
      break;
    case FORM_T_OPTGROUP:
      form_get_default_successful(name, ffi->infos, retv);
      break;
    case FORM_T_SELECT:
      form_get_default_successful(ffi->name, ffi->infos, retv);
      break;
    default:
      /* nothing to do */
      break;
    }
    if(n)
    {
      form_field *ff = _malloc(sizeof(form_field));

      ff->type = ffi->type;

      ff->name = tl_strdup(n);
      ff->value = v ? v : tl_strdup("");
      *retv = dllist_append(*retv, (dllist_t)ff);
    }
    ptr = ptr->next;
  }
}

#if GTK_FACE
static void form_get_successful(char *name, dllist * fields, dllist ** retv)
{
  dllist *ptr;

  for(ptr = fields; ptr; ptr = ptr->next)
  {
    form_field_info *ffi = (form_field_info *) ptr->data;
    char *n, *v;

    if(!ffi->widget && (ffi->type != FORM_T_HIDDEN))
      continue;

    n = NULL;
    v = NULL;
    switch (ffi->type)
    {
    case FORM_T_TEXT:
    case FORM_T_PASSWORD:
      n = ffi->name;
      v = tl_strdup(gtk_entry_get_text(GTK_ENTRY(ffi->widget)));
      break;
    case FORM_T_FILE:
      n = ffi->name;
      v = tl_strdup(gtk_entry_get_text(GTK_ENTRY(ffi->widget)));
      break;
    case FORM_T_RADIO:
    case FORM_T_CHECKBOX:
      if(GTK_TOGGLE_BUTTON(ffi->widget)->active)
      {
        n = ffi->name;
        v = tl_strdup(ffi->default_value);
      }
      break;
    case FORM_T_TEXTAREA:
      {
        int len;
        char *p;

#if GTK_FACE < 2
        len = gtk_text_get_length(GTK_TEXT(ffi->widget));
#else
        len = gtk_text_buffer_get_char_count(
          gtk_text_view_get_buffer(GTK_TEXT_VIEW(ffi->widget)));
#endif
        p = gtk_editable_get_chars(GTK_EDITABLE(ffi->widget), 0, len);
        v = tl_strdup(p);
        g_free(p);
        n = ffi->name;
      }
      break;
    case FORM_T_OPTION:
      if(GTK_IS_CLIST(ffi->widget))
      {
        if(g_list_find(GTK_CLIST(ffi->widget)->selection, (void *) ffi->idx))
        {
          n = ffi->name ? ffi->name : name;
          v = tl_strdup(ffi->default_value);
        }
      }
      else
      {
        if(GTK_CHECK_MENU_ITEM(ffi->widget)->active)
        {
          n = ffi->name ? ffi->name : name;
          v = tl_strdup(ffi->default_value);
        }
      }
      break;
    case FORM_T_HIDDEN:
      n = ffi->name;
      v = tl_strdup(ffi->default_value);
      break;
    case FORM_T_OPTGROUP:
      form_get_successful(name, ffi->infos, retv);
      break;
    case FORM_T_SELECT:
      form_get_successful(ffi->name, ffi->infos, retv);
      break;
    default:
      /* nothing to do */
      break;
    }
    if(n)
    {
      form_field *ff = _malloc(sizeof(form_field));

      ff->type = ffi->type;

      ff->name = tl_strdup(n);
      ff->value = v ? v : tl_strdup("");
      *retv = dllist_append(*retv, (dllist_t)ff);
    }
  }
}

static void form_submit_cb(GtkWidget * w, form_info * fi)
{
  form_field_info *ffi = NULL;
  dllist *fields = NULL;
  url_info *ui;

  if(w)
    ffi = (form_field_info *) gtk_object_get_user_data(GTK_OBJECT(w));

  form_get_successful(NULL, fi->infos, &fields);

  if(ffi && ffi->name)
  {
    form_field *ff = _malloc(sizeof(form_field));

    ff->type = ffi->type;
    ff->name = tl_strdup(ffi->name);
    ff->value =
      ffi->default_value ? tl_strdup(ffi->default_value) : tl_strdup("");
    fields = dllist_prepend(fields, (dllist_t) ff);
  }

  ui = url_info_new(fi->action);
  ui->type = URLI_FORM;
  ui->method = fi->method;
  ui->encoding = fi->encoding;
  ui->fields = fields;

  if(gui_cfg.config_shell)
  {
    url_info *cui;
    int row = gtk_clist_append(GTK_CLIST(gui_cfg.url_list), &fi->action);
    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);

  if(cfg.mode_started)
  {
    if(!append_starting_url(ui, fi->parent_url))
    {
      gdk_beep();
    }
  }
}

static void form_reset(dllist * fields)
{
  while(fields)
  {
    form_field_info *ffi = (form_field_info *) fields->data;

    switch (ffi->type)
    {
    case FORM_T_TEXT:
    case FORM_T_PASSWORD:
      gtk_entry_set_text(GTK_ENTRY(ffi->widget), ffi->default_value);
      break;
    case FORM_T_FILE:
      gtk_entry_set_text(GTK_ENTRY(ffi->widget), ffi->default_value);
      break;
    case FORM_T_RADIO:
    case FORM_T_CHECKBOX:
      gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ffi->widget),
        ffi->checked);
      break;
    case FORM_T_OPTGROUP:
    case FORM_T_SELECT:
      form_reset(ffi->infos);
      break;
    case FORM_T_OPTION:
      gtk_check_menu_item_set_state(GTK_CHECK_MENU_ITEM(ffi->widget),
        ffi->selected);
      break;
    case FORM_T_TEXTAREA:
#if GTK_FACE < 2
      gtk_text_set_point(GTK_TEXT(ffi->widget), 0);
      gtk_text_forward_delete(GTK_TEXT(ffi->widget),
        gtk_text_get_length(GTK_TEXT(ffi->widget)));
      if(ffi->default_value)
        gtk_text_insert(GTK_TEXT(ffi->widget), NULL, NULL, NULL,
          ffi->default_value, strlen(ffi->default_value));
#else
      gtk_text_buffer_set_text(gtk_text_view_get_buffer(
      GTK_TEXT_VIEW(ffi->widget)), ffi->default_value
      ? ffi->default_value : "", -1);
#endif
      break;
    default:
      break;
    }

    fields = fields->next;
  }
}

static void form_reset_cb(GtkWidget * w, form_info * fi)
{
  form_reset(fi->infos);
}

static GtkWidget *form_render_optgroup(form_field_info * sel, dllist * dl)
{
  GtkWidget *menu, *mi;
  char *p;
  dllist *ptr;

  menu = gtk_menu_new();
  gtk_widget_realize(menu);

  ptr = dl;
  while(ptr)
  {
    form_field_info *ffi = (form_field_info *) ptr->data;

    mi = NULL;
    switch (ffi->type)
    {
    case FORM_T_OPTION:
      if(ptr->next &&
        (((form_field_info *) ptr->next->data)->type == FORM_T_NONFORM))
      {
        if(ffi->text)
          p = ffi->text;
        else
          p = ((form_field_info *) ptr->next->data)->text;
        ptr = ptr->next;
      }
      else if(ffi->text)
        p = ffi->text;
      else if(ffi->default_value)
        p = ffi->default_value;
      else
        p = "option";
      if(ffi->multiple)
        mi = gtk_check_menu_item_new_with_label(p);
      else
      {
        mi = gtk_radio_menu_item_new_with_label(sel->rg, p);
        sel->rg = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(mi));
      }
      break;
    case FORM_T_OPTGROUP:
      if(ptr->next &&
        (((form_field_info *) ptr->next->data)->type == FORM_T_NONFORM))
      {
        if(ffi->text)
          p = ffi->text;
        else
          p = ((form_field_info *) ptr->next->data)->text;
        ptr = ptr->next;
      }
      else if(ffi->text)
        p = ffi->text;
      else
        p = "optgroup";
      mi = gtk_menu_item_new_with_label(p);
      gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi),
        form_render_optgroup(sel, ffi->infos));
      break;
    default:
      xprintf(0, gettext("Unsupported form type in context: %d\n"),
        ffi->type);
      break;
    }
    if(mi)
    {
      gtk_menu_append(GTK_MENU(menu), mi);
      gtk_widget_show(mi);
      gtk_object_set_user_data(GTK_OBJECT(mi), ffi);
      gtk_widget_set_sensitive(mi, !ffi->disabled);
    }
    ffi->widget = mi;

    ptr = ptr->next;
  }

  return menu;
}

static GtkWidget *form_render_selection(form_field_info * ffi)
{
  GtkWidget *w, *menu;

  if(ffi->height > 1)
  {
    dllist *ptr;
    GtkWidget *swin = NULL;


    w = gtk_clist_new(1);
    if(ffi->multiple)
    {
      gtk_clist_set_selection_mode(GTK_CLIST(w), GTK_SELECTION_MULTIPLE);
    }
    else
    {
      gtk_clist_set_selection_mode(GTK_CLIST(w), GTK_SELECTION_SINGLE);
    }
    gtk_object_set_user_data(GTK_OBJECT(w), ffi);
    gtk_widget_set_sensitive(w, !ffi->disabled);
    for(ptr = ffi->infos; ptr; ptr = ptr->next)
    {
      form_field_info *offi = (form_field_info *) ptr->data;

      if(offi->type == FORM_T_OPTION)
      {
        char *p;

        if(offi->text)
          p = offi->text;
        else if(offi->default_value)
          p = offi->default_value;
        else
          p = "option";

        offi->idx = gtk_clist_append(GTK_CLIST(w), &p);
        gtk_clist_set_selectable(GTK_CLIST(w), offi->idx, !offi->disabled);
        if(offi->selected)
          gtk_clist_select_row(GTK_CLIST(w), offi->idx, 0);
        offi->widget = w;
      }
      else
      {
        xprintf(0, gettext("Unsupported form type in context: %d\n"),
          ffi->type);
      }
    }
    ffi->widget = w;

    swin = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
      GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_widget_show(swin);
    gtk_container_add(GTK_CONTAINER(swin), w);

    gtk_widget_show(w);
    if(swin)
      w = swin;
  }
  else
  {
    w = gtk_option_menu_new();
    menu = form_render_optgroup(ffi, ffi->infos);
    gtk_option_menu_set_menu(GTK_OPTION_MENU(w), menu);
    gtk_object_set_user_data(GTK_OBJECT(w), ffi);
    gtk_widget_set_sensitive(w, !ffi->disabled);
  }

  return w;
}

static GtkWidget *form_render(form_info * fi, GtkWidget * pbox)
{
  GtkWidget *box, *w;
  dllist *ptr, *ptr2;
  char *p;

  box = gtk_vbox_new(FALSE, 2);
  gtk_box_pack_start(GTK_BOX(pbox), box, FALSE, FALSE, 1);
  gtk_widget_show(box);

  for(ptr = fi->infos; ptr; ptr = ptr->next)
  {
    form_field_info *ffi;

    ffi = (form_field_info *) ptr->data;