gui_tools.c

来自「网络爬虫程序」· C语言 代码 · 共 949 行 · 第 1/2 页

  int ofs = 0;

  info = _malloc(sizeof(struct path_entry_info));
  info->fs = NULL;
  info->label = label ? tl_strndup(label, strlen(label) - 2) : NULL;
  info->fslabel = tl_strdup(fslabel);
  info->isdir = dir;

  box = gtk_hbox_new(0, 0);
  gtk_widget_show(box);
  gtk_table_attach(GTK_TABLE(table), box, col, col + 1, row, row + 1,
    GTK_FILL | GTK_SHRINK, GTK_FILL, 2, 2);

  if(label)
  {
    labelw = gtk_label_new(label);
    gtk_box_pack_start(GTK_BOX(box), labelw, FALSE, TRUE, 0);
    gtk_misc_set_alignment(GTK_MISC(labelw), 0.0, 0.5);
    gtk_widget_show(labelw);
    ofs = 1;
  }

  pom = gtk_hbox_new(FALSE, 0);
  gtk_widget_show(pom);
  gtk_table_attach(GTK_TABLE(table), pom, col + ofs, col + ofs + 1,
    row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 2, 2);

  info->entry = entry = gtk_entry_new();
  gtk_box_pack_start(GTK_BOX(pom), entry, TRUE, TRUE, 0);
  gtk_widget_show(entry);

  gtk_signal_connect(GTK_OBJECT(entry), "destroy",
    GTK_SIGNAL_FUNC(path_entry_info_destroy), (gpointer) info);

  gtk_signal_connect(GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(entry))),
    "hide", GTK_SIGNAL_FUNC(path_entry_info_hide), (gpointer) info);

  button = guitl_pixmap_button(browse_xpm, NULL, gettext("Browse ..."));
  gtk_box_pack_end(GTK_BOX(pom), button, FALSE, TRUE, 2);
  gtk_widget_show(button);

  gtk_signal_connect(GTK_OBJECT(button), "clicked",
    GTK_SIGNAL_FUNC(GetFile), (gpointer) info);

  return entry;
}

GtkWidget *guitl_tab_add_path_entry(GtkWidget * table, char *label,
  guint col, guint row, int dir)
{
  return guitl_tab_add_path_entry_full(table, label, col, row, dir, NULL);
}

void guitl_ListDeleteSelected(GtkObject * object, gpointer func_data)
{
  GtkWidget *w = (GtkWidget *) func_data;

  gtk_clist_freeze(GTK_CLIST(w));

  if(GTK_CLIST(w)->selection)
  {
    gtk_clist_remove(GTK_CLIST(w),
      GPOINTER_TO_INT(GTK_CLIST(w)->selection->data));
  }

  gtk_clist_thaw(GTK_CLIST(w));

  if(!GTK_CLIST(w)->rows)
    gtk_signal_emit_by_name(GTK_OBJECT(func_data), "select_row", 0, 0, NULL);
}

void guitl_ListInsertEntry(GtkObject * object, gpointer func_data)
{
  listanfo *lnfo = (listanfo *) func_data;
  const char *p;

  p = gtk_entry_get_text(GTK_ENTRY(lnfo->entry));

  if(p && *p)
  {
    gtk_clist_append(GTK_CLIST(lnfo->list), (gchar **) &p);
  }
  else
    gdk_beep();
}

void guitl_ListModifyEntry(GtkObject * object, gpointer func_data)
{
  listanfo *lnfo = (listanfo *) func_data;
  const char *p;

  p = gtk_entry_get_text(GTK_ENTRY(lnfo->entry));

  if(p && *p && GTK_CLIST(lnfo->list)->selection)
  {
    int row = GPOINTER_TO_INT(GTK_CLIST(lnfo->list)->selection->data);
    gtk_clist_set_text(GTK_CLIST(lnfo->list), row, 0, p);
  }
  else
    gdk_beep();
}

void guitl_ListClear(GtkObject * object, gpointer func_data)
{
  gtk_clist_freeze(GTK_CLIST(func_data));
  gtk_clist_clear(GTK_CLIST(func_data));
  gtk_clist_thaw(GTK_CLIST(func_data));

  gtk_signal_emit_by_name(GTK_OBJECT(func_data), "select_row", 0, 0, NULL);
}

void guitl_ListCopyToEntry(GtkObject * object, int row, int col,
  GdkEvent * event, gpointer func_data)
{
  GtkWidget *entry = (GtkWidget *) func_data;
  char *p = NULL;

  if(GTK_CLIST(object)->selection)
    gtk_clist_get_text(GTK_CLIST(object), row, 0, &p);

  if(!p)
    p = "";

  if(entry)
    gtk_entry_set_text(GTK_ENTRY(entry), p);
}

void guitl_ListInsertList(GtkObject * object, gpointer func_data)
{
  listanfo *lnfo = (listanfo *) func_data;
  GList *dlist = GTK_CLIST(lnfo->entry)->selection;
  char *p;

  if(!dlist)
    gdk_beep();

  while(dlist)
  {
    gtk_clist_get_text(GTK_CLIST(lnfo->entry),
      GPOINTER_TO_INT(dlist->data), 0, &p);

    gtk_clist_append(GTK_CLIST(lnfo->list), &p);
    dlist = dlist->next;
  }
}

GtkWidget *guitl_new_edit_list(GtkWidget ** list, GtkWidget ** entry,
  char *label, GtkWidget ** dbutton, GtkWidget ** mbutton,
  GtkWidget ** cbutton, GtkWidget ** abutton, gboolean connect_entry,
  const char **vals)
{
  GtkWidget *swin;
  GtkWidget *box, *brow, *button;
  listanfo *p = NULL;

  box = gtk_table_new(3, 1, FALSE);
  gtk_widget_show(box);

  swin = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_table_attach_defaults(GTK_TABLE(box), swin, 0, 1, 0, 1);
  gtk_widget_show(swin);

  *list = gtk_clist_new(1);
  gtk_clist_set_selection_mode(GTK_CLIST(*list), GTK_SELECTION_BROWSE);
  gtk_clist_set_reorderable(GTK_CLIST(*list), TRUE);
  gtk_clist_set_column_auto_resize(GTK_CLIST(*list), 0, TRUE);
  gtk_container_add(GTK_CONTAINER(swin), *list);
  gtk_widget_show(*list);

  brow = gtk_table_new(1, 2, FALSE);
  gtk_table_attach(GTK_TABLE(box), brow, 0, 1, 1, 2,
    GTK_EXPAND | GTK_FILL, GTK_FILL, 2, 5);
  gtk_widget_show(brow);

  if(vals)
    *entry = guitl_tab_add_enum(brow, label, 0, 0, vals, TRUE);
  else
    *entry = guitl_tab_add_entry(brow, label, 0, 0, FALSE);

  if(connect_entry)
    gtk_signal_connect(GTK_OBJECT(*list), "select_row",
      GTK_SIGNAL_FUNC(guitl_ListCopyToEntry), (gpointer) * entry);

  brow = gtk_hbutton_box_new();
  gtk_table_attach(GTK_TABLE(box), brow, 0, 1, 2, 3,
    GTK_EXPAND | GTK_FILL, GTK_FILL, 2, 5);
  gtk_hbutton_box_set_spacing_default(1);
  gtk_widget_show(brow);

  gtk_button_box_set_layout(GTK_BUTTON_BOX(brow), GTK_BUTTONBOX_SPREAD);

  button = guitl_pixmap_button(append_xpm, NULL, gettext("Append"));
  gtk_container_border_width(GTK_CONTAINER(button), 0);
  gtk_container_add(GTK_CONTAINER(brow), button);
  gtk_widget_show(button);

  if(!abutton)
  {
    p = g_malloc(sizeof(listanfo));

    p->list = *list;
    p->entry = *entry;

    gtk_signal_connect(GTK_OBJECT(button), "clicked",
      GTK_SIGNAL_FUNC(guitl_ListInsertEntry), (gpointer) p);

    gtk_signal_connect(GTK_OBJECT(*entry), "activate",
      GTK_SIGNAL_FUNC(guitl_ListInsertEntry), (gpointer) p);
  }
  else
    *abutton = button;

  button = guitl_pixmap_button(modify_xpm, NULL, gettext("Modify"));
  gtk_container_border_width(GTK_CONTAINER(button), 0);
  gtk_container_add(GTK_CONTAINER(brow), button);
  gtk_widget_show(button);

  if(!mbutton)
  {
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
      GTK_SIGNAL_FUNC(guitl_ListModifyEntry), (gpointer) p);
  }
  else
    *mbutton = button;

  button = guitl_pixmap_button(clear_xpm, NULL, gettext("Clear"));
  gtk_container_border_width(GTK_CONTAINER(button), 0);
  gtk_container_add(GTK_CONTAINER(brow), button);
  gtk_widget_show(button);

  if(!cbutton)
  {
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
      GTK_SIGNAL_FUNC(guitl_ListClear), (gpointer) * list);
  }
  else
    *cbutton = button;

  button = guitl_pixmap_button(delete_xpm, NULL, gettext("Delete"));
  gtk_container_border_width(GTK_CONTAINER(button), 0);
  gtk_container_add(GTK_CONTAINER(brow), button);
  gtk_widget_show(button);

  if(!dbutton)
  {
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
      GTK_SIGNAL_FUNC(guitl_ListDeleteSelected), (gpointer) * list);
  }
  else
    *dbutton = button;

  return box;
}

Icon *guitl_load_pixmap(char **pmap)
{
  GdkWindow *win = GTK_WIDGET(gui_cfg.toplevel)->window;
  Icon *icon = malloc(sizeof(Icon));

  icon->pixmap = gdk_pixmap_create_from_xpm_d(win, &icon->shape, NULL, pmap);

  return icon;
}

GtkWidget *guitl_pixmap_button(char **pm, char *alticon, char *label)
{
  GtkWidget *btn;
  GtkWidget *pixmap = NULL;
  Icon *icon;

  btn = gtk_button_new();

  if(alticon)
  {
    GdkPixmap *pm;
    GdkBitmap *mask;

    pm =
      gdk_pixmap_create_from_xpm(GTK_WIDGET(gui_cfg.toplevel)->window, &mask,
      NULL, alticon);

    if(pm)
    {
      pixmap = gtk_pixmap_new(pm, mask);
    }
  }
  if(!pixmap)
  {
    icon = guitl_load_pixmap(pm);

    pixmap = gtk_pixmap_new(icon->pixmap, icon->shape);
    _free(icon);
  }

  if(label)
  {
    GtkWidget *box;
    GtkWidget *lbl;

    box = gtk_hbox_new(FALSE, 1);
    gtk_container_add(GTK_CONTAINER(btn), box);
    gtk_widget_show(box);

    gtk_box_pack_start(GTK_BOX(box), pixmap, TRUE, TRUE, 0);
    gtk_misc_set_alignment(GTK_MISC(pixmap), 1.0, 0.5);
    gtk_widget_show(pixmap);

    lbl = gtk_label_new(label);
    gtk_misc_set_alignment(GTK_MISC(lbl), 0.0, 0.5);
    gtk_box_pack_start(GTK_BOX(box), lbl, TRUE, TRUE, 0);
    gtk_widget_show(lbl);

  }
  else
  {
    gtk_container_add(GTK_CONTAINER(btn), pixmap);
    gtk_widget_show(pixmap);
  }

  return btn;
}

void guitl_PopdownW(GtkObject * object, gpointer func_data)
{
  GtkWidget *w = (GtkWidget *) func_data;

  gtk_widget_hide(w);
}

static void menu_kill(GtkWidget * w, GtkWidget * menu)
{
  gtk_widget_destroy(menu);
}

void guitl_menu_attach(GtkWidget * menu, GtkWidget * parent)
{
  gtk_signal_connect(GTK_OBJECT(parent), "destroy",
    GTK_SIGNAL_FUNC(menu_kill), menu);
  gtk_object_set_data(GTK_OBJECT(menu), "guitl_menu_parent", parent);
}

GtkWidget *guitl_menu_parent(GtkWidget * menu)
{
  return gtk_object_get_data(GTK_OBJECT(menu), "guitl_menu_parent");
}

static char *guitl_selection_content = NULL;
enum
{
  GUITL_SEL_TYPE_NONE,
  GUITL_COMPOUND_TEXT,
  GUITL_STRING,
  GUITL_TEXT,
  GUITL_LAST_SEL_TYPE
};

static gint guitl_selection_clear(GtkWidget * widget,
  GdkEventSelection * event)
{
  g_free(guitl_selection_content);
  guitl_selection_content = NULL;

  return TRUE;
}

static void guitl_selection_get(GtkWidget * widget,
  GtkSelectionData * selection_data, guint info, guint time, gpointer data)
{
  GdkAtom type = GDK_NONE;
  switch (info)
  {
  case GUITL_COMPOUND_TEXT:
    type = gdk_atom_intern("COMPOUND_TEXT", FALSE);
    break;
  case GUITL_TEXT:
    type = gdk_atom_intern("TEXT", FALSE);
    break;
  case GUITL_STRING:
    type = gdk_atom_intern("STRING", FALSE);
    break;
  }
  gtk_selection_data_set(selection_data, type, 8 * sizeof(gchar),
    guitl_selection_content, strlen(guitl_selection_content));
}

void guitl_set_clipboard_content(char *content)
{
  GdkAtom clipboard_atom;
  static bool_t initialized = FALSE;
  static GtkTargetEntry targetlist[] = {
    {"STRING", 0, GUITL_STRING},
    {"TEXT", 0, GUITL_TEXT},
    {"COMPOUND_TEXT", 0, GUITL_COMPOUND_TEXT}
  };

  if(!initialized)
  {
    initialized = TRUE;
    clipboard_atom = gdk_atom_intern("CLIPBOARD", FALSE);

    gtk_selection_add_targets(gui_cfg.toplevel,
      GDK_SELECTION_PRIMARY,
      targetlist, sizeof(targetlist) / sizeof(targetlist[0]));
    gtk_selection_add_targets(gui_cfg.toplevel, clipboard_atom,
      targetlist, sizeof(targetlist) / sizeof(targetlist[0]));
    gtk_signal_connect(GTK_OBJECT(gui_cfg.toplevel),
      "selection_get", GTK_SIGNAL_FUNC(guitl_selection_get), NULL);
    gtk_signal_connect(GTK_OBJECT(gui_cfg.toplevel),
      "selection_clear_event", GTK_SIGNAL_FUNC(guitl_selection_clear), NULL);
  }

  g_free(guitl_selection_content);
  guitl_selection_content = g_strdup(content);

  gtk_selection_owner_set(gui_cfg.toplevel,
    GDK_SELECTION_PRIMARY, GDK_CURRENT_TIME);
  clipboard_atom = gdk_atom_intern("CLIPBOARD", FALSE);
  gtk_selection_owner_set(gui_cfg.toplevel, clipboard_atom, GDK_CURRENT_TIME);
}

void guitl_clist_selection_to_clipboard(GtkWidget * w, GtkWidget * clist)
{
  char *t = NULL, *p;
  GList *sel;

  for(sel = GTK_CLIST(clist)->selection; sel; sel = sel->next)
  {
    int row = GPOINTER_TO_INT(sel->data);
    gtk_clist_get_text(GTK_CLIST(clist), row, 0, &p);
    t = tl_str_concat(t, p, "\n", NULL);
  }

  if(t)
  {
    guitl_set_clipboard_content(t);
    _free(t);
  }
}

GtkWidget *guitl_toolbar_button(GtkWidget * parent, char *label, char *help,
  char **pmap, GtkSignalFunc cb, gpointer cb_data, char *alticon)
{
  GtkWidget *button = NULL;
  GtkWidget *pixmap = NULL;
  Icon *icon;

  if(alticon)
  {
    GdkPixmap *pm;
    GdkBitmap *mask;

    pm = gdk_pixmap_create_from_xpm(GTK_WIDGET(gui_cfg.toplevel)->window,
      &mask, NULL, alticon);

    if(pm)
      pixmap = gtk_pixmap_new(pm, mask);
  }
  if(pmap && !pixmap)
  {
    icon = guitl_load_pixmap(pmap);

    pixmap = gtk_pixmap_new(icon->pixmap, icon->shape);
    _free(icon);
  }

  button = gtk_toolbar_append_item(GTK_TOOLBAR(parent), label,
    help, "", pixmap, cb, cb_data);

  return button;
}
#endif