Ejemplo n.º 1
0
void
Launch_Gtk_Process(int pipe_number)
{
    int	argc = 0;
    gchar **argv = NULL;
    GtkWidget *button, *mbar, *swin;
    GtkWidget *table, *align, *handlebox;
    GtkWidget *vbox, *hbox, *vbox2, *scrolled_win;
    GtkObject *adj;

    /* enable locale */
    gtk_set_locale ();

    gtk_init (&argc, &argv);

    ttip = create_yellow_tooltips();
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_name(window, "TiMidity");
    gtk_window_set_title(GTK_WINDOW(window), "TiMidity - MIDI Player");
    gtk_window_set_wmclass(GTK_WINDOW(window), "timidity", "TiMidity");

    gtk_signal_connect(GTK_OBJECT(window), "delete_event",
		       GTK_SIGNAL_FUNC (delete_event), NULL);

    gtk_signal_connect(GTK_OBJECT(window), "destroy",
		       GTK_SIGNAL_FUNC (destroy), NULL);

    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(window), vbox);

    mbar = create_menubar();
    gtk_box_pack_start(GTK_BOX(vbox), mbar, FALSE, FALSE, 0);

    scrolled_win = gtk_scrolled_window_new(NULL, NULL);
    gtk_box_pack_start(GTK_BOX(vbox), scrolled_win, TRUE, TRUE ,0);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
    gtk_widget_show(scrolled_win);

#ifdef HAVE_GTK_2
    text = gtk_text_view_new();
    gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
#else
    text = gtk_text_new(NULL, NULL);
#endif
    gtk_widget_show(text);
    gtk_container_add(GTK_CONTAINER(scrolled_win), text);

    hbox = gtk_hbox_new(FALSE, 4);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 4);
    gtk_widget_show(hbox);

    adj = gtk_adjustment_new(0., 0., 100., 1., 20., 0.);
    locator = gtk_hscale_new(GTK_ADJUSTMENT(adj));
    gtk_scale_set_draw_value(GTK_SCALE(locator), TRUE);
    gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
			GTK_SIGNAL_FUNC(generic_scale_cb),
			(gpointer)GTK_CHANGE_LOCATOR);
    gtk_signal_connect(GTK_OBJECT(locator), "button_press_event",
			GTK_SIGNAL_FUNC(locate_update_cb),
			NULL);
    gtk_signal_connect(GTK_OBJECT(locator), "button_release_event",
			GTK_SIGNAL_FUNC(locate_update_cb),
			NULL);
    gtk_range_set_update_policy(GTK_RANGE(locator),
				GTK_UPDATE_DISCONTINUOUS);
    gtk_scale_set_digits(GTK_SCALE(locator), 0);
    gtk_widget_show(locator);
    gtk_box_pack_start(GTK_BOX(hbox), locator, TRUE, TRUE, 4);

    align = gtk_alignment_new(0., 1., 1., 0.);
    gtk_widget_show(align);
    cnt_lbl = gtk_label_new("00:00");
    gtk_widget_show(cnt_lbl);
    gtk_container_add(GTK_CONTAINER(align), cnt_lbl);
    gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0);

    align = gtk_alignment_new(0., 1., 1., 0.);
    gtk_widget_show(align);
    tot_lbl = gtk_label_new("/00:00");
    gtk_widget_show(tot_lbl);
    gtk_container_add(GTK_CONTAINER(align), tot_lbl);
    gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0);

    hbox = gtk_hbox_new(FALSE, 4);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 4);

    swin = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
				   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    clist = gtk_clist_new(1);
    gtk_container_add(GTK_CONTAINER(swin), clist);
    gtk_widget_show(swin);
    gtk_widget_show(clist);
    gtk_widget_set_usize(clist, 200, 10);
    gtk_clist_set_reorderable(GTK_CLIST(clist), TRUE);
    gtk_clist_set_button_actions(GTK_CLIST(clist), 0, GTK_BUTTON_SELECTS);
    gtk_clist_set_button_actions(GTK_CLIST(clist), 1, GTK_BUTTON_DRAGS);
    gtk_clist_set_button_actions(GTK_CLIST(clist), 2, GTK_BUTTON_SELECTS);
    gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE);
    gtk_clist_set_column_auto_resize(GTK_CLIST(clist), 1, TRUE);
    gtk_signal_connect(GTK_OBJECT(clist), "select_row",
		       GTK_SIGNAL_FUNC(file_list_cb), NULL);

    gtk_box_pack_start(GTK_BOX(hbox), swin, TRUE, TRUE, 0);

    vbox2 = gtk_vbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 0);
    gtk_widget_show(vbox2);

    /* This is so the pixmap creation works properly. */
    gtk_widget_realize(window);
    set_icon_pixmap(window, timidity_xpm);

    gtk_box_pack_start(GTK_BOX(vbox2),
		       create_pixmap_label(window, loud_xpm),
		       FALSE, FALSE, 0);

    adj = gtk_adjustment_new(30., 0., (gfloat)MAX_AMPLIFICATION, 1., 20., 0.);
    vol_scale = gtk_vscale_new(GTK_ADJUSTMENT(adj));
    gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE);
    gtk_signal_connect (GTK_OBJECT(adj), "value_changed",
			GTK_SIGNAL_FUNC(generic_scale_cb),
			(gpointer)GTK_CHANGE_VOLUME);
    gtk_range_set_update_policy(GTK_RANGE(vol_scale),
				GTK_UPDATE_DELAYED);
    gtk_widget_show(vol_scale);
    gtk_tooltips_set_tip(ttip, vol_scale, "Volume control", NULL);

    gtk_box_pack_start(GTK_BOX(vbox2), vol_scale, TRUE, TRUE, 0);

    gtk_box_pack_start(GTK_BOX(vbox2),
		       create_pixmap_label(window, quiet_xpm),
		       FALSE, FALSE, 0);

    handlebox = gtk_handle_box_new();
    gtk_box_pack_start(GTK_BOX(hbox), handlebox, FALSE, FALSE, 0);

    table = gtk_table_new(7, 2, TRUE);
    gtk_container_add(GTK_CONTAINER(handlebox), table);

    button = create_button_with_pixmap(window, playpaus_xpm, GTK_PAUSE,
				       "Play/Pause");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      0, 2, 0, 1);

    button = create_button_with_pixmap(window, prevtrk_xpm, GTK_PREV,
				       "Previous file");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      0, 1, 1, 2);

    button = create_button_with_pixmap(window, nexttrk_xpm, GTK_NEXT,
				       "Next file");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      1, 2, 1, 2);

    button = create_button_with_pixmap(window, rew_xpm, GTK_RWD,
				       "Rewind");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      0, 1, 2, 3);

    button = create_button_with_pixmap(window, ff_xpm, GTK_FWD,
				       "Fast forward");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      1, 2, 2, 3);

    button = create_button_with_pixmap(window, keydown_xpm, GTK_KEYDOWN,
				       "Lower pitch");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      0, 1, 3, 4);

    button = create_button_with_pixmap(window, keyup_xpm, GTK_KEYUP,
				       "Raise pitch");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      1, 2, 3, 4);

    button = create_button_with_pixmap(window, slow_xpm, GTK_SLOWER,
				       "Decrease tempo");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      0, 1, 4, 5);

    button = create_button_with_pixmap(window, fast_xpm, GTK_FASTER,
				       "Increase tempo");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      1, 2, 4, 5);

    button = create_button_with_pixmap(window, restart_xpm, GTK_RESTART,
				       "Restart");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      0, 1, 5, 6);

    button = create_button_with_pixmap(window, open_xpm, 0,
				       "Open");
#ifdef HAVE_GTK_2
    gtk_signal_disconnect_by_func(GTK_OBJECT(button), G_CALLBACK(generic_cb), 0);
#else
    gtk_signal_disconnect_by_func(GTK_OBJECT(button), generic_cb, 0);
#endif
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
			      GTK_SIGNAL_FUNC(open_file_cb), 0);
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      1, 2, 5, 6);

    button = create_button_with_pixmap(window, quit_xpm, GTK_QUIT,
				       "Quit");
    gtk_table_attach_defaults(GTK_TABLE(table), button,
			      0, 2, 6, 7);

    gtk_widget_show(hbox);
    gtk_widget_show(vbox);
    gtk_widget_show(table);
    gtk_widget_show(handlebox);
    gtk_widget_show(window);

    gdk_input_add(pipe_number, GDK_INPUT_READ, handle_input, NULL);

    gtk_main();
}
Ejemplo n.º 2
0
static void create_config(GtkWidget *tab) {
  GtkWidget *tabs;
  GtkWidget *text, *label, *panel, *button, *hbox, *scrolled, *frame, *vbox;
  GtkObject *adj;
  gchar *plugin_about_text;
  gchar *station_tab_titles[3] = { _("Station"), _("Frequency"), "" };
  char *f[3];
  int i;

  tabs = gtk_notebook_new();
 
  gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs),GTK_POS_TOP);
  gtk_box_pack_start(GTK_BOX(tab),tabs,TRUE,TRUE,0); 

  /* STATION TAB */

  panel = gtk_vbox_new(0, 0);
  
  gui_station_list = gtk_clist_new_with_titles(3, station_tab_titles);
  gtk_clist_set_column_auto_resize(GTK_CLIST(gui_station_list),
				   0, TRUE);
  gtk_clist_set_column_auto_resize(GTK_CLIST(gui_station_list),
				   0, TRUE);
  gtk_clist_set_reorderable(GTK_CLIST(gui_station_list), TRUE);
  gtk_clist_set_column_justification(GTK_CLIST(gui_station_list),
				     1, GTK_JUSTIFY_RIGHT);

  /* fill data in clist */
  f[1] = malloc(32);
  f[2] = "";
  for (i = 0; i< nstations; i++) {
    f[0] = stations[i].station_name;
    snprintf(f[1],32, "%.2f", stations[i].freq);
    gtk_clist_append(GTK_CLIST(gui_station_list), f);
  }
  gui_station_count = nstations;
  free(f[1]);

  gtk_signal_connect(GTK_OBJECT(gui_station_list), "select-row",
		     (GtkSignalFunc)gui_select_row, NULL);

  scrolled = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
				 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_container_add(GTK_CONTAINER(scrolled),gui_station_list);

  gtk_container_add(GTK_CONTAINER(panel), scrolled);

  hbox = gtk_hbox_new(0, 0);

  button = gtk_button_new_with_label(_("New"));
  gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_new_station, NULL);

  gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2);
  button = gtk_button_new_with_label(_("Edit")); 
  gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_edit_station, NULL);

  gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2);
  button = gtk_button_new_with_label(_("Delete")); 
  gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_delete_station, NULL);

  gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2);
  button = gtk_button_new_with_label(_("Up"));
  gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_moveup_station, NULL);

  gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2);

  button = gtk_button_new_with_label(_("Down"));
  gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_movedown_station, NULL);
  gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2);
  
  label = gtk_label_new(_("Stations"));

  gtk_box_pack_start(GTK_BOX(panel), hbox, FALSE, FALSE, 4);


  
  gtk_notebook_append_page(GTK_NOTEBOOK(tabs), panel, label);

  /* OPTIONS TAB */

  vbox = gtk_vbox_new(0,0);

  /* mutetime */ {

    hbox = gtk_hbox_new(0, 0);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, 0, 0, 2);
    
    label = gtk_label_new(_("Time to mute on channel jump (seconds):"));
    gtk_box_pack_start(GTK_BOX(hbox), label, 0, 0, 2);
    
    adj = gtk_adjustment_new(mutetime, 0.0, 9.99, 0.01, 0.1, 1);
    gui_mutetime_entry = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 0.01, 2);
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(gui_mutetime_entry), mutetime);
    gtk_box_pack_start(GTK_BOX(hbox), gui_mutetime_entry, 0, 0, 2);

  }

  /* reopenoption */ {

    gui_reopen_toggle = gtk_check_button_new_with_label(_("Attempt to reopen radio on startup"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gui_reopen_toggle), attempt_reopen);
    gtk_box_pack_start(GTK_BOX(vbox), gui_reopen_toggle, 0, 0, 2);
  /* close radio on exit toggle */
    gui_close_toggle = 
      gtk_check_button_new_with_label(_("Turn radio off when exiting gkrellm"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gui_close_toggle), 
        close_atexit);
    gtk_box_pack_start(GTK_BOX(vbox), gui_close_toggle, 0, 0, 2);

  }
  
  label = gtk_label_new(_("Options"));
  gtk_notebook_append_page(GTK_NOTEBOOK(tabs), vbox, label);

  /* INFO TAB */
  
  frame = gtk_frame_new(NULL);
  scrolled = gkrellm_gtk_notebook_page(tabs,_("Info"));
  text = gkrellm_gtk_scrolled_text_view(scrolled,NULL,
                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

  for (i=0; i < sizeof(info_text)/sizeof(gchar *); ++i)
     gkrellm_gtk_text_view_append(text, _(info_text[i]));
  /* ABOUT TAB */

  plugin_about_text = g_strdup_printf(
   _("Radio Plugin %s\n" \
   "GKrellM radio Plugin\n\n" \
   "Copyright (C) 2001-2002 Sjoerd Simons\n" \
   "[email protected]\n" \
   "http://gkrellm.luon.net/gkrellm-radio.phtml\n\n" \
   "Released under the GNU General Public Licence"), VERSION);

  text = gtk_label_new(plugin_about_text); 
  label = gtk_label_new(_("About"));
  gtk_notebook_append_page(GTK_NOTEBOOK(tabs),text,label);
  g_free(plugin_about_text);
}
Ejemplo n.º 3
0
void player_filter_page (GtkWidget *notebook) {
  GtkWidget *page_hbox;
  GtkWidget *scrollwin;
  GtkWidget *label;
  GtkWidget *vbox;
  GtkWidget *vbox2;
  GtkWidget *alignment;
  GtkWidget *pixmap;
  GtkWidget *button;
  GtkWidget *peditor;
  char *titles[5] = { "", "", "", _("Mode"), _("Pattern") };
  int i;

  page_hbox = gtk_hbox_new (FALSE, 8);
  gtk_container_set_border_width (GTK_CONTAINER (page_hbox), 8);

  label = gtk_label_new (_("Player Filter"));
  gtk_widget_show (label);

  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page_hbox, label);

  /* Pattern CList */

  scrollwin = gtk_scrolled_window_new (NULL, NULL);
  gtk_box_pack_start (GTK_BOX (page_hbox), scrollwin, FALSE, FALSE, 0);

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), 
				  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

  pattern_clist = gtk_clist_new_with_titles (5, titles);
  gtk_widget_set_usize (pattern_clist, 260, 200);
  gtk_clist_set_selection_mode (GTK_CLIST (pattern_clist),
                                                        GTK_SELECTION_BROWSE);
  gtk_clist_set_reorderable (GTK_CLIST (pattern_clist), TRUE);

  gtk_signal_connect (GTK_OBJECT (pattern_clist), "event",
                        GTK_SIGNAL_FUNC (pattern_clist_event_callback), NULL);
  gtk_signal_connect (GTK_OBJECT (pattern_clist), "select_row",
                   GTK_SIGNAL_FUNC (pattern_clist_select_row_callback), NULL);
  gtk_signal_connect (GTK_OBJECT (pattern_clist), "row_move",
                     GTK_SIGNAL_FUNC (pattern_clist_row_move_callback), NULL);

  for (i = 0; i < 3; i++) {
    pixmap = aligned_pixmap (group_pix[i].pix, group_pix[i].mask);
    gtk_clist_set_column_width (GTK_CLIST (pattern_clist), i, 
                                             pixmap_width (group_pix[i].pix));
    gtk_clist_set_column_widget (GTK_CLIST (pattern_clist), i, pixmap);
    gtk_widget_show (pixmap);

    gtk_clist_set_column_resizeable (GTK_CLIST (pattern_clist), i, FALSE);
  }

  gtk_clist_set_column_width (GTK_CLIST (pattern_clist), 3, 45);

  gtk_container_add (GTK_CONTAINER (scrollwin), pattern_clist); 
  gtk_clist_column_titles_passive (GTK_CLIST (pattern_clist));

  gtk_widget_show (pattern_clist);

  gtk_widget_show (scrollwin);

  gtk_widget_ensure_style (pattern_clist);

/*FIXME_GTK2: style->font not working with gtk2*/
#ifndef USE_GTK2
  i = MAX (pixmap_height (group_pix[0].pix), 
	      pattern_clist->style->font->ascent + 
	      pattern_clist->style->font->descent + 1);

  gtk_clist_set_row_height (GTK_CLIST (pattern_clist), i);
#endif

  /* Buttons */

  vbox = gtk_vbox_new (FALSE, 4);
  gtk_box_pack_start (GTK_BOX (page_hbox), vbox, FALSE, FALSE, 0);

  button = gtk_button_new_with_label (_("New"));
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
                                GTK_SIGNAL_FUNC (new_pattern_callback), NULL);
  gtk_widget_show (button);

  delete_button = gtk_button_new_with_label (_("Delete"));
  gtk_box_pack_start (GTK_BOX (vbox), delete_button, FALSE, FALSE, 0);
  gtk_signal_connect (GTK_OBJECT (delete_button), "clicked",
                             GTK_SIGNAL_FUNC (delete_pattern_callback), NULL);
  gtk_widget_show (delete_button);

  alignment = gtk_alignment_new (0, 0.5, 1, 0);
  gtk_box_pack_end (GTK_BOX (vbox), alignment, TRUE, TRUE, 0);

  vbox2 = gtk_vbox_new (FALSE, 4);
  gtk_container_add (GTK_CONTAINER (alignment), vbox2);

  up_button = gtk_button_new_with_label (_("Up"));
  gtk_box_pack_start (GTK_BOX (vbox2), up_button, FALSE, FALSE, 0);
  gtk_signal_connect (GTK_OBJECT (up_button), "clicked",
                GTK_SIGNAL_FUNC (move_up_down_pattern_callback), (void *) -1);
  gtk_widget_show (up_button);

  down_button = gtk_button_new_with_label (_("Down"));
  gtk_box_pack_start (GTK_BOX (vbox2), down_button, FALSE, FALSE, 0);
  gtk_signal_connect (GTK_OBJECT (down_button), "clicked",
                 GTK_SIGNAL_FUNC (move_up_down_pattern_callback), (void *) 1);
  gtk_widget_show (down_button);

  gtk_widget_show (vbox2);
  gtk_widget_show (alignment);
  gtk_widget_show (vbox);

  /* Pattern Editor */

  peditor = player_filter_pattern_editor ();
  gtk_box_pack_end (GTK_BOX (page_hbox), peditor, TRUE, TRUE, 0);

  gtk_widget_show (page_hbox);

  player_filter_page_init ();
}
static void prefs_display_header_create(void)
{
    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *btn_hbox;
    GtkWidget *confirm_area;
    GtkWidget *ok_btn;
    GtkWidget *cancel_btn;

    GtkWidget *vbox1;

    GtkWidget *hbox1;
    GtkWidget *hdr_label;
    GtkWidget *hdr_combo;

    GtkWidget *btn_vbox;
    GtkWidget *reg_btn;
    GtkWidget *del_btn;
    GtkWidget *up_btn;
    GtkWidget *down_btn;

    GtkWidget *clist_hbox;
    GtkWidget *clist_hbox1;
    GtkWidget *clist_hbox2;
    GtkWidget *clist_scrolledwin;
    GtkWidget *headers_clist;
    GtkWidget *hidden_headers_clist;

    GtkWidget *checkbtn_other_headers;

    gchar *title[1];

    debug_print(_("Creating display header setting window...\n"));

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width (GTK_CONTAINER (window), 8);
    gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
    gtk_window_set_modal (GTK_WINDOW (window), TRUE);
    gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);

    vbox = gtk_vbox_new (FALSE, 6);
    gtk_widget_show (vbox);
    gtk_container_add (GTK_CONTAINER (window), vbox);

    btn_hbox = gtk_hbox_new (FALSE, 8);
    gtk_widget_show (btn_hbox);
    gtk_box_pack_end (GTK_BOX (vbox), btn_hbox, FALSE, FALSE, 0);

    gtkut_stock_button_set_create(&confirm_area, &ok_btn, GTK_STOCK_OK,
                                  &cancel_btn, GTK_STOCK_CANCEL,
                                  NULL, NULL);
    gtk_widget_show (confirm_area);
    gtk_box_pack_end (GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
    gtk_widget_grab_default (ok_btn);

    gtk_window_set_title (GTK_WINDOW(window),
                          _("Display header setting"));
    MANAGE_WINDOW_SIGNALS_CONNECT(window);
    g_signal_connect (G_OBJECT(window), "delete_event",
                      G_CALLBACK(prefs_display_header_deleted), NULL);
    g_signal_connect (G_OBJECT(window), "key_press_event",
                      G_CALLBACK(prefs_display_header_key_pressed), NULL);
    g_signal_connect (G_OBJECT(ok_btn), "clicked",
                      G_CALLBACK(prefs_display_header_ok), NULL);
    g_signal_connect (G_OBJECT(cancel_btn), "clicked",
                      G_CALLBACK(prefs_display_header_cancel), NULL);

    vbox1 = gtk_vbox_new (FALSE, VSPACING);
    gtk_widget_show (vbox1);
    gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
    gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);

    hbox1 = gtk_hbox_new (FALSE, 8);
    gtk_widget_show (hbox1);
    gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 0);

    hdr_label = gtk_label_new (_("Header name"));
    gtk_widget_show (hdr_label);
    gtk_box_pack_start (GTK_BOX (hbox1), hdr_label, FALSE, FALSE, 0);

    hdr_combo = gtk_combo_new ();
    gtk_widget_show (hdr_combo);
    gtk_box_pack_start (GTK_BOX (hbox1), hdr_combo, TRUE, TRUE, 0);
    gtk_widget_set_size_request (hdr_combo, 150, -1);
    gtkut_combo_set_items (GTK_COMBO (hdr_combo),
                           "From", "To", "Cc", "Subject", "Date",
                           "Reply-To", "Sender", "User-Agent", "X-Mailer",
                           NULL);

    clist_hbox = gtk_hbox_new (FALSE, 10);
    gtk_widget_show (clist_hbox);
    gtk_box_pack_start (GTK_BOX (vbox1), clist_hbox, TRUE, TRUE, 0);

    /* display headers list */

    clist_hbox1 = gtk_hbox_new (FALSE, 8);
    gtk_widget_show (clist_hbox1);
    gtk_box_pack_start (GTK_BOX (clist_hbox), clist_hbox1, TRUE, TRUE, 0);

    clist_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
    gtk_widget_set_size_request (clist_scrolledwin, 200, 210);
    gtk_widget_show (clist_scrolledwin);
    gtk_box_pack_start (GTK_BOX (clist_hbox1), clist_scrolledwin,
                        TRUE, TRUE, 0);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clist_scrolledwin),
                                    GTK_POLICY_AUTOMATIC,
                                    GTK_POLICY_AUTOMATIC);

    title[0] = _("Displayed Headers");
    headers_clist = gtk_clist_new_with_titles(1, title);
    gtk_widget_show (headers_clist);
    gtk_container_add (GTK_CONTAINER (clist_scrolledwin), headers_clist);
    gtk_clist_set_selection_mode (GTK_CLIST (headers_clist),
                                  GTK_SELECTION_BROWSE);
    gtk_clist_set_reorderable (GTK_CLIST (headers_clist), TRUE);
    gtk_clist_set_use_drag_icons (GTK_CLIST (headers_clist), FALSE);
    gtkut_clist_set_redraw (GTK_CLIST (headers_clist));
    GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (headers_clist)->column[0].button,
                            GTK_CAN_FOCUS);
    g_signal_connect_after
    (G_OBJECT (headers_clist), "row_move",
     G_CALLBACK (prefs_display_header_row_moved), NULL);

    btn_vbox = gtk_vbox_new (FALSE, 8);
    gtk_widget_show (btn_vbox);
    gtk_box_pack_start (GTK_BOX (clist_hbox1), btn_vbox, FALSE, FALSE, 0);

    reg_btn = gtk_button_new_with_label (_("Add"));
    gtk_widget_show (reg_btn);
    gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0);
    g_signal_connect (G_OBJECT (reg_btn), "clicked",
                      G_CALLBACK (prefs_display_header_register_cb),
                      GINT_TO_POINTER(FALSE));
    del_btn = gtk_button_new_with_label (_("Delete"));
    gtk_widget_show (del_btn);
    gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0);
    g_signal_connect (G_OBJECT (del_btn), "clicked",
                      G_CALLBACK (prefs_display_header_delete_cb),
                      headers_clist);

    up_btn = gtk_button_new_with_label (_("Up"));
    gtk_widget_show (up_btn);
    gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
    g_signal_connect (G_OBJECT (up_btn), "clicked",
                      G_CALLBACK (prefs_display_header_up), NULL);

    down_btn = gtk_button_new_with_label (_("Down"));
    gtk_widget_show (down_btn);
    gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
    g_signal_connect (G_OBJECT (down_btn), "clicked",
                      G_CALLBACK (prefs_display_header_down), NULL);

    /* hidden headers list */

    clist_hbox2 = gtk_hbox_new (FALSE, 8);
    gtk_widget_show (clist_hbox2);
    gtk_box_pack_start (GTK_BOX (clist_hbox), clist_hbox2, TRUE, TRUE, 0);

    clist_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
    gtk_widget_set_size_request (clist_scrolledwin, 200, 210);
    gtk_widget_show (clist_scrolledwin);
    gtk_box_pack_start (GTK_BOX (clist_hbox2), clist_scrolledwin,
                        TRUE, TRUE, 0);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clist_scrolledwin),
                                    GTK_POLICY_AUTOMATIC,
                                    GTK_POLICY_AUTOMATIC);

    title[0] = _("Hidden headers");
    hidden_headers_clist = gtk_clist_new_with_titles(1, title);
    gtk_widget_show (hidden_headers_clist);
    gtk_container_add (GTK_CONTAINER (clist_scrolledwin),
                       hidden_headers_clist);
    gtk_clist_set_selection_mode (GTK_CLIST (hidden_headers_clist),
                                  GTK_SELECTION_BROWSE);
    gtk_clist_set_auto_sort(GTK_CLIST (hidden_headers_clist), TRUE);
    gtkut_clist_set_redraw (GTK_CLIST (hidden_headers_clist));
    GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (hidden_headers_clist)->
                            column[0].button, GTK_CAN_FOCUS);

    btn_vbox = gtk_vbox_new (FALSE, 8);
    gtk_widget_show (btn_vbox);
    gtk_box_pack_start (GTK_BOX (clist_hbox2), btn_vbox, FALSE, FALSE, 0);

    reg_btn = gtk_button_new_with_label (_("Add"));
    gtk_widget_show (reg_btn);
    gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0);
    g_signal_connect (G_OBJECT (reg_btn), "clicked",
                      G_CALLBACK (prefs_display_header_register_cb),
                      GINT_TO_POINTER (TRUE));
    del_btn = gtk_button_new_with_label (_("Delete"));
    gtk_widget_show (del_btn);
    gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0);
    g_signal_connect (G_OBJECT (del_btn), "clicked",
                      G_CALLBACK (prefs_display_header_delete_cb),
                      hidden_headers_clist);

    PACK_CHECK_BUTTON (btn_hbox, checkbtn_other_headers,
                       _("Show all unspecified headers"));
    SET_TOGGLE_SENSITIVITY (checkbtn_other_headers, clist_hbox2);

    gtk_widget_show_all(window);

    dispheader.window        = window;

    dispheader.confirm_area  = confirm_area;
    dispheader.ok_btn        = ok_btn;
    dispheader.cancel_btn    = cancel_btn;

    dispheader.hdr_combo     = hdr_combo;
    dispheader.hdr_entry     = GTK_COMBO (hdr_combo)->entry;

    dispheader.headers_clist        = headers_clist;
    dispheader.hidden_headers_clist = hidden_headers_clist;

    dispheader.other_headers = checkbtn_other_headers;
}
Ejemplo n.º 5
0
 GtkWidget * yank_app_new(EYank *yank) 
{
    yank_preferences      *prefs;


    static GtkTargetEntry drop_types[] =
    {
        { "text/uri-list", 0, 1 },
    };
    static gint n_drop_types = sizeof (drop_types)/sizeof (drop_types [0]);
    gchar     *treetitle[] =
    {
        _("NoteTree"),
        NULL
    };
    gchar     *todotitles[] =
    {
        _("Deadline"),
        _("Priority"),
        _("Complete"),
        _("Title"),
        NULL
    };
     GtkWidget   *app; 
    GtkWidget   *scrolledwindow1;
    GtkWidget   *scrolledwindow2;
    GtkWidget   *scrolledwindow3;
    GtkWidget   *hbox;
    GtkWidget   *hbox3;
    GtkWidget   *vbox;
    GtkWidget   *label;
    GdkFont     *font;
    GtkObject   *prio_adjust;
/*     gint        got_crash; */
    GtkWidget   *b_toggle_ext_flags;
    GtkWidget   *hbox_ext_flags;
		GtkWidget		*hpaned;
    
		hpaned = app = yank->priv->hpaned; 
    yank_main_app(app);  


	 sp->edit_tree = NULL;

	 sp->title_entry =NULL;
	 sp->todo_check =NULL;
	 sp->prio_entry =NULL;
	 sp->de_deadline =NULL;
	 sp->ad_complete =NULL;
	 sp->tlabel_created =NULL;
	 sp->tlabel_changed =NULL;
	 sp->label_changes =NULL;
	 sp->tlabel_expire =NULL;
	 sp->note_id_entry =NULL;
	 sp->text_entry =NULL;
	 sp->note_tree =NULL;
	 sp->b_ok =NULL;
	 sp->b_apply =NULL;
	 sp->b_cancel =NULL;
	 sp->todolist =NULL; 
	 sp->notebook =NULL;
	 sp->status =NULL;  
	 sp->prio_date_box =NULL; 
	 sp->edit_tree=NULL;

   
    yank_root_win(GTK_WINDOW(app)); 
   


    /*
     * main tree
     */
    
    scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1),
                                   GTK_POLICY_AUTOMATIC,
                                   GTK_POLICY_AUTOMATIC);
    /* gtk_widget_show will be called later */
/*     gtk_container_add(GTK_CONTAINER(hpaned), scrolledwindow1); */
		e_paned_add1(E_PANED(hpaned), scrolledwindow1);

    sp->note_tree = gtk_ctree_new_with_titles(1, 0, treetitle);
    gtk_widget_show(sp->note_tree);
    gtk_container_add(GTK_CONTAINER(scrolledwindow1), sp->note_tree);
    gtk_clist_set_column_width(GTK_CLIST(sp->note_tree), 0, 80);
    gtk_clist_set_column_auto_resize(GTK_CLIST(sp->note_tree), 0, TRUE);
    gtk_clist_set_row_height(GTK_CLIST(sp->note_tree), 19);
    gtk_clist_set_selection_mode(GTK_CLIST(sp->note_tree), GTK_SELECTION_EXTENDED);
    gtk_clist_set_reorderable(GTK_CLIST(sp->note_tree), TRUE);
    gtk_clist_set_use_drag_icons(GTK_CLIST(sp->note_tree), TRUE);
    gtk_clist_column_titles_show(GTK_CLIST(sp->note_tree));
    gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_select_row",
                       GTK_SIGNAL_FUNC (note_tree_row_selected), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_unselect_row",
                       GTK_SIGNAL_FUNC (note_tree_row_unselected), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->note_tree), "click_column",
                       GTK_SIGNAL_FUNC (cb_note_tree_col_selected), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received",
		       GTK_SIGNAL_FUNC(cb_note_tree_reordered), NULL);
    /*
     * FIXME:
     * dnd on the note-tree disables reordering of notes by dnd
     */
/*     gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", */
/*                        GTK_SIGNAL_FUNC(cb_note_tree_drop), NULL); */
/*     gtk_drag_dest_set(sp->note_tree, GTK_DEST_DEFAULT_MOTION | */
/*                       GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, */
/*                       drop_types, n_drop_types, GDK_ACTION_COPY); */

    sp->notebook = gtk_notebook_new();
    gtk_notebook_set_show_tabs(GTK_NOTEBOOK(sp->notebook), FALSE);
    gtk_notebook_set_show_border(GTK_NOTEBOOK(sp->notebook), FALSE);
    gtk_widget_show(sp->notebook);
/*     gtk_container_add(GTK_CONTAINER(hpaned), sp->notebook); */
		e_paned_add2(E_PANED(hpaned), sp->notebook);

    /*
     * todo-list
     */
    
    scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
                                   GTK_POLICY_AUTOMATIC,
                                   GTK_POLICY_AUTOMATIC);
    gtk_widget_show(scrolledwindow2);
    gtk_container_add(GTK_CONTAINER(sp->notebook), scrolledwindow2);
    
    sp->todolist = gtk_clist_new_with_titles(4, todotitles);
    gtk_signal_connect(GTK_OBJECT(sp->todolist), "select_row",
                       GTK_SIGNAL_FUNC (cb_todo_row_selected), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->todolist), "click_column",
                       GTK_SIGNAL_FUNC (cb_todo_col_selected), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->todolist), "drag_data_received",
                       GTK_SIGNAL_FUNC(cb_todo_list_drop), NULL);
    gtk_drag_dest_set(sp->todolist, GTK_DEST_DEFAULT_MOTION |
                      GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
                      drop_types, n_drop_types, GDK_ACTION_COPY);    
    gtk_widget_show(sp->todolist);
    gtk_container_add(GTK_CONTAINER(scrolledwindow2), sp->todolist);
    gtk_clist_column_titles_show(GTK_CLIST(sp->todolist));
    gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 0 , TRUE);
    gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 3 , TRUE);
    gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 1,
                                       GTK_JUSTIFY_RIGHT);
    gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 2,
                                       GTK_JUSTIFY_RIGHT);
    

    /*
     * text/ data
     */
    
    vbox = gtk_vbox_new(FALSE, 3);
    gtk_widget_show(vbox);
    gtk_container_add(GTK_CONTAINER (sp->notebook), vbox);
    
    hbox = gtk_hbox_new(FALSE, 0);
    gtk_widget_show(hbox);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);

    sp->prio_date_box = gtk_vbox_new(FALSE, 3);
    gtk_widget_show(sp->prio_date_box);
    gtk_box_pack_start(GTK_BOX(vbox), sp->prio_date_box, FALSE, FALSE, 0);
    
    hbox_ext_flags = gui_ext_flags();
    gtk_box_pack_start(GTK_BOX(vbox), hbox_ext_flags, FALSE, FALSE, 3);

    label = gtk_label_new(_("Title:"));
    font = gtk_widget_get_style(label)->font;
    gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
    gtk_widget_show(label);
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);

    sp->title_entry = gtk_entry_new();
    gtk_widget_set_usize(sp->title_entry, -1, gdk_string_height(font, "W") + 10);
    gtk_widget_show(sp->title_entry);
    gtk_box_pack_start(GTK_BOX(hbox), sp->title_entry, TRUE, TRUE, 5);

    sp->todo_check = gtk_check_button_new_with_label(_("Done"));
    gtk_widget_set_usize(sp->todo_check, -1, gdk_string_height(font, "W") + 10);
    gtk_widget_show(sp->todo_check);
    gtk_box_pack_start(GTK_BOX(hbox), sp->todo_check, FALSE, FALSE, 5);

    /*
     * button for extra flags& data
     */
    
    b_toggle_ext_flags = gtk_button_new();
    {
        GtkWidget *p_up;
        GtkWidget *p_down;
        GtkWidget *box;
        
        box = gtk_hbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(b_toggle_ext_flags), box);
        gtk_widget_show(box);
        p_up = gnome_stock_pixmap_widget_at_size(
            GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_UP, 12, 14);
        p_down = gnome_stock_pixmap_widget_at_size(
            GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_DOWN, 12, 14);
        gtk_widget_hide(p_up);
        gtk_widget_show(p_down);
        gtk_container_add(GTK_CONTAINER(box), p_up);
        gtk_container_add(GTK_CONTAINER(box), p_down);
        gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "up", p_up);
        gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "down", p_down);
    }
    gtk_widget_show(b_toggle_ext_flags);
    gtk_box_pack_start(GTK_BOX(hbox), b_toggle_ext_flags, FALSE, FALSE, 5);
    gtk_signal_connect(GTK_OBJECT(b_toggle_ext_flags), "clicked",
                       GTK_SIGNAL_FUNC(cb_toggle_ext_flags), hbox_ext_flags);
    
    /*
     * deadline/ prio/ complete
     */
    
    {
        GtkWidget *prio_hbox1;
        GtkWidget *prio_hbox2;
        GtkWidget *sc_complete;
        
        prio_hbox1 = gtk_hbox_new(FALSE, 0);
        gtk_widget_show(prio_hbox1);
        gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox1, FALSE, FALSE,
                           0);
        prio_hbox2 = gtk_hbox_new(FALSE, 0);
        gtk_widget_show(prio_hbox2);
        gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox2, FALSE, FALSE,
                           0);
        
        label = gtk_label_new(_("Deadline:"));
        gtk_widget_show(label);
        gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
        sp->de_deadline = gnome_date_edit_new(0, 1, 1);
        gnome_date_edit_set_popup_range(GNOME_DATE_EDIT(sp->de_deadline), 0, 23);
        gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->date_entry,
                                 FALSE);
        gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->time_entry,
                                 FALSE);
        gtk_widget_show(sp->de_deadline);
        gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->de_deadline, FALSE, FALSE, 0);
        
        label = gtk_label_new(_("Priority:"));
        gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
        gtk_widget_show(label);
        gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
        
        prio_adjust = gtk_adjustment_new(0, 0, 9999, 1, 10, 10);
        sp->prio_entry = gtk_spin_button_new(GTK_ADJUSTMENT(prio_adjust), 1, 0);
        /* NOTE: this is note 100% ok */
        gtk_widget_set_usize(GTK_WIDGET(sp->prio_entry),
                             gdk_string_width(font, "999999") + 10,
                             gdk_string_height(font, "W") + 10);
        gtk_widget_show(sp->prio_entry);
        gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->prio_entry, FALSE, FALSE, 0);
        
        label = gtk_label_new(_("Complete:"));
        gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
        gtk_widget_show(label);
        gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
        
        sp->ad_complete = gtk_adjustment_new(0, 0, 101, 1, 1, 1);
        sc_complete = gtk_hscale_new(GTK_ADJUSTMENT(sp->ad_complete));
        gtk_scale_set_digits(GTK_SCALE(sc_complete), 0);
        gtk_scale_set_value_pos(GTK_SCALE(sc_complete), GTK_POS_LEFT);
        gtk_widget_show(sc_complete);
        gtk_box_pack_start(GTK_BOX(prio_hbox2), sc_complete, TRUE, TRUE, 5);

        label = gtk_label_new(_("%"));
        gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
        gtk_widget_show(label);
        gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
        
    }
    
    /*
     * additional note data
     */

    sp->note_id_entry = gtk_entry_new();
/*     gtk_widget_show(sp->note_id_entry); */
    gtk_widget_hide(sp->note_id_entry);
    gtk_box_pack_start(GTK_BOX(hbox), sp->note_id_entry, FALSE, FALSE, 5);

    /*
     * note text
     */
    
    scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3),
                                   GTK_POLICY_AUTOMATIC,
                                   GTK_POLICY_AUTOMATIC);
    gtk_widget_show(scrolledwindow3);
    gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow3, TRUE, TRUE, 0);
                       
    sp->text_entry = gtk_text_new(NULL, NULL);
    gtk_text_set_editable(GTK_TEXT(sp->text_entry), TRUE);
    gtk_widget_show(sp->text_entry);
    gtk_container_add(GTK_CONTAINER(scrolledwindow3), sp->text_entry);

    /* text dnd */
    gtk_signal_connect(GTK_OBJECT(sp->text_entry), "drag_data_received",
                       GTK_SIGNAL_FUNC(cb_text_entry_drop), NULL);
    gtk_drag_dest_set(sp->text_entry, GTK_DEST_DEFAULT_MOTION |
                      GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
                      drop_types, n_drop_types, GDK_ACTION_COPY);

    hbox3 = gtk_hbox_new(FALSE, 0);
    gtk_widget_show(hbox3);
    gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 3);

    sp->b_ok = gnome_stock_button(GNOME_STOCK_BUTTON_OK);
    gtk_widget_show(sp->b_ok);
    gtk_box_pack_start(GTK_BOX(hbox3), sp->b_ok, TRUE, FALSE, 5);
    gtk_signal_connect(GTK_OBJECT(sp->b_ok), "clicked",
                       GTK_SIGNAL_FUNC(cb_b_ok), NULL);

    sp->b_apply = gnome_stock_button(GNOME_STOCK_BUTTON_APPLY);
    gtk_widget_show(sp->b_apply);
    gtk_box_pack_start(GTK_BOX(hbox3), sp->b_apply, TRUE, FALSE, 5);
    gtk_signal_connect(GTK_OBJECT(sp->b_apply), "clicked",
                       GTK_SIGNAL_FUNC(cb_b_apply), NULL);
        
    sp->b_cancel = gnome_stock_button(GNOME_STOCK_BUTTON_CANCEL);
    gtk_widget_show(sp->b_cancel);
    gtk_box_pack_start(GTK_BOX(hbox3), sp->b_cancel, TRUE, FALSE, 5);
    gtk_signal_connect(GTK_OBJECT(sp->b_cancel), "clicked",
                       GTK_SIGNAL_FUNC(cb_b_cancel), NULL);

    /*
     * a bit suboptimal
     */
    
    gtk_signal_connect(GTK_OBJECT(sp->title_entry), "changed",
                       GTK_SIGNAL_FUNC(note_changed), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "date-changed",
                       GTK_SIGNAL_FUNC(note_changed), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "time-changed",
                       GTK_SIGNAL_FUNC(note_changed), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->tlabel_expire), "time_changed",
		       GTK_SIGNAL_FUNC(note_changed), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->prio_entry), "changed",
                       GTK_SIGNAL_FUNC(note_changed), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
                       GTK_SIGNAL_FUNC(note_changed), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
                       GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check);
    gtk_signal_connect(GTK_OBJECT(sp->todo_check), "toggled",
                       GTK_SIGNAL_FUNC(note_changed), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->text_entry), "changed",
                       GTK_SIGNAL_FUNC(note_changed), NULL);

    /*
     * keyboard-control
     */
    
    gtk_signal_connect(GTK_OBJECT(sp->title_entry), "activate",
                       GTK_SIGNAL_FUNC(cb_finished_note), NULL);
    gtk_signal_connect(GTK_OBJECT(sp->text_entry), "activate",
                       GTK_SIGNAL_FUNC(cb_finished_note), NULL);

    /*
     * create pixmaps
     */
    
    pix_text_xpm = gnome_pixmap_new_from_xpm_d(text_xpm);
    gtk_widget_show(pix_text_xpm);
    pix_box_xpm = gnome_pixmap_new_from_xpm_d(box_xpm);
    gtk_widget_show(pix_box_xpm);
    pix_box2_xpm = gnome_pixmap_new_from_xpm_d(box2_xpm);
    gtk_widget_show(pix_box2_xpm);
    pix_circle_xpm = gnome_pixmap_new_from_xpm_d(circle_xpm);
    gtk_widget_show(pix_circle_xpm);
    pix_circle2_xpm = gnome_pixmap_new_from_xpm_d(circle2_xpm);
    gtk_widget_show(pix_circle2_xpm);

    /*
     * menus
     */
    
/*     gnome_app_set_contents(GNOME_APP(app), hpaned); */
/*     sp->status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_USER); */
/*     gnome_app_set_statusbar(GNOME_APP(app), sp->status); */
/*     yank_install_menus_and_toolbar(app); */
    yank_tree_item_context_menu(sp->note_tree);
    yank_todo_item_context_menu(sp->todolist);
    yank_text_item_context_menu(sp->title_entry);
    yank_text_item_context_menu(sp->text_entry);
    
/*     gtk_signal_connect(GTK_OBJECT(app), "delete_event", */
/*                        GTK_SIGNAL_FUNC(cb_delete_event), NULL); */

    /*
     * initialize preferences
     * also preloads plugins
     */
    
    load_preferences();
    prefs = get_preferences();

    gtk_text_set_word_wrap(GTK_TEXT(sp->text_entry), prefs->wordwrap);
    gtk_text_set_line_wrap(GTK_TEXT(sp->text_entry), prefs->linewrap);
    
    
/*     if (prefs->yank_width * prefs->yank_height) */
/*     { */
/*         gtk_window_set_default_size(GTK_WINDOW(app), prefs->yank_width, */
/*                                     prefs->yank_height); */
/*     } */
/*     else */
/*     { */
/*         gtk_window_set_default_size(GTK_WINDOW(app), 600, 400); */
/*     } */
    
    if (prefs->use_custom_font)
    {
	if (prefs->note_font)
        {
	    set_note_font_str(prefs->note_font);
	}
	if (prefs->note_tree_font)
	{
	    set_note_tree_font_str(prefs->note_tree_font);
        }
        if (prefs->todolist_font)
        {
            set_todolist_font_str(prefs->todolist_font);
        }
    }
    else
    {
        set_default_font();
    }
    
    
    /*
     * parse geometry if given
     */
    
/*     if (geometry != NULL) */
/*     { */
/*         gint x, y, w, h; */
/*         if (gnome_parse_geometry(geometry, &x, &y, &w, &h )) */
/*         { */
/*             if (x != -1) */
/*             { */
/*                 gtk_widget_set_uposition(app, x, y); */
/*             } */
/*              */
/*             if (w != -1) */
/*             { */
/*                 gtk_window_set_default_size(GTK_WINDOW(app), w, h); */
/*             } */
/*         } */
/*         else */
/*         { */
/*             g_error(_("Could not parse geometry string `%s'"), geometry); */
/*         } */
/*     } */
/*      */
/*     if (prefs->note_tree_width) */
/*     { */
/*         gtk_widget_set_usize(scrolledwindow1, prefs->note_tree_width, -1); */
/*     } */
/*     else */
/*     { */
/*         gtk_widget_set_usize(scrolledwindow1, 200, -1); */
/*     } */
/*     gtk_widget_show(scrolledwindow1); */

    /*
     * try to read files from killed sessions
     */

/*     got_crash = get_crash_file(); */
    
    
    /*
     * load file from the command-line
     */
    
/*     if (file != NULL && ! got_crash) */
/*     { */
/*         load_notes_from_cli((gchar *)file, GTK_CTREE(sp->note_tree), NULL); */
/*     } */

    /*
     * read default file
     */
    
/*     if (file == NULL && ! got_crash) */
/*     { */
/*         get_def_file(); */
/*     } */
    
    /*
     * register some signal-handlers
     */

/*     if (signal(SIGTERM, handle_sigterm) == SIG_ERR) */
/*     { */
/*         g_warning("Can't handle SIGTERM"); */
/*     } */
/*     if (signal(SIGCHLD, handle_sigchild) == SIG_ERR) */
/*     { */
/*         g_warning("Can't handle SIGCHILD"); */
/*     } */
/*     if (signal(SIGPIPE, handle_sigpipe) == SIG_ERR) */
/*     { */
/*         g_warning("Can't handle SIGPIPE"); */
/*     } */

    /*
     * init autosave
     */
    
/*     if (prefs->auto_save_minutes) */
/*     { */
/*         autosave_notes(NULL); */
/*     } */
    
    return (hpaned);
}
Ejemplo n.º 6
0
static void prefs_summary_column_create(void)
{
	GtkWidget *window;
	GtkWidget *vbox;

	GtkWidget *label_hbox;
	GtkWidget *label;

	GtkWidget *vbox1;

	GtkWidget *hbox1;
	GtkWidget *clist_hbox;
	GtkWidget *scrolledwin;
	GtkWidget *stock_clist;
	GtkWidget *shown_clist;

	GtkWidget *btn_vbox;
	GtkWidget *btn_vbox1;
	GtkWidget *add_btn;
	GtkWidget *remove_btn;
	GtkWidget *up_btn;
	GtkWidget *down_btn;

	GtkWidget *btn_hbox;
	GtkWidget *default_btn;
	GtkWidget *confirm_area;
	GtkWidget *ok_btn;
	GtkWidget *cancel_btn;

	gchar *title[1];

	debug_print("Creating summary column setting window...\n");

	window = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_container_set_border_width(GTK_CONTAINER(window), 8);
	gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_modal(GTK_WINDOW(window), TRUE);
	gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
	gtk_window_set_title(GTK_WINDOW(window),
			     _("Displayed items configuration"));
	gtk_signal_connect(GTK_OBJECT(window), "delete_event",
			   GTK_SIGNAL_FUNC(prefs_summary_column_delete_event),
			   NULL);
	gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
			   GTK_SIGNAL_FUNC(prefs_summary_column_key_pressed),
			   NULL);

	vbox = gtk_vbox_new(FALSE, 6);
	gtk_widget_show(vbox);
	gtk_container_add(GTK_CONTAINER(window), vbox);

	label_hbox = gtk_hbox_new(FALSE, 0);
	gtk_widget_show(label_hbox);
	gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4);

	label = gtk_label_new
		(_("Select items to be displayed in the summary view. You can modify\n"
		   "the order by using the Up / Down buttons or by dragging the items."));
	gtk_widget_show(label);
	gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4);
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);

	vbox1 = gtk_vbox_new(FALSE, VSPACING);
	gtk_widget_show(vbox1);
	gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2);

	hbox1 = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(hbox1);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);

	clist_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(clist_hbox);
	gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);

	scrolledwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_set_usize(scrolledwin, 180, 210);
	gtk_widget_show(scrolledwin);
	gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	title[0] = _("Available items");
	stock_clist = gtk_clist_new_with_titles(1, title);
	gtk_widget_show(stock_clist);
	gtk_container_add(GTK_CONTAINER(scrolledwin), stock_clist);
	gtk_clist_set_selection_mode(GTK_CLIST(stock_clist),
				     GTK_SELECTION_BROWSE);
	GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(stock_clist)->column[0].button,
			       GTK_CAN_FOCUS);

	/* add/remove button */
	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);

	btn_vbox1 = gtk_vbox_new(FALSE, 8);
	gtk_widget_show(btn_vbox1);
	gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);

	add_btn = gtk_button_new_with_label(_("  ->  "));
	gtk_widget_show(add_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), add_btn, FALSE, FALSE, 0);

	remove_btn = gtk_button_new_with_label(_("  <-  "));
	gtk_widget_show(remove_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), remove_btn, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(add_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_add), NULL);
	gtk_signal_connect(GTK_OBJECT(remove_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_remove), NULL);

	clist_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(clist_hbox);
	gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);

	scrolledwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_set_usize(scrolledwin, 180, 210);
	gtk_widget_show(scrolledwin);
	gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	title[0] = _("Displayed items");
	shown_clist = gtk_clist_new_with_titles(1, title);
	gtk_widget_show(shown_clist);
	gtk_container_add(GTK_CONTAINER(scrolledwin), shown_clist);
	gtk_clist_set_selection_mode(GTK_CLIST(shown_clist),
				     GTK_SELECTION_BROWSE);
	gtk_clist_set_reorderable(GTK_CLIST(shown_clist), TRUE);
	gtk_clist_set_use_drag_icons(GTK_CLIST(shown_clist), FALSE);
	GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(shown_clist)->column[0].button,
			       GTK_CAN_FOCUS);

	/* up/down button */
	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);

	btn_vbox1 = gtk_vbox_new(FALSE, 8);
	gtk_widget_show(btn_vbox1);
	gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);

	up_btn = gtk_button_new_with_label(_("Up"));
	gtk_widget_show(up_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), up_btn, FALSE, FALSE, 0);

	down_btn = gtk_button_new_with_label(_("Down"));
	gtk_widget_show(down_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), down_btn, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(up_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_up), NULL);
	gtk_signal_connect(GTK_OBJECT(down_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_down), NULL);

	btn_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(btn_hbox);
	gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0);

	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0);

	default_btn = gtk_button_new_with_label(_(" Use default "));
	gtk_widget_show(default_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0);
	gtk_signal_connect(GTK_OBJECT(default_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_set_to_default),
			   NULL);

	gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
				&cancel_btn, _("Cancel"), NULL, NULL);
	gtk_widget_show(confirm_area);
	gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
	gtk_widget_grab_default(ok_btn);

	gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_ok), NULL);
	gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked",
			   GTK_SIGNAL_FUNC(prefs_summary_column_cancel), NULL);

	summary_col.window      = window;
	summary_col.stock_clist = stock_clist;
	summary_col.shown_clist = shown_clist;
	summary_col.add_btn     = add_btn;
	summary_col.remove_btn  = remove_btn;
	summary_col.up_btn      = up_btn;
	summary_col.down_btn    = down_btn;
	summary_col.ok_btn      = ok_btn;
	summary_col.cancel_btn  = cancel_btn;
}
Ejemplo n.º 7
0
PrefsDisplayItemsDialog *prefs_display_items_dialog_create(void)
{
	PrefsDisplayItemsDialog *dialog;

	GtkWidget *window;
	GtkWidget *vbox;

	GtkWidget *label_hbox;
	GtkWidget *label;

	GtkWidget *vbox1;

	GtkWidget *hbox1;
	GtkWidget *clist_hbox;
	GtkWidget *scrolledwin;
	GtkWidget *stock_clist;
	GtkWidget *shown_clist;

	GtkWidget *btn_vbox;
	GtkWidget *btn_vbox1;
	GtkWidget *add_btn;
	GtkWidget *remove_btn;
	GtkWidget *up_btn;
	GtkWidget *down_btn;

	GtkWidget *btn_hbox;
	GtkWidget *default_btn;
	GtkWidget *confirm_area;
	GtkWidget *ok_btn;
	GtkWidget *cancel_btn;

	gchar *title[1];

	dialog = g_new0(PrefsDisplayItemsDialog, 1);

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_container_set_border_width(GTK_CONTAINER(window), 8);
	gtk_window_set_position(GTK_WINDOW(window),
				GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_modal(GTK_WINDOW(window), TRUE);
	gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
	gtk_window_set_title(GTK_WINDOW(window), _("Display items setting"));
	g_signal_connect(G_OBJECT(window), "delete_event",
			 G_CALLBACK(prefs_display_items_delete_event), dialog);
	g_signal_connect(G_OBJECT(window), "key_press_event",
			 G_CALLBACK(prefs_display_items_key_pressed), dialog);

	vbox = gtk_vbox_new(FALSE, 6);
	gtk_widget_show(vbox);
	gtk_container_add(GTK_CONTAINER(window), vbox);

	label_hbox = gtk_hbox_new(FALSE, 0);
	gtk_widget_show(label_hbox);
	gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4);

	label = gtk_label_new("");
	gtk_widget_show(label);
	gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4);
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);

	vbox1 = gtk_vbox_new(FALSE, VSPACING);
	gtk_widget_show(vbox1);
	gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2);

	hbox1 = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(hbox1);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);

	clist_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(clist_hbox);
	gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);

	scrolledwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_set_size_request
		(scrolledwin,
		 SCROLLED_WINDOW_WIDTH * gtkut_get_dpi_multiplier(),
		 SCROLLED_WINDOW_HEIGHT * gtkut_get_dpi_multiplier());
	gtk_widget_show(scrolledwin);
	gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	title[0] = _("Available items");
	stock_clist = gtk_clist_new_with_titles(1, title);
	gtk_widget_show(stock_clist);
	gtk_container_add(GTK_CONTAINER(scrolledwin), stock_clist);
	gtk_clist_set_selection_mode(GTK_CLIST(stock_clist),
				     GTK_SELECTION_BROWSE);
	GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(stock_clist)->column[0].button,
			       GTK_CAN_FOCUS);
	gtkut_clist_set_redraw(GTK_CLIST(stock_clist));

	/* add/remove button */
	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);

	btn_vbox1 = gtk_vbox_new(FALSE, 8);
	gtk_widget_show(btn_vbox1);
	gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);

	add_btn = gtk_button_new_with_label(_("  ->  "));
	gtk_widget_show(add_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), add_btn, FALSE, FALSE, 0);

	remove_btn = gtk_button_new_with_label(_("  <-  "));
	gtk_widget_show(remove_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), remove_btn, FALSE, FALSE, 0);

	g_signal_connect(G_OBJECT(add_btn), "clicked",
			 G_CALLBACK(prefs_display_items_add), dialog);
	g_signal_connect(G_OBJECT(remove_btn), "clicked",
			 G_CALLBACK(prefs_display_items_remove), dialog);

	clist_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(clist_hbox);
	gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);

	scrolledwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_set_size_request
		(scrolledwin,
		 SCROLLED_WINDOW_WIDTH * gtkut_get_dpi_multiplier(),
		 SCROLLED_WINDOW_HEIGHT * gtkut_get_dpi_multiplier());
	gtk_widget_show(scrolledwin);
	gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	title[0] = _("Displayed items");
	shown_clist = gtk_clist_new_with_titles(1, title);
	gtk_widget_show(shown_clist);
	gtk_container_add(GTK_CONTAINER(scrolledwin), shown_clist);
	gtk_clist_set_selection_mode(GTK_CLIST(shown_clist),
				     GTK_SELECTION_BROWSE);
#if 0
	gtk_clist_set_reorderable(GTK_CLIST(shown_clist), TRUE);
	gtk_clist_set_use_drag_icons(GTK_CLIST(shown_clist), FALSE);
#endif
	GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(shown_clist)->column[0].button,
			       GTK_CAN_FOCUS);
	gtkut_clist_set_redraw(GTK_CLIST(shown_clist));

	g_signal_connect(G_OBJECT(shown_clist), "select-row",
			 G_CALLBACK(prefs_display_items_shown_select_row),
			 dialog);
	g_signal_connect_after(G_OBJECT(shown_clist), "row-move",
			       G_CALLBACK(prefs_display_items_shown_row_move),
			       dialog);

	/* up/down button */
	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);

	btn_vbox1 = gtk_vbox_new(FALSE, 8);
	gtk_widget_show(btn_vbox1);
	gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);

	up_btn = gtk_button_new_with_label(_("Up"));
	gtk_widget_show(up_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), up_btn, FALSE, FALSE, 0);

	down_btn = gtk_button_new_with_label(_("Down"));
	gtk_widget_show(down_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox1), down_btn, FALSE, FALSE, 0);

	g_signal_connect(G_OBJECT(up_btn), "clicked",
			 G_CALLBACK(prefs_display_items_up), dialog);
	g_signal_connect(G_OBJECT(down_btn), "clicked",
			 G_CALLBACK(prefs_display_items_down), dialog);

	btn_hbox = gtk_hbox_new(FALSE, 8);
	gtk_widget_show(btn_hbox);
	gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0);

	btn_vbox = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(btn_vbox);
	gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0);

	default_btn = gtk_button_new_with_label(_(" Revert to default "));
	gtk_widget_show(default_btn);
	gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0);

	g_signal_connect(G_OBJECT(default_btn), "clicked",
			 G_CALLBACK(prefs_display_items_default), dialog);

	gtkut_stock_button_set_create(&confirm_area, &ok_btn, GTK_STOCK_OK,
				      &cancel_btn, GTK_STOCK_CANCEL,
				      NULL, NULL);
	gtk_widget_show(confirm_area);
	gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
	gtk_widget_grab_default(ok_btn);

	g_signal_connect(G_OBJECT(ok_btn), "clicked",
			 G_CALLBACK(prefs_display_items_ok), dialog);
	g_signal_connect(G_OBJECT(cancel_btn), "clicked",
			 G_CALLBACK(prefs_display_items_cancel), dialog);

	dialog->window       = window;
	dialog->label        = label;
	dialog->stock_clist  = stock_clist;
	dialog->shown_clist  = shown_clist;
	dialog->add_btn      = add_btn;
	dialog->remove_btn   = remove_btn;
	dialog->up_btn       = up_btn;
	dialog->down_btn     = down_btn;
	dialog->confirm_area = confirm_area;
	dialog->ok_btn       = ok_btn;
	dialog->cancel_btn   = cancel_btn;

	gtkut_box_set_reverse_order(GTK_BOX(dialog->confirm_area),
				    !prefs_common.comply_gnome_hig);
	manage_window_set_transient(GTK_WINDOW(dialog->window));
	gtk_widget_grab_focus(dialog->ok_btn);

	dialog->finished = FALSE;
	dialog->cancelled = FALSE;

	return dialog;
}