Exemple #1
0
void get_folder_to_play(GtkWidget *widget, gpointer user_data) {

  /** User folder selection. **/

  #ifdef DEBUG
  DEBUG_FUNC_MARK
  #endif

  GtkWidget *folder_chooser_dialog = gtk_file_chooser_dialog_new("Choose a folder contains music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);

  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog),  current_folder.c_str() ) ;
  gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
  gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
  gtk_file_chooser_set_use_preview_label(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;
  gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;

  gtk_window_set_position(GTK_WINDOW(folder_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
  gtk_widget_set_size_request(folder_chooser_dialog,-1,-1) ;
  gtk_window_set_modal(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
  gtk_window_set_destroy_with_parent(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
  gtk_window_set_type_hint(GTK_WINDOW(folder_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ;
  gtk_window_set_transient_for(GTK_WINDOW(folder_chooser_dialog), GTK_WINDOW(gui->window)) ;


  gchar *folderpath = NULL ;  // Selected folder.

  gint result = gtk_dialog_run (GTK_DIALOG (folder_chooser_dialog));

  switch (result) {
 
      case GTK_RESPONSE_CANCEL :


       if (! is_playing) {
         gtk_button_set_label(GTK_BUTTON(gui->folder_chooser_button), "Select a folder to play content") ;
       }
  
       gtk_widget_destroy(folder_chooser_dialog);
  
       return ;

      case GTK_RESPONSE_ACCEPT :

        folderpath = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog));
   
        gtk_widget_destroy(folder_chooser_dialog);

        break ;
  }

  parse_folder(folderpath) ;

  gchar *dirname = g_path_get_dirname(folderpath) ;

  current_folder = dirname  ;

  g_free(dirname) ;

  #ifdef DEBUG
  fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ;
  #endif

  g_free(folderpath) ;

}
Exemple #2
0
void create_kbm_window()
{
  if (hime_kbm_window) {
    gtk_window_present(GTK_WINDOW(hime_kbm_window));
    return;
  }

  load_setttings();

  hime_kbm_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_position(GTK_WINDOW(hime_kbm_window), GTK_WIN_POS_MOUSE);
  gtk_window_set_has_resize_grip(GTK_WINDOW(hime_kbm_window), FALSE);

  g_signal_connect (G_OBJECT (hime_kbm_window), "delete_event",
                    G_CALLBACK (close_kbm_window),
                    NULL);

  gtk_window_set_title (GTK_WINDOW (hime_kbm_window), _(_L("HIME 注音/詞音設定")));
  gtk_container_set_border_width (GTK_CONTAINER (hime_kbm_window), 1);

  GtkWidget *vbox_top = gtk_vbox_new (FALSE, 3);
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
  gtk_container_add (GTK_CONTAINER (hime_kbm_window), vbox_top);


  GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 3);
  gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, TRUE, TRUE, 0);


  GtkWidget *vbox_l = gtk_vbox_new (FALSE, 3);
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_l), GTK_ORIENTATION_VERTICAL);
  gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_l, TRUE, TRUE, 10);

  GtkWidget *vbox_r = gtk_vbox_new (FALSE, 3);
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_r), GTK_ORIENTATION_VERTICAL);
  gtk_grid_set_row_homogeneous(GTK_GRID(vbox_r), TRUE);
  gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_r, TRUE, TRUE, 10);


  GtkWidget *frame_kbm = gtk_frame_new(_(_L("鍵盤排列方式/選擇鍵/選單每列字數")));
  gtk_box_pack_start (GTK_BOX (vbox_l), frame_kbm, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (frame_kbm), 1);
  gtk_container_add (GTK_CONTAINER (frame_kbm), create_kbm_opts());

  gtk_box_pack_start (GTK_BOX (vbox_l), create_en_pho_key_sel(_(_L("(詞音) 切換[中/英]輸入"))), TRUE, TRUE, 0);

  GtkWidget *frame_tsin_space_opt = gtk_frame_new(_(_L("(詞音) 鍵入空白鍵")));
  gtk_box_pack_start (GTK_BOX (vbox_l), frame_tsin_space_opt, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_space_opt), 1);

  GtkWidget *box_tsin_space_opt = gtk_vbox_new (FALSE, 0);
  gtk_orientable_set_orientation(GTK_ORIENTABLE(box_tsin_space_opt), GTK_ORIENTATION_VERTICAL);
  gtk_container_add (GTK_CONTAINER (frame_tsin_space_opt), box_tsin_space_opt);
  gtk_container_set_border_width (GTK_CONTAINER (box_tsin_space_opt), 1);

  GSList *group_tsin_space_opt = NULL;
  int current_idx = get_currnet_tsin_space_option_idx();
  new_select_idx_tsin_space_opt = current_idx;

  gsize i;
  for(i=0; i< tsin_space_optionsN; i++) {
    GtkWidget *button = gtk_radio_button_new_with_label (group_tsin_space_opt, _(tsin_space_options[i].name));
    gtk_box_pack_start (GTK_BOX (box_tsin_space_opt), button, TRUE, TRUE, 0);

    group_tsin_space_opt = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));

    g_signal_connect (G_OBJECT (button), "clicked",
       G_CALLBACK (callback_button_clicked_tsin_space_opt), (gpointer) i);

    if (i==current_idx)
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
  }

  GtkWidget *hbox_tsin_phrase_pre_select = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_l), hbox_tsin_phrase_pre_select , TRUE, TRUE, 1);
  check_button_tsin_phrase_pre_select = gtk_check_button_new_with_label(_(_L("詞音輸入預選詞視窗")));
  gtk_box_pack_start (GTK_BOX (hbox_tsin_phrase_pre_select), check_button_tsin_phrase_pre_select, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_tsin_phrase_pre_select), tsin_phrase_pre_select);


  GtkWidget *hbox_phonetic_char_dynamic_sequence = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_l), hbox_phonetic_char_dynamic_sequence , TRUE, TRUE, 1);
  check_button_phonetic_char_dynamic_sequence = gtk_check_button_new_with_label(_(_L("依使用頻率調整字的順序")));
  gtk_box_pack_start (GTK_BOX (hbox_phonetic_char_dynamic_sequence), check_button_phonetic_char_dynamic_sequence, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_phonetic_char_dynamic_sequence), phonetic_char_dynamic_sequence);


  GtkWidget *hbox_pho_hide_row2 = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_l), hbox_pho_hide_row2 , TRUE, TRUE, 1);
  check_button_pho_hide_row2 = gtk_check_button_new_with_label(_(_L("注音隱藏第二列 (注音符號)")));
  gtk_box_pack_start (GTK_BOX (hbox_pho_hide_row2), check_button_pho_hide_row2, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_pho_hide_row2), pho_hide_row2);


  GtkWidget *hbox_pho_in_row1 = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_l), hbox_pho_in_row1 , TRUE, TRUE, 1);
  check_button_pho_in_row1 = gtk_check_button_new_with_label(_(_L("注音符號移至第一列")));
  gtk_box_pack_start (GTK_BOX (hbox_pho_in_row1), check_button_pho_in_row1, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_pho_in_row1), pho_in_row1);


  GtkWidget *hbox_phonetic_huge_tab = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_r), hbox_phonetic_huge_tab , TRUE, TRUE, 1);
  check_button_phonetic_huge_tab = gtk_check_button_new_with_label(_(_L("使用巨大 UTF-8 字集")));
  gtk_box_pack_start (GTK_BOX (hbox_phonetic_huge_tab), check_button_phonetic_huge_tab, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_phonetic_huge_tab), phonetic_huge_tab);


  GtkWidget *hbox_tsin_tone_char_input = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tone_char_input , TRUE, TRUE, 1);
  check_button_tsin_tone_char_input = gtk_check_button_new_with_label(_(_L("(詞音) 輸入注音聲調符號")));
  gtk_box_pack_start (GTK_BOX (hbox_tsin_tone_char_input), check_button_tsin_tone_char_input, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_tsin_tone_char_input), tsin_tone_char_input);


  GtkWidget *hbox_tsin_tab_phrase_end = gtk_hbox_new(FALSE, 1);
  gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tab_phrase_end , TRUE, TRUE, 1);
  check_button_tsin_tab_phrase_end = gtk_check_button_new_with_label(_(_L("(詞音) 使用 Escape/Tab 斷詞")));
  gtk_box_pack_start (GTK_BOX (hbox_tsin_tab_phrase_end), check_button_tsin_tab_phrase_end, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_tsin_tab_phrase_end), tsin_tab_phrase_end);

  GtkWidget *hbox_tsin_tail_select_key = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tail_select_key , TRUE, TRUE, 1);
  check_button_tsin_tail_select_key = gtk_check_button_new_with_label(_(_L("選擇鍵顯示於候選字(詞)後方")));
  gtk_box_pack_start (GTK_BOX (hbox_tsin_tail_select_key), check_button_tsin_tail_select_key, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_tsin_tail_select_key), tsin_tail_select_key);

  GtkWidget *hbox_tsin_buffer_editing_mode = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_buffer_editing_mode , TRUE, TRUE, 1);
  check_button_tsin_buffer_editing_mode = gtk_check_button_new_with_label(_(_L("\\ 鍵可切換 jkx 鍵編輯模式")));
  gtk_box_pack_start (GTK_BOX (hbox_tsin_buffer_editing_mode), check_button_tsin_buffer_editing_mode, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_tsin_buffer_editing_mode), tsin_buffer_editing_mode);

  GtkWidget *hbox_tsin_use_pho_near = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_use_pho_near , TRUE, TRUE, 1);
  check_button_tsin_use_pho_near = gtk_check_button_new_with_label(_(_L("按下 ↑ 鍵查詢近似音")));
  gtk_box_pack_start (GTK_BOX (hbox_tsin_use_pho_near), check_button_tsin_use_pho_near, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(
     GTK_TOGGLE_BUTTON(check_button_tsin_use_pho_near), tsin_use_pho_near);

  GtkWidget *frame_tsin_buffer_size = gtk_frame_new(_(_L("(詞音) 的編輯緩衝區大小")));
  gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_buffer_size, FALSE, FALSE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_buffer_size), 1);
  GtkAdjustment *adj_gtab_in =
   (GtkAdjustment *) gtk_adjustment_new (tsin_buffer_size, 10.0, MAX_PH_BF, 1.0, 1.0, 0.0);
  spinner_tsin_buffer_size = gtk_spin_button_new (adj_gtab_in, 0, 0);
  gtk_container_add (GTK_CONTAINER (frame_tsin_buffer_size), spinner_tsin_buffer_size);

  GtkWidget *frame_tsin_cursor_color = gtk_frame_new(_(_L("詞音游標的顏色")));
  gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_cursor_color, FALSE, FALSE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_cursor_color), 1);
  GtkWidget *button_tsin_cursor_color = gtk_button_new();
  g_signal_connect (G_OBJECT (button_tsin_cursor_color), "clicked",
                    G_CALLBACK (cb_tsin_cursor_color), G_OBJECT (hime_kbm_window));
  da_cursor =  gtk_drawing_area_new();
  gtk_container_add (GTK_CONTAINER (button_tsin_cursor_color), da_cursor);
  gdk_color_parse(tsin_cursor_color, &tsin_cursor_gcolor);
#if !GTK_CHECK_VERSION(2,91,6)
  gtk_widget_modify_bg(da_cursor, GTK_STATE_NORMAL, &tsin_cursor_gcolor);
#else
  GdkRGBA rgbbg;
  gdk_rgba_parse(&rgbbg, gdk_color_to_string(&tsin_cursor_gcolor));
  gtk_widget_override_background_color(da_cursor, GTK_STATE_FLAG_NORMAL, &rgbbg);
#endif
  gtk_widget_set_size_request(da_cursor, 16, 2);
  gtk_container_add (GTK_CONTAINER (frame_tsin_cursor_color), button_tsin_cursor_color);

  GtkWidget *hbox_cancel_ok = gtk_hbox_new (FALSE, 10);
  gtk_grid_set_column_homogeneous(GTK_GRID(hbox_cancel_ok), TRUE);
  gtk_box_pack_start (GTK_BOX (vbox_top), hbox_cancel_ok , FALSE, FALSE, 5);
  GtkWidget *button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
  if (button_order)
    gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
  else
    gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
  GtkWidget *button_ok = gtk_button_new_from_stock (GTK_STOCK_OK);
#if !GTK_CHECK_VERSION(2,91,2)
  if (button_order)
    gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
  else
    gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
#else
  if (button_order)
    gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_LEFT, 1, 1);
  else
    gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_RIGHT, 1, 1);
#endif

  g_signal_connect (G_OBJECT (button_cancel), "clicked",
                            G_CALLBACK (close_kbm_window),
                            G_OBJECT (hime_kbm_window));

  g_signal_connect_swapped (G_OBJECT (button_ok), "clicked",
                            G_CALLBACK (cb_ok),
                            G_OBJECT (hime_kbm_window));

  GTK_WIDGET_SET_FLAGS (button_cancel, GTK_CAN_DEFAULT);
  gtk_widget_grab_default (button_cancel);

  gtk_widget_show_all (hime_kbm_window);

  return;
}
Exemple #3
0
static void
joind_show_dialog (server *serv)
{
	GtkWidget *dialog1;
	GtkWidget *dialog_vbox1;
	GtkWidget *vbox1;
	GtkWidget *hbox1;
	GtkWidget *image1;
	GtkWidget *vbox2;
	GtkWidget *label;
	GtkWidget *radiobutton1;
	GtkWidget *radiobutton2;
	GtkWidget *radiobutton3;
	GSList *radiobutton1_group;
	GtkWidget *hbox2;
	GtkWidget *entry1;
	GtkWidget *checkbutton1;
	GtkWidget *dialog_action_area1;
	GtkWidget *okbutton1;
	char buf[256];
	char buf2[256];

	serv->gui->joind_win = dialog1 = gtk_dialog_new ();
	gtk_window_set_title (GTK_WINDOW (dialog1), _("XChat: Connection Complete"));
	gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
	gtk_window_set_position (GTK_WINDOW (dialog1), GTK_WIN_POS_MOUSE);

	dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
	gtk_widget_show (dialog_vbox1);

	vbox1 = gtk_vbox_new (FALSE, 0);
	gtk_widget_show (vbox1);
	gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);

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

	image1 = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_DIALOG);
	gtk_widget_show (image1);
	gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, TRUE, 24);
	gtk_misc_set_alignment (GTK_MISC (image1), 0.5, 0.06);

	vbox2 = gtk_vbox_new (FALSE, 10);
	gtk_container_set_border_width (GTK_CONTAINER (vbox2), 6);
	gtk_widget_show (vbox2);
	gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);

	snprintf (buf2, sizeof (buf2), _("Connection to %s complete."),
				 server_get_network (serv, TRUE));
	snprintf (buf, sizeof (buf), "\n<b>%s</b>", buf2);
	label = gtk_label_new (buf);
	gtk_widget_show (label);
	gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
	gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	label = gtk_label_new (_("In the Server-List window, no channel (chat room) has been entered to be automatically joined for this network."));
	gtk_widget_show (label);
	gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
	GTK_LABEL (label)->wrap = TRUE;
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	label = gtk_label_new (_("What would you like to do next?"));
	gtk_widget_show (label);
	gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	serv->gui->joind_radio1 = radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, _("_Nothing, I'll join a channel later."));
	gtk_widget_show (radiobutton1);
	gtk_box_pack_start (GTK_BOX (vbox2), radiobutton1, FALSE, FALSE, 0);
	radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1));

	hbox2 = gtk_hbox_new (FALSE, 0);
	gtk_widget_show (hbox2);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);

	serv->gui->joind_radio2 = radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, _("_Join this channel:"));
	gtk_widget_show (radiobutton2);
	gtk_box_pack_start (GTK_BOX (hbox2), radiobutton2, FALSE, FALSE, 0);
	gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group);
	radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2));

	serv->gui->joind_entry = entry1 = gtk_entry_new ();
	gtk_entry_set_text (GTK_ENTRY (entry1), "#");
	gtk_widget_show (entry1);
	gtk_box_pack_start (GTK_BOX (hbox2), entry1, TRUE, TRUE, 8);

	snprintf (buf, sizeof (buf), "<small>     %s</small>",
				 _("If you know the name of the channel you want to join, enter it here."));
	label = gtk_label_new (buf);
	gtk_widget_show (label);
	gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
	gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	radiobutton3 = gtk_radio_button_new_with_mnemonic (NULL, _("O_pen the Channel-List window."));
	gtk_widget_show (radiobutton3);
	gtk_box_pack_start (GTK_BOX (vbox2), radiobutton3, FALSE, FALSE, 0);
	gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton3), radiobutton1_group);
	radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton3));

	snprintf (buf, sizeof (buf), "<small>     %s</small>",
				 _("Retrieving the Channel-List may take a minute or two."));
	label = gtk_label_new (buf);
	gtk_widget_show (label);
	gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
	gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	serv->gui->joind_check = checkbutton1 = gtk_check_button_new_with_mnemonic (_("_Always show this dialog after connecting."));
	if (prefs.gui_join_dialog)
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), TRUE);
	gtk_widget_show (checkbutton1);
	gtk_box_pack_start (GTK_BOX (vbox1), checkbutton1, FALSE, FALSE, 0);

	dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
	gtk_widget_show (dialog_action_area1);
	gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);

	okbutton1 = gtk_button_new_from_stock ("gtk-ok");
	gtk_widget_show (okbutton1);
	gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog1)->action_area), okbutton1, FALSE, TRUE, 0);
	GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);

	g_signal_connect (G_OBJECT (dialog1), "destroy",
							G_CALLBACK (joind_destroy_cb), serv);
	g_signal_connect (G_OBJECT (entry1), "focus_in_event",
							G_CALLBACK (joind_entryfocus_cb), serv);
	g_signal_connect (G_OBJECT (entry1), "activate",
							G_CALLBACK (joind_entryenter_cb), okbutton1);
	g_signal_connect (G_OBJECT (radiobutton2), "toggled",
							G_CALLBACK (joind_radio2_cb), serv);
	g_signal_connect (G_OBJECT (okbutton1), "clicked",
							G_CALLBACK (joind_ok_cb), serv);

	gtk_widget_grab_focus (okbutton1);
	gtk_widget_show_all (dialog1);
}
Exemple #4
0
int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);

    if (argc != 2)
    {
        fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
        exit(1);
    }

    const gchar* filename = argv[1];

    {
        struct stat st;
        stat(filename, &st);
        if (!S_ISREG(st.st_mode))
        {
            fprintf(stderr, "Error: %s is not a file\n", filename);
            exit(1);
        }
    }

    GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
    gtk_window_set_position(window, GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(window, 400, 300);
    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);

    const gchar* mime = NULL;
    {
        magic_t magic;

        magic = magic_open(MAGIC_MIME_TYPE);
        g_assert(magic != NULL);

        int magic_load_result = magic_load(magic, NULL);
        g_assert(magic_load_result == 0);

        mime = magic_file(magic, filename);
        if (mime == NULL)
        {
            fprintf(stderr, "Error: Can't detect mime type (%s).\n", magic_error(magic));
            magic_close(magic);
            exit(1);
        }

        magic_close(magic);
    }

    GError* error = NULL;
    GtkWidget* page = get_page(filename, mime, &error);
    if (error != NULL)
    {
        fprintf(stderr,
                "Error: Can't create page.\ndomain: %s\nmessage: %s\n",
                g_quark_to_string(error->domain),
                error->message);
        g_error_free(error);
        exit(1);
    }

    gtk_container_add(GTK_CONTAINER(window), page);

    gtk_widget_show_all(GTK_WIDGET(window));
    gtk_main();

    return 0;
}
Exemple #5
0
void gui_main::build_gui()
{
    gdk_threads_enter();
    XInitThreads();
    gtk_init( 0, NULL );

    /* Create the main window */
    _window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width (GTK_CONTAINER (_window), 8);
    gtk_window_set_title (GTK_WINDOW (_window), "PRIMATES control window");
    //gtk_window_set_default_size(GTK_WINDOW(_window), 400, 300);
    gtk_window_set_position (GTK_WINDOW (_window), GTK_WIN_POS_CENTER);

    _pwmControlPage = gtk_fixed_new();
    gtk_widget_set_usize(_pwmControlPage, 900, 450);

    LoadServoControls(_pwmControlPage);

    GtkWidget * noteBook = gtk_notebook_new ();

// second page initialization

    _positionPage = gtk_fixed_new();
    gtk_widget_set_usize(_positionPage, 900, 450);

    gtkAllServo * all = new gtkAllServo("Start", ServosModel);
    gtk_fixed_put(GTK_FIXED (_positionPage), all->get_main(), 0, 0);

    all = new gtkAllServo("2nd", ServosModel);
    gtk_fixed_put(GTK_FIXED (_positionPage), all->get_main(), 0, 60);

    all = new gtkAllServo("3nd", ServosModel);
    gtk_fixed_put(GTK_FIXED (_positionPage), all->get_main(), 0, 120);

    all = new gtkAllServo("4nd", ServosModel);
    gtk_fixed_put(GTK_FIXED (_positionPage), all->get_main(), 0, 180);

    all = new gtkAllServo("5nd", ServosModel);
    gtk_fixed_put(GTK_FIXED (_positionPage), all->get_main(), 0, 240);

    RewardView * view = new RewardView(RewardModel);
    gtk_fixed_put(GTK_FIXED (_positionPage), view->get_main(), 250, 0);

    // walk page
    WalkView * walkView = new WalkView(ServosModel);
    GtkWidget * walkPage = gtk_fixed_new();
    gtk_widget_set_usize(walkPage, 900, 450);
    gtk_fixed_put(GTK_FIXED (walkPage), walkView->get_main(), 0, 0);

    gtk_notebook_append_page ((GtkNotebook*)noteBook, _positionPage, gtk_label_new("Position"));
    gtk_notebook_append_page ((GtkNotebook*)noteBook, _pwmControlPage, gtk_label_new("PWM Control"));
    gtk_notebook_append_page ((GtkNotebook*)noteBook, walkPage, gtk_label_new("Walk"));

    // put everithing to window
    gtk_container_add (GTK_CONTAINER (_window), noteBook);
    /* Enter the main loop */
    gtk_widget_show_all (_window);
    gtk_main ();
    /* Release gtk's global lock */
    gdk_threads_leave();
}
Exemple #6
0
/*! \brief Creates the arc angle dialog
 *  \par Function Description
 *  This function creates the arc angle dialog. Depending on the
 *  \a arc_object the entries are filled with the arc OBJECT properties
 *  or with some standard values.
 *
 *  \param [in] w_current   The GschemToplevel object
 *  \param [in] arc_object  an arc OBJECT if used to modify an arc
 *                          or NULL to create a new arc.
 */
void arc_angle_dialog (GschemToplevel *w_current, OBJECT *arc_object)
{
  GtkWidget *label[3];
  GtkWidget *vbox;
  GtkWidget *alignment, *table;
  GtkWidget *widget[3];

  if (!w_current->aawindow) {
    w_current->aawindow = gschem_dialog_new_with_buttons(_("Arc Params"),
                                                         GTK_WINDOW(w_current->main_window),
                                                         GTK_DIALOG_MODAL,
                                                         "arc-angle", w_current,
                                                         GTK_STOCK_CANCEL,
                                                         GTK_RESPONSE_REJECT,
                                                         GTK_STOCK_OK,
                                                         GTK_RESPONSE_ACCEPT,
                                                         NULL);

  /* Set the alternative button order (ok, cancel, help) for other systems */
    gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->aawindow),
                                            GTK_RESPONSE_ACCEPT,
                                            GTK_RESPONSE_REJECT,
                                            -1);

    gtk_window_set_position (GTK_WINDOW (w_current->aawindow), GTK_WIN_POS_MOUSE);

    g_signal_connect (G_OBJECT (w_current->aawindow), "response",
                      G_CALLBACK (arc_angle_dialog_response),
                      w_current);

    gtk_dialog_set_default_response(GTK_DIALOG(w_current->aawindow),
                                    GTK_RESPONSE_ACCEPT);

    gtk_container_set_border_width (GTK_CONTAINER (w_current->aawindow),
                                    DIALOG_BORDER_SPACING);
    vbox = GTK_DIALOG(w_current->aawindow)->vbox;
    gtk_box_set_spacing(GTK_BOX(vbox), DIALOG_V_SPACING);


    alignment = gtk_alignment_new(0,0,1,1);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0,
                              0 /*DIALOG_INDENTATION */, 0);
    gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, FALSE, 0);

    label[0] = gschem_dialog_misc_create_property_label (_("Arc _Radius:"));
    label[1] = gschem_dialog_misc_create_property_label (_("Start _Angle:"));
    label[2] = gschem_dialog_misc_create_property_label (_("_Degrees of Sweep:"));

    widget[0] = gtk_spin_button_new_with_range (1, 100000, 100);
    gtk_entry_set_activates_default (GTK_ENTRY(widget[0]), TRUE);

    widget[1] = gtk_spin_button_new_with_range (-360,360,1);
    gtk_entry_set_activates_default (GTK_ENTRY(widget[1]), TRUE);

    widget[2] = gtk_spin_button_new_with_range (-360,360,1);
    gtk_entry_set_activates_default(GTK_ENTRY(widget[2]), TRUE);

	table = gschem_dialog_misc_create_property_table (label, widget, 3);
    gtk_container_add (GTK_CONTAINER(alignment), table);

    GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[0], "radius");
    GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[1],"spin_start");
    GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[2],"spin_sweep");
    g_object_set_data(G_OBJECT(w_current->aawindow), "arc_object", arc_object);
    gtk_widget_show_all (w_current->aawindow);
  }

  else {  /* dialog already created */
    gtk_window_present (GTK_WINDOW(w_current->aawindow));
    widget[0] = GTK_WIDGET (g_object_get_data (G_OBJECT (w_current->aawindow),
                                               "radius"));
    widget[1] = GTK_WIDGET (g_object_get_data (G_OBJECT (w_current->aawindow),
                                               "spin_start"));
    widget[2] = GTK_WIDGET (g_object_get_data (G_OBJECT (w_current->aawindow),
                                               "spin_sweep"));
  }

  if (arc_object == NULL) {
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[0]), w_current->distance);
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[1]),0);
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[2]), 90);
  } else {
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[0]),
                              geda_arc_object_get_radius (arc_object));
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[1]),
                              geda_arc_object_get_start_angle (arc_object));
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[2]),
                              geda_arc_object_get_sweep_angle (arc_object));
  }

  gtk_widget_grab_focus(widget[0]);
}
Exemple #7
0
static void
xfmpc_song_dialog_init (XfmpcSongDialog *dialog)
{
	XfmpcSongDialogPrivate *priv = dialog->priv = GET_PRIVATE (dialog);

	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
	gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), TRUE);
	gtk_window_set_icon_name (GTK_WINDOW (dialog), "stock_volume");
	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
	gtk_window_set_title (GTK_WINDOW (dialog), _("Song Info"));

	gtk_dialog_add_buttons (GTK_DIALOG (dialog),
													GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
													NULL);

	PangoAttrList *attrs = pango_attr_list_new ();
	PangoAttribute *attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
	pango_attr_list_insert (attrs, attr);

	GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
	gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
	gtk_widget_show (vbox);

	GtkWidget *vbox2 = gtk_vbox_new (FALSE, 0);
	GtkWidget *frame = gtk_frame_new("");
	gtk_container_add (GTK_CONTAINER (frame), vbox2);
		//xfce_create_framebox_with_content (NULL, vbox2);
	gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

	/* File */
	GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 6);
	GtkWidget *label = gtk_label_new (_("File"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);
	label = priv->label_file = gtk_label_new (NULL);
	gtk_label_set_selectable (GTK_LABEL (label), TRUE);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);

	/* Artist */
	hbox = priv->hbox_artist = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 6);
	label = gtk_label_new (_("Artist"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);
	label = priv->label_artist = gtk_label_new (NULL);
	gtk_label_set_selectable (GTK_LABEL (label), TRUE);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);

	/* Title */
	hbox = priv->hbox_title = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 6);
	label = gtk_label_new (_("Title"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);
	label = priv->label_title = gtk_label_new (NULL);
	gtk_label_set_selectable (GTK_LABEL (label), TRUE);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);

	/* Album */
	hbox = priv->hbox_album = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 6);
	label = gtk_label_new (_("Album"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);
	label = priv->label_album = gtk_label_new (NULL);
	gtk_label_set_selectable (GTK_LABEL (label), TRUE);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);

	/* Date */
	hbox = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 6);
	priv->hbox_date = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (hbox), priv->hbox_date, FALSE, FALSE, 0);
	label = gtk_label_new (_("Date"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_box_pack_start (GTK_BOX (priv->hbox_date), label, FALSE, FALSE, 5);
	label = priv->label_date = gtk_label_new (NULL);
	gtk_label_set_selectable (GTK_LABEL (label), TRUE);
	gtk_box_pack_start (GTK_BOX (priv->hbox_date), label, FALSE, FALSE, 5);

	/* Track */
	priv->hbox_track = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (hbox), priv->hbox_track, FALSE, FALSE, 15);
	label = gtk_label_new (_("Track"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_box_pack_start (GTK_BOX (priv->hbox_track), label, FALSE, FALSE, 5);
	label = priv->label_track = gtk_label_new (NULL);
	gtk_label_set_selectable (GTK_LABEL (label), TRUE);
	gtk_box_pack_start (GTK_BOX (priv->hbox_track), label, FALSE, FALSE, 5);

	/* Genre */
	hbox = priv->hbox_genre = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 6);
	label = gtk_label_new (_("Genre"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);
	label = priv->label_genre = gtk_label_new (NULL);
	gtk_label_set_selectable (GTK_LABEL (label), TRUE);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5);

	gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox, TRUE, TRUE, 0);
	gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
}
Exemple #8
0
static GtkWidget *
create_window (int confirm_mode)
{
  GtkWidget *w;
  GtkWidget *win, *box;
  GtkWidget *wvbox, *chbox, *bbox;
  GtkAccelGroup *acc;
  gchar *msg;

  tooltips = gtk_tooltips_new ();

  /* FIXME: check the grabbing code against the one we used with the
     old gpg-agent */
  win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  acc = gtk_accel_group_new ();

  g_signal_connect (G_OBJECT (win), "delete_event",
		    G_CALLBACK (delete_event), NULL);

#if 0
  g_signal_connect (G_OBJECT (win), "destroy", G_CALLBACK (gtk_main_quit),
		    NULL);
#endif
  g_signal_connect (G_OBJECT (win), "size-request",
		    G_CALLBACK (constrain_size), NULL);
  if (!confirm_mode)
    {
      if (pinentry->grab)
	g_signal_connect (G_OBJECT (win),
			  "realize", G_CALLBACK (make_transient), NULL);

      /* We need to grab the keyboard when its visible! not when its
         mapped (there is a difference)  */
      g_object_set (G_OBJECT(win), "events",
                    GDK_VISIBILITY_NOTIFY_MASK | GDK_STRUCTURE_MASK, NULL);

      g_signal_connect (G_OBJECT (win),
			pinentry->grab
                        ? "visibility-notify-event"
                        : "focus-in-event",
			G_CALLBACK (grab_keyboard), NULL);
      g_signal_connect (G_OBJECT (win),
			pinentry->grab ? "unmap-event" : "focus-out-event",
			G_CALLBACK (ungrab_keyboard), NULL);
    }
  gtk_window_add_accel_group (GTK_WINDOW (win), acc);

  wvbox = gtk_vbox_new (FALSE, HIG_LARGE * 2);
  gtk_container_add (GTK_CONTAINER (win), wvbox);
  gtk_container_set_border_width (GTK_CONTAINER (wvbox), HIG_LARGE);

  chbox = gtk_hbox_new (FALSE, HIG_LARGE);
  gtk_box_pack_start (GTK_BOX (wvbox), chbox, FALSE, FALSE, 0);

  w = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,
					       GTK_ICON_SIZE_DIALOG);
  gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.0);
  gtk_box_pack_start (GTK_BOX (chbox), w, FALSE, FALSE, 0);

  box = gtk_vbox_new (FALSE, HIG_SMALL);
  gtk_box_pack_start (GTK_BOX (chbox), box, TRUE, TRUE, 0);

  if (pinentry->title)
    {
      msg = pinentry_utf8_validate (pinentry->title);
      gtk_window_set_title (GTK_WINDOW(win), msg);
    }
  if (pinentry->description)
    {
      msg = pinentry_utf8_validate (pinentry->description);
      w = gtk_label_new (msg);
      g_free (msg);
      gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
      gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
      gtk_box_pack_start (GTK_BOX (box), w, TRUE, FALSE, 0);
    }
  if (pinentry->error && !confirm_mode)
    {
      GdkColor color = { 0, 0xffff, 0, 0 };

      msg = pinentry_utf8_validate (pinentry->error);
      w = gtk_label_new (msg);
      g_free (msg);
      gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
      gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
      gtk_box_pack_start (GTK_BOX (box), w, TRUE, FALSE, 0);
      gtk_widget_modify_fg (w, GTK_STATE_NORMAL, &color);
    }

  qualitybar = NULL;

  if (!confirm_mode)
    {
      GtkWidget* table = gtk_table_new (pinentry->quality_bar ? 2 : 1, 2,
					FALSE);
      gtk_box_pack_start (GTK_BOX (box), table, FALSE, FALSE, 0);

      if (pinentry->prompt)
	{
	  msg = pinentry_utf8_validate (pinentry->prompt);
	  w = gtk_label_new_with_mnemonic (msg);
	  g_free (msg);
	  gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
	  gtk_table_attach (GTK_TABLE (table), w, 0, 1, 0, 1,
			    GTK_FILL, GTK_FILL, 4, 0);
	}

      entry = gtk_secure_entry_new ();
      gtk_widget_set_size_request (entry, 200, -1);
      g_signal_connect (G_OBJECT (entry), "activate",
			G_CALLBACK (enter_callback), entry);
      g_signal_connect (G_OBJECT (entry), "changed",
                        G_CALLBACK (changed_text_handler), entry);
      gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
                        GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
      gtk_widget_grab_focus (entry);
      gtk_widget_show (entry);

      if (pinentry->quality_bar)
	{
          msg = pinentry_utf8_validate (pinentry->quality_bar);
	  w = gtk_label_new (msg);
          g_free (msg);
	  gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
	  gtk_table_attach (GTK_TABLE (table), w, 0, 1, 1, 2,
			    GTK_FILL, GTK_FILL, 4, 0);
	  qualitybar = gtk_progress_bar_new();
	  gtk_widget_add_events (qualitybar,
				 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
	  gtk_progress_bar_set_text (GTK_PROGRESS_BAR (qualitybar),
				     QUALITYBAR_EMPTY_TEXT);
	  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (qualitybar), 0.0);
          if (pinentry->quality_bar_tt)
            gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), qualitybar,
                                  pinentry->quality_bar_tt, "");
	  gtk_table_attach (GTK_TABLE (table), qualitybar, 1, 2, 1, 2,
	  		    GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
	}

#ifdef ENABLE_ENHANCED
      if (pinentry->enhanced)
	{
	  GtkWidget *sbox = gtk_hbox_new (FALSE, HIG_SMALL);
	  gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);

	  w = gtk_label_new ("Forget secret after");
	  gtk_box_pack_start (GTK_BOX (sbox), w, FALSE, FALSE, 0);
	  gtk_widget_show (w);

	  time_out = gtk_spin_button_new
	    (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, HUGE_VAL, 1, 60, 60)),
	     2, 0);
	  gtk_box_pack_start (GTK_BOX (sbox), time_out, FALSE, FALSE, 0);
	  gtk_widget_show (time_out);

	  w = gtk_label_new ("seconds");
	  gtk_box_pack_start (GTK_BOX (sbox), w, FALSE, FALSE, 0);
	  gtk_widget_show (w);
	  gtk_widget_show (sbox);

	  insure = gtk_check_button_new_with_label ("ask before giving out "
						    "secret");
	  gtk_box_pack_start (GTK_BOX (box), insure, FALSE, FALSE, 0);
	  gtk_widget_show (insure);
	}
#endif
    }

  bbox = gtk_hbutton_box_new ();
  gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
  gtk_box_set_spacing (GTK_BOX (bbox), 6);
  gtk_box_pack_start (GTK_BOX (wvbox), bbox, TRUE, FALSE, 0);

  if (!pinentry->one_button)
    {
      if (pinentry->cancel)
        {
          msg = pinentry_utf8_validate (pinentry->cancel);
          w = gtk_button_new_with_mnemonic (msg);
          g_free (msg);
        }
      else if (pinentry->default_cancel)
        {
          GtkWidget *image;

          msg = pinentry_utf8_validate (pinentry->default_cancel);
          w = gtk_button_new_with_mnemonic (msg);
          g_free (msg);
          image = gtk_image_new_from_stock (GTK_STOCK_CANCEL,
                                            GTK_ICON_SIZE_BUTTON);
          if (image)
            gtk_button_set_image (GTK_BUTTON (w), image);
        }
      else
          w = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
      gtk_container_add (GTK_CONTAINER (bbox), w);
      g_signal_connect (G_OBJECT (w), "clicked",
                        G_CALLBACK (confirm_mode ? confirm_button_clicked
                                    : button_clicked),
			(gpointer) CONFIRM_CANCEL);
      GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
    }

  if (confirm_mode && !pinentry->one_button && pinentry->notok)
    {
      msg = pinentry_utf8_validate (pinentry->notok);
      w = gtk_button_new_with_mnemonic (msg);
      g_free (msg);

      gtk_container_add (GTK_CONTAINER (bbox), w);
      g_signal_connect (G_OBJECT (w), "clicked",
                        G_CALLBACK (confirm_button_clicked),
			(gpointer) CONFIRM_NOTOK);
      GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
    }

  if (pinentry->ok)
    {
      msg = pinentry_utf8_validate (pinentry->ok);
      w = gtk_button_new_with_mnemonic (msg);
      g_free (msg);
    }
  else if (pinentry->default_ok)
    {
      GtkWidget *image;

      msg = pinentry_utf8_validate (pinentry->default_ok);
      w = gtk_button_new_with_mnemonic (msg);
      g_free (msg);
      image = gtk_image_new_from_stock (GTK_STOCK_OK,
                                        GTK_ICON_SIZE_BUTTON);
      if (image)
        gtk_button_set_image (GTK_BUTTON (w), image);
    }
  else
    w = gtk_button_new_from_stock (GTK_STOCK_OK);
  gtk_container_add (GTK_CONTAINER(bbox), w);
  if (!confirm_mode)
    {
      g_signal_connect (G_OBJECT (w), "clicked",
			G_CALLBACK (button_clicked), "ok");
      GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
      gtk_widget_grab_default (w);
      g_signal_connect_object (G_OBJECT (entry), "focus_in_event",
				G_CALLBACK (gtk_widget_grab_default),
			       G_OBJECT (w), 0);
    }
  else
    {
      g_signal_connect (G_OBJECT (w), "clicked",
			G_CALLBACK(confirm_button_clicked),
			(gpointer) CONFIRM_OK);
      GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
    }

  gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
  gtk_window_set_keep_above (GTK_WINDOW (win), TRUE);
  gtk_widget_show_all (win);
  gtk_window_present (GTK_WINDOW (win));  /* Make sure it has the focus.  */

  return win;
}
Exemple #9
0
int l_dover(const char *datadov,const char *nomerdov,GtkWidget *wpredok)
{
l_dover_data data;
char bros[512];
GdkColor color;

data.datdov.new_plus(datadov);
data.nomdov.new_plus(nomerdov);
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);

//gtk_window_set_default_size (GTK_WINDOW  (data.window),400,-1);
//gdk_color_parse("black",&color);
//gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color);


sprintf(bros,"%s %s",name_system,gettext("Доверенность"));

gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);

gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);


if(wpredok != NULL)
 {
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
  //Удерживать окно над породившем его окном всегда
  gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
  //Закрыть окно если окно предок удалено
  gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
 }

gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_dover_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);

GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);

GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);

gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);

data.label_kolstr=gtk_label_new (gettext("Доверенность"));
//gdk_color_parse("green",&color);
//gtk_widget_modify_fg(data.label_kolstr,GTK_STATE_NORMAL,&color);


gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);

gtk_widget_show(vbox1);
gtk_widget_show(vbox2);

data.label_poisk=gtk_label_new ("");
gdk_color_parse("red",&color);
gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color);

gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0);

data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300);

gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);

//Кнопки
GtkTooltips *tooltips[KOL_F_KL];

sprintf(bros,"%sF1 %s",RFK,gettext("Шапка"));
data.knopka[SFK1]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK1], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK1]), "clicked",GTK_SIGNAL_FUNC(l_dover_knopka),&data);
tooltips[SFK1]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK1],data.knopka[SFK1],gettext("Просмотр шапки документа"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK1]),(gpointer)SFK1);
gtk_widget_show(data.knopka[SFK1]);

sprintf(bros,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_dover_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);

sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_dover_knopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);


sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_dover_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);

sprintf(bros,"%sF3 %s",RFK,gettext("Удалить документ"));
data.knopka[SFK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(l_dover_knopka),&data);
tooltips[SFK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Удалить документ"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3);
gtk_widget_show(data.knopka[SFK3]);


sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_dover_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);

sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_dover_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);


gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));

gtk_widget_grab_focus(data.knopka[FK10]);

l_dover_create_list(&data);

gtk_widget_show(data.window);
//if(metka_rr == 0)
  gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));


gtk_main();


if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

return(data.metka_voz);

}
Exemple #10
0
gint _vala_main (gchar** args, int args_length1) {
	gint result = 0;
	Block1Data* _data1_;
	GtkHeaderBar* headerbar = NULL;
	GtkHeaderBar* _tmp0_ = NULL;
	GtkWindow* window = NULL;
	GtkWindow* _tmp1_ = NULL;
	GtkGrid* grid = NULL;
	GtkGrid* _tmp2_ = NULL;
	GtkButton* _tmp3_ = NULL;
	GtkGrid* gridtwo = NULL;
	GtkGrid* _tmp4_ = NULL;
	GtkLabel* _tmp5_ = NULL;
	GtkLabel* _tmp6_ = NULL;
	GtkLabel* _tmp7_ = NULL;
	GtkLabel* _tmp8_ = NULL;
	GtkLabel* _tmp9_ = NULL;
	GtkLabel* _tmp10_ = NULL;
	GtkLabel* _tmp11_ = NULL;
	GtkLabel* _tmp12_ = NULL;
	GtkGrid* layout = NULL;
	GtkGrid* _tmp13_ = NULL;
	GtkButton* _tmp14_ = NULL;
	GtkLabel* _tmp15_ = NULL;
	GtkButton* rotate_button = NULL;
	GtkButton* _tmp16_ = NULL;
	GtkLabel* _tmp17_ = NULL;
#line 20 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_data1_ = g_slice_new0 (Block1Data);
#line 20 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_data1_->_ref_count_ = 1;
#line 21 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_init (&args_length1, &args);
#line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp0_ = (GtkHeaderBar*) gtk_header_bar_new ();
#line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp0_);
#line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	headerbar = _tmp0_;
#line 25 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_header_bar_set_show_close_button (headerbar, TRUE);
#line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp1_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL);
#line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp1_);
#line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	window = _tmp1_;
#line 29 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_window_set_titlebar (window, (GtkWidget*) headerbar);
#line 30 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_window_set_title (window, "Hello Again Again Again!");
#line 31 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_set_border_width ((GtkContainer*) window, (guint) 12);
#line 32 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_window_set_position (window, GTK_WIN_POS_CENTER);
#line 33 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_window_set_default_size (window, 350, 350);
#line 34 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_signal_connect ((GtkWidget*) window, "destroy", (GCallback) _gtk_main_quit_gtk_widget_destroy, NULL);
#line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp2_ = (GtkGrid*) gtk_grid_new ();
#line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp2_);
#line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	grid = _tmp2_;
#line 38 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_orientable_set_orientation ((GtkOrientable*) grid, GTK_ORIENTATION_VERTICAL);
#line 39 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_set_row_spacing (grid, 6);
#line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp3_ = (GtkButton*) gtk_button_new_with_label ("testing");
#line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp3_);
#line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_data1_->button = _tmp3_;
#line 43 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_signal_connect_data (_data1_->button, "clicked", (GCallback) ___lambda3__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
#line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp4_ = (GtkGrid*) gtk_grid_new ();
#line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp4_);
#line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gridtwo = _tmp4_;
#line 53 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_set_column_spacing (gridtwo, 6);
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp5_ = (GtkLabel*) gtk_label_new ("Label 1");
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp5_);
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp6_ = _tmp5_;
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _tmp6_);
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (_tmp6_);
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp7_ = (GtkLabel*) gtk_label_new ("Label 2");
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp7_);
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp8_ = _tmp7_;
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _tmp8_);
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (_tmp8_);
#line 57 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _data1_->button);
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp9_ = (GtkLabel*) gtk_label_new ("Label 3");
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp9_);
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp10_ = _tmp9_;
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) _tmp10_);
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (_tmp10_);
#line 60 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) grid);
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp11_ = (GtkLabel*) gtk_label_new ("Label 4");
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp11_);
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp12_ = _tmp11_;
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) _tmp12_);
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (_tmp12_);
#line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp13_ = (GtkGrid*) gtk_grid_new ();
#line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp13_);
#line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	layout = _tmp13_;
#line 64 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_set_column_spacing (layout, 6);
#line 65 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_set_row_spacing (layout, 6);
#line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp14_ = (GtkButton*) gtk_button_new_with_label ("Say Hello");
#line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp14_);
#line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_data1_->hello_button = _tmp14_;
#line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp15_ = (GtkLabel*) gtk_label_new (NULL);
#line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp15_);
#line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_data1_->hello_label = _tmp15_;
#line 70 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_signal_connect_data (_data1_->hello_button, "clicked", (GCallback) ___lambda4__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
#line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp16_ = (GtkButton*) gtk_button_new_with_label ("Rotate");
#line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp16_);
#line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	rotate_button = _tmp16_;
#line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_tmp17_ = (GtkLabel*) gtk_label_new ("Horizontal");
#line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_object_ref_sink (_tmp17_);
#line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_data1_->rotate_label = _tmp17_;
#line 78 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	g_signal_connect_data (rotate_button, "clicked", (GCallback) ___lambda5__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
#line 82 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_attach (layout, (GtkWidget*) _data1_->hello_button, 0, 0, 1, 1);
#line 83 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_attach_next_to (layout, (GtkWidget*) _data1_->hello_label, (GtkWidget*) _data1_->hello_button, GTK_POS_RIGHT, 1, 1);
#line 84 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_attach (layout, (GtkWidget*) rotate_button, 0, 1, 1, 1);
#line 85 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_attach_next_to (layout, (GtkWidget*) _data1_->rotate_label, (GtkWidget*) rotate_button, GTK_POS_RIGHT, 1, 1);
#line 86 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_grid_attach (layout, (GtkWidget*) gridtwo, 0, 2, 2, 2);
#line 88 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_container_add ((GtkContainer*) window, (GtkWidget*) layout);
#line 89 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_widget_show_all ((GtkWidget*) window);
#line 91 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	gtk_main ();
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	result = 0;
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (rotate_button);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (layout);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (gridtwo);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (grid);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (window);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_g_object_unref0 (headerbar);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	block1_data_unref (_data1_);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	_data1_ = NULL;
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
	return result;
#line 529 "gtk-testing.c"
}
Exemple #11
0
void
calendar_create_print_window (GUI *appGUI)
{
	GtkWidget *vbox1;
	GtkWidget *frame1;
	GtkWidget *alignment;
	GtkWidget *table_fonts;
	GtkWidget *month_name_font_button;
	GtkWidget *day_name_font_button;
	GtkWidget *day_number_font_button;
	GtkWidget *event_font_button;
	GtkWidget *label;
	GtkWidget *hbox1;
	GtkWidget *frame2;
	GtkWidget *vbox2;
	GtkWidget *vseparator1;
	GtkWidget *frame3;
	GtkWidget *table5;
	GtkObject *spinbutton_adj;
	GtkWidget *hseparator1;
	GtkWidget *hbuttonbox;
	GtkWidget *cancel_button;
	GtkWidget *ok_button;
	GtkWidget *landscape_radiobutton;
	GSList *radiobutton_group = NULL;
	gchar buffer[BUFFER_SIZE];

	static FONT_SEL sel1, sel2, sel3, sel4;

	sel1.appGUI = sel2.appGUI = sel3.appGUI = sel4.appGUI = appGUI;
	sel1.font = sel2.font = sel3.font = sel4.font = NULL;
	sel1.widget = sel2.widget = sel3.widget = sel4.widget = NULL;
	sel1.save = sel2.save = sel3.save = sel4.save = FALSE;

	appGUI->cal->window_print_options = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (appGUI->cal->window_print_options), _("Printing properties"));
	gtk_window_set_position (GTK_WINDOW (appGUI->cal->window_print_options), GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_modal (GTK_WINDOW (appGUI->cal->window_print_options), TRUE);
	g_signal_connect (G_OBJECT (appGUI->cal->window_print_options), "delete_event",
	                  G_CALLBACK (window_cal_print_opt_close_cb), appGUI);
	g_signal_connect (G_OBJECT (appGUI->cal->window_print_options), "key_press_event",
	                  G_CALLBACK (cal_print_opt_key_press_cb), appGUI);
	gtk_window_set_transient_for (GTK_WINDOW (appGUI->cal->window_print_options), GTK_WINDOW (appGUI->main_window));
	gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->window_print_options), 4);

	/*---------------------------------------------------------------------------------*/

	vbox1 = gtk_vbox_new (FALSE, 0);
	gtk_widget_show (vbox1);
	gtk_container_add (GTK_CONTAINER (appGUI->cal->window_print_options), vbox1);

	frame1 = gtk_frame_new (NULL);
	gtk_widget_show (frame1);
	gtk_box_pack_start (GTK_BOX (vbox1), frame1, FALSE, FALSE, 2);
	gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_widget_show (alignment);
	gtk_container_add (GTK_CONTAINER (frame1), alignment);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);

	table_fonts = gtk_table_new (4, 3, FALSE);
	gtk_widget_show (table_fonts);
	gtk_container_add (GTK_CONTAINER (alignment), table_fonts);
	gtk_table_set_row_spacings (GTK_TABLE (table_fonts), 4);
	gtk_table_set_col_spacings (GTK_TABLE (table_fonts), 4);

	/* table_fonts: row 1 */
	g_snprintf (buffer, BUFFER_SIZE, "%s:", _("Month name"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_table_attach (GTK_TABLE (table_fonts), label, 0, 1, 0, 1,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	appGUI->cal->print_month_name_font_entry = gtk_entry_new ();
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_month_name_font_entry, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_month_name_font_entry);
	gtk_table_attach (GTK_TABLE (table_fonts), appGUI->cal->print_month_name_font_entry, 1, 2, 0, 1,
	                  (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_entry_set_text (GTK_ENTRY (appGUI->cal->print_month_name_font_entry), config.cal_print_month_name_font);

	sel1.config = config.cal_print_month_name_font;
	sel1.entry = appGUI->cal->print_month_name_font_entry;

	if (config.default_stock_icons) {
		month_name_font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
	} else {
		month_name_font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE);
	}
	GTK_WIDGET_UNSET_FLAGS (month_name_font_button, GTK_CAN_FOCUS);
	gtk_widget_show (month_name_font_button);
	g_signal_connect (G_OBJECT (month_name_font_button), "clicked",
	                  G_CALLBACK (utl_gui_font_select_cb), &sel1);
	gtk_table_attach (GTK_TABLE (table_fonts), month_name_font_button, 2, 3, 0, 1,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	/* table_fonts: row 2 */
	g_snprintf (buffer, BUFFER_SIZE, "%s:", _("Day name"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_table_attach (GTK_TABLE (table_fonts), label, 0, 1, 1, 2,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	appGUI->cal->print_day_name_font_entry = gtk_entry_new ();
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_day_name_font_entry, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_day_name_font_entry);
	gtk_table_attach (GTK_TABLE (table_fonts), appGUI->cal->print_day_name_font_entry, 1, 2, 1, 2,
	                  (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_entry_set_text (GTK_ENTRY (appGUI->cal->print_day_name_font_entry), config.cal_print_day_name_font);

	sel2.config = config.cal_print_day_name_font;
	sel2.entry = appGUI->cal->print_day_name_font_entry;

	if (config.default_stock_icons) {
		day_name_font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
	} else {
		day_name_font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE);
	}
	GTK_WIDGET_UNSET_FLAGS (day_name_font_button, GTK_CAN_FOCUS);
	gtk_widget_show (day_name_font_button);
	g_signal_connect (G_OBJECT (day_name_font_button), "clicked",
	                  G_CALLBACK (utl_gui_font_select_cb), &sel2);
	gtk_table_attach (GTK_TABLE (table_fonts), day_name_font_button, 2, 3, 1, 2,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	/* table_fonts: row 3 */
	g_snprintf (buffer, BUFFER_SIZE, "%s:", _("Day number"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_table_attach (GTK_TABLE (table_fonts), label, 0, 1, 2, 3,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	appGUI->cal->print_day_num_font_entry = gtk_entry_new ();
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_day_num_font_entry, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_day_num_font_entry);
	gtk_table_attach (GTK_TABLE (table_fonts), appGUI->cal->print_day_num_font_entry, 1, 2, 2, 3,
	                  (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_entry_set_text (GTK_ENTRY (appGUI->cal->print_day_num_font_entry), config.cal_print_day_num_font);

	sel3.config = config.cal_print_day_num_font;
	sel3.entry = appGUI->cal->print_day_num_font_entry;

	if (config.default_stock_icons) {
		day_number_font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
	} else {
		day_number_font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE);
	}
	GTK_WIDGET_UNSET_FLAGS (day_number_font_button, GTK_CAN_FOCUS);
	gtk_widget_show (day_number_font_button);
	g_signal_connect (G_OBJECT (day_number_font_button), "clicked",
	                  G_CALLBACK (utl_gui_font_select_cb), &sel3);
	gtk_table_attach (GTK_TABLE (table_fonts), day_number_font_button, 2, 3, 2, 3,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	/* table_fonts: row 4 */
	g_snprintf (buffer, BUFFER_SIZE, "%s:", _("Events"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_table_attach (GTK_TABLE (table_fonts), label, 0, 1, 3, 4,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	appGUI->cal->print_event_font_entry = gtk_entry_new ();
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_event_font_entry, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_event_font_entry);
	gtk_table_attach (GTK_TABLE (table_fonts), appGUI->cal->print_event_font_entry, 1, 2, 3, 4,
	                  (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_entry_set_text (GTK_ENTRY (appGUI->cal->print_event_font_entry), config.cal_print_event_font);

	sel4.config = config.cal_print_event_font;
	sel4.entry = appGUI->cal->print_event_font_entry;

	if (config.default_stock_icons) {
		event_font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
	} else {
		event_font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE);
	}
	GTK_WIDGET_UNSET_FLAGS (event_font_button, GTK_CAN_FOCUS);
	gtk_widget_show (event_font_button);
	g_signal_connect (G_OBJECT (event_font_button), "clicked",
	                  G_CALLBACK (utl_gui_font_select_cb), &sel4);
	gtk_table_attach (GTK_TABLE (table_fonts), event_font_button, 2, 3, 3, 4,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	/* table_fonts: END */

	g_snprintf (buffer, BUFFER_SIZE, "<b>%s</b>", _("Fonts"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_frame_set_label_widget (GTK_FRAME (frame1), label);
	gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

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

	frame2 = gtk_frame_new (NULL);
	gtk_widget_show (frame2);
	gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 2);
	gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_widget_show (alignment);
	gtk_container_add (GTK_CONTAINER (frame2), alignment);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);

	vbox2 = gtk_vbox_new (FALSE, 0);
	gtk_widget_show (vbox2);
	gtk_container_add (GTK_CONTAINER (alignment), vbox2);

	appGUI->cal->print_tasks_checkbutton = gtk_check_button_new_with_mnemonic (_("Tasks"));
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_tasks_checkbutton, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_tasks_checkbutton);
	gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->print_tasks_checkbutton, FALSE, FALSE, 0);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_tasks_checkbutton),
	                              config.cal_print_tasks);

	appGUI->cal->print_birthdays_checkbutton = gtk_check_button_new_with_mnemonic (_("Birthdays"));
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_birthdays_checkbutton, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_birthdays_checkbutton);
	gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->print_birthdays_checkbutton, FALSE, FALSE, 0);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_birthdays_checkbutton),
	                              config.cal_print_birthdays);

	appGUI->cal->print_namedays_checkbutton = gtk_check_button_new_with_mnemonic (_("Namedays"));
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_namedays_checkbutton, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_namedays_checkbutton);
	gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->print_namedays_checkbutton, FALSE, FALSE, 0);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_namedays_checkbutton),
	                              config.cal_print_namedays);

	appGUI->cal->print_day_notes_checkbutton = gtk_check_button_new_with_mnemonic (_("Day notes"));
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_day_notes_checkbutton, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_day_notes_checkbutton);
	gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->print_day_notes_checkbutton, FALSE, FALSE, 0);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_day_notes_checkbutton),
	                              config.cal_print_day_notes);

	appGUI->cal->print_ical_checkbutton = gtk_check_button_new_with_mnemonic (_("ICal"));
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_ical_checkbutton, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_ical_checkbutton);
	gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->print_ical_checkbutton, FALSE, FALSE, 0);
	gtk_widget_set_sensitive (appGUI->cal->print_ical_checkbutton, FALSE);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_ical_checkbutton),
	                              config.cal_print_ical);

	g_snprintf (buffer, BUFFER_SIZE, "<b>%s</b>", _("Visible events"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_frame_set_label_widget (GTK_FRAME (frame2), label);
	gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

	vseparator1 = gtk_vseparator_new ();
	gtk_widget_show (vseparator1);
	gtk_box_pack_start (GTK_BOX (hbox1), vseparator1, TRUE, TRUE, 0);

	frame3 = gtk_frame_new (NULL);
	gtk_widget_show (frame3);
	gtk_box_pack_start (GTK_BOX (hbox1), frame3, TRUE, TRUE, 2);
	gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_NONE);

	g_snprintf (buffer, BUFFER_SIZE, "<b>%s</b>", _("Options"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_frame_set_label_widget (GTK_FRAME (frame3), label);
	gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_widget_show (alignment);
	gtk_container_add (GTK_CONTAINER (frame3), alignment);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);

	table5 = gtk_table_new (2, 2, FALSE);
	gtk_widget_show (table5);
	gtk_container_add (GTK_CONTAINER (alignment), table5);
	gtk_table_set_row_spacings (GTK_TABLE (table5), 4);
	gtk_table_set_col_spacings (GTK_TABLE (table5), 4);

	g_snprintf (buffer, BUFFER_SIZE, "%s:", _("Padding"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_table_attach (GTK_TABLE (table5), label, 0, 1, 0, 1,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	g_snprintf (buffer, BUFFER_SIZE, "%s:", _("Event maximum length"));
	label = gtk_label_new (buffer);
	gtk_widget_show (label);
	gtk_table_attach (GTK_TABLE (table5), label, 0, 1, 1, 2,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	spinbutton_adj = gtk_adjustment_new (config.cal_print_padding, 1, 16, 1, 10, 0);
	appGUI->cal->print_padding_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_adj), 1, 0);
	gtk_widget_show (appGUI->cal->print_padding_spinbutton);
	gtk_table_attach (GTK_TABLE (table5), appGUI->cal->print_padding_spinbutton, 1, 2, 0, 1,
	                  (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	spinbutton_adj = gtk_adjustment_new (config.cal_print_event_length, 6, 256, 1, 10, 0);
	appGUI->cal->print_event_length_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_adj), 1, 0);
	gtk_widget_show (appGUI->cal->print_event_length_spinbutton);
	gtk_table_attach (GTK_TABLE (table5), appGUI->cal->print_event_length_spinbutton, 1, 2, 1, 2,
	                  (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	label = gtk_label_new (_("Page orientation:"));
	gtk_widget_show (label);
	gtk_table_attach (GTK_TABLE (table5), label, 0, 1, 2, 3,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	appGUI->cal->print_portrait_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("Portrait"));
	GTK_WIDGET_UNSET_FLAGS (appGUI->cal->print_portrait_radiobutton, GTK_CAN_FOCUS);
	gtk_widget_show (appGUI->cal->print_portrait_radiobutton);
	gtk_table_attach (GTK_TABLE (table5), appGUI->cal->print_portrait_radiobutton, 1, 2, 2, 3,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->cal->print_portrait_radiobutton), radiobutton_group);
	radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->cal->print_portrait_radiobutton));

	landscape_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("Landscape"));
	GTK_WIDGET_UNSET_FLAGS (landscape_radiobutton, GTK_CAN_FOCUS);
	gtk_widget_show (landscape_radiobutton);
	gtk_table_attach (GTK_TABLE (table5), landscape_radiobutton, 1, 2, 3, 4,
	                  (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_radio_button_set_group (GTK_RADIO_BUTTON (landscape_radiobutton), radiobutton_group);
	radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (landscape_radiobutton));

	if (config.cal_print_page_orientation == PORTRAIT) {
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->cal->print_portrait_radiobutton), TRUE);
	} else {
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (landscape_radiobutton), TRUE);
	}

	hseparator1 = gtk_hseparator_new ();
	gtk_widget_show (hseparator1);
	gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, FALSE, TRUE, 4);

	hbuttonbox = gtk_hbutton_box_new ();
	gtk_widget_show (hbuttonbox);
	gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, FALSE, 0);
	gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox), 4);
	gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
	gtk_box_set_spacing (GTK_BOX (hbuttonbox), 16);

	if (config.default_stock_icons) {
		cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
	} else {
		cancel_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CANCEL);
	}
	gtk_widget_show (cancel_button);
	g_signal_connect (cancel_button, "clicked", G_CALLBACK (window_button_cal_print_opt_close_cb), appGUI);
	gtk_container_add (GTK_CONTAINER (hbuttonbox), cancel_button);

	if (config.default_stock_icons) {
		ok_button = gtk_button_new_from_stock (GTK_STOCK_OK);
	} else {
		ok_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_OK);
	}
	gtk_widget_show (ok_button);
	g_signal_connect (ok_button, "clicked", G_CALLBACK (calendar_print_start_cb), appGUI);
	gtk_container_add (GTK_CONTAINER (hbuttonbox), ok_button);

	gtk_widget_show (appGUI->cal->window_print_options);
}
Exemple #12
0
int vvod_tabnom(class iceb_u_str *tabnom,GtkWidget *wpredok)
{
char strsql[512];
class vvod_tabnom_data data;

//printf("vvod_tabnom\n");
    
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
gtk_window_set_resizable(GTK_WINDOW(data.window),FALSE); /*запрет на изменение размеров окна*/


gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
//gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_widget_destroyed),&data.window);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(vvod_tabnom_key_press),&data);


if(wpredok != NULL)
 {
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
  //Удерживать окно над породившем его окном всегда
  gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
  //Закрыть окно если окно предок удалено
  gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
 }

GtkWidget *label;
sprintf(strsql,"%s %s",name_system,gettext("Ввод табельного номера"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);

label=gtk_label_new(gettext("Введите табельный номер"));


GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
GtkWidget *hbox[KOLENTER+1];
for(int i=0 ; i < KOLENTER+1; i++)
  hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);

gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
for(int i=0 ; i < KOLENTER+1; i++)
 gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);
gtk_container_add (GTK_CONTAINER (vbox), hboxknop);


data.knopka_enter[E_TABNOM]=gtk_button_new_with_label(gettext("Табельный номер"));
gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.knopka_enter[E_TABNOM], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_TABNOM]),"clicked",GTK_SIGNAL_FUNC(vvod_tabnom_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_TABNOM]),(gpointer)E_TABNOM);
GtkTooltips *tooltips_k=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_k,data.knopka_enter[E_TABNOM],gettext("Выбор табельного номера."),NULL);


data.entry[E_TABNOM] = gtk_entry_new_with_max_length (11);
gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.entry[E_TABNOM], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_TABNOM]), "activate",GTK_SIGNAL_FUNC(vvod_tabnom_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_TABNOM]),"");
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_TABNOM]),(gpointer)E_TABNOM);



GtkTooltips *tooltips[KOL_F_KL];

sprintf(strsql,"F2 %s",gettext("Ввод"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Запись введеной в меню информации."),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(vvod_tabnom_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);

sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы с меню без записи введенной информации."),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(vvod_tabnom_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);

gtk_widget_grab_focus(data.entry[0]);

gtk_widget_show_all (data.window);

gtk_main();

if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

if(data.voz == 0)
 tabnom->new_plus(data.tabnom.ravno());

return(data.voz);
}
Exemple #13
0
void configure_program_dialog(GtkWidget *widget, gpointer user_data) {

  /** Program configuration dailog window. **/

  #ifdef DEBUG
  DEBUG_FUNC_MARK
  #endif

  GtkWidget *configure_dialog = gtk_dialog_new() ;



  gtk_window_set_icon_from_file(GTK_WINDOW(configure_dialog), PATH_TO_PRG_WIN_ICON, NULL) ;
  gtk_window_set_title(GTK_WINDOW(configure_dialog), "Configure program") ;
  gtk_window_set_position(GTK_WINDOW(configure_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
  gtk_window_set_resizable(GTK_WINDOW(configure_dialog), FALSE);
  gtk_widget_set_size_request(configure_dialog,-1,-1) ;
  gtk_window_set_modal(GTK_WINDOW(configure_dialog), FALSE) ;
  gtk_window_set_destroy_with_parent(GTK_WINDOW(configure_dialog), TRUE) ;
  gtk_window_set_decorated(GTK_WINDOW(configure_dialog), TRUE) ;

  gtk_window_set_type_hint(GTK_WINDOW(configure_dialog), GDK_WINDOW_TYPE_HINT_NORMAL) ;
  gtk_window_set_transient_for(GTK_WINDOW(configure_dialog), GTK_WINDOW(gui->window)) ;

  gtk_container_set_border_width(GTK_CONTAINER(configure_dialog), 12) ;


  #define DIALOG_DEFAULT_SPACE 12


  /** ***** [START] Icon set choice [START] ***** **/

  GtkWidget *icon_set_choice_frame = gtk_frame_new(" Icon set ") ;


  GtkWidget *icon_set_choice_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;

  gtk_container_set_border_width(GTK_CONTAINER(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;

  gtk_box_set_spacing(GTK_BOX(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;

  gtk_box_set_homogeneous(GTK_BOX(icon_set_choice_hbox), TRUE) ;


  GtkWidget *radiobutton_icons_high_contrast = gtk_radio_button_new_with_label(NULL, " HighContrast") ;

  GtkWidget *image_icons_high_contrast       ;

  GtkWidget *radiobutton_icons_oxygen        = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_icons_high_contrast)), " Oxygen") ;

  GtkWidget *image_icons_oxygen              ;


  gtk_widget_set_tooltip_markup(radiobutton_icons_high_contrast, "Set the <b>HighContrast</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
  gtk_widget_set_tooltip_markup(radiobutton_icons_oxygen,        "Set the <b>Oxygen</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;

  gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), FALSE) ;
  gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen),        FALSE) ;


  if (settings.icon_set_oxygen) {

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), TRUE) ;

    image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS  "face-angry.png")     ;

    image_icons_oxygen        = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS         "face-smile-big.png") ;

  }
  else {

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), TRUE) ;

    image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS  "face-smile-big.png") ;

    image_icons_oxygen        = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS         "face-angry.png")     ;

  }


  gtk_button_set_image(GTK_BUTTON(radiobutton_icons_high_contrast), image_icons_high_contrast) ;

  gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_high_contrast), TRUE) ;

  gtk_button_set_image(GTK_BUTTON(radiobutton_icons_oxygen), image_icons_oxygen) ;

  gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_oxygen), TRUE)   ;





  gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_high_contrast, TRUE,  TRUE, 0) ;
  gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_oxygen,        TRUE,  TRUE, 0) ;

  gtk_container_add(GTK_CONTAINER(icon_set_choice_frame), icon_set_choice_hbox) ;

  /** ***** [END] Icon set choice [END] ***** **/



  /** ***** [START] Playing settings [START] ***** **/

  GtkWidget *playing_settings_frame = gtk_frame_new(" Player settings ") ;


  GtkWidget *playing_settings_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;

  gtk_container_set_border_width(GTK_CONTAINER(playing_settings_vbox), DIALOG_DEFAULT_SPACE) ;



  GtkWidget *playing_settings_repeat_all = gtk_check_button_new_with_label(" Repeat all mode. ") ;

  gtk_widget_set_tooltip_markup(playing_settings_repeat_all, "Enable the <b>repeat all</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;

  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all), is_repeat_all) ;



  GtkWidget *playing_settings_shuffle = gtk_check_button_new_with_label(" Shuffle mode. ") ;

  gtk_widget_set_tooltip_markup(playing_settings_shuffle, "Enable the <b>shuffle</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;

  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle), is_shuffle ) ;

  GtkWidget *playing_settings_volume_hbox  = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;



  GtkWidget *playing_settings_volume_label_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;

  GtkWidget *playing_settings_volume_image      = gtk_image_new_from_file( (settings.path_to_button_icons + "audio-volume-medium.png").c_str() ) ;

  GtkWidget *playing_settings_volume_label      = gtk_label_new(" Default Volume:") ;

  gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_image, FALSE, FALSE, 0) ;
  gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_label, FALSE, FALSE, 0) ;


  GtkWidget *playing_settings_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1.0) ;



  gtk_widget_set_tooltip_markup(playing_settings_volume_scale, "Set the <b>default player volume</b> at start.\nThis will <b>not</b> update the player settings.\nYou must press the <b>Apply</b> button to store your configuration.") ;

  gtk_range_set_value(GTK_RANGE(playing_settings_volume_scale), settings.volume) ;

  gtk_scale_set_draw_value(GTK_SCALE(playing_settings_volume_scale), TRUE) ;
  gtk_scale_set_has_origin(GTK_SCALE(playing_settings_volume_scale), TRUE) ;

  gtk_scale_set_value_pos(GTK_SCALE(playing_settings_volume_scale), GTK_POS_TOP) ;

  gtk_scale_add_mark(GTK_SCALE(playing_settings_volume_scale), 50.0, GTK_POS_TOP, NULL) ;



  gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_label_hbox, FALSE,  FALSE, 0) ;
  gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_scale,      TRUE,   TRUE,  0) ;



  gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_repeat_all,               FALSE, FALSE, 0)   ;
  gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_shuffle,                  FALSE, FALSE, 0)   ;
  gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_volume_hbox,              FALSE, FALSE, 0)   ;

  gtk_container_add(GTK_CONTAINER(playing_settings_frame), playing_settings_vbox) ;

  /** ***** [END] Playing settings [END] ***** **/



  /** ***** [START] Interface size setting [START] ***** **/

  GtkWidget *interface_size_frame = gtk_frame_new(" Interface size ") ;

  GtkWidget *interface_size_hbox  = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;

  gtk_container_set_border_width(GTK_CONTAINER(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;

  GtkWidget *interface_size_radiobutton_little = gtk_radio_button_new_with_label(NULL, " Little") ;
  GtkWidget *interface_size_radiobutton_middle = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Medium") ;
  GtkWidget *interface_size_radiobutton_big    = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), "  Big  ") ;

  GtkWidget *interface_size_little_image       = gtk_image_new_from_file((settings.path_to_button_icons + "interface-little.png").c_str() ) ;
  GtkWidget *interface_size_middle_image       = gtk_image_new_from_file((settings.path_to_button_icons + "interface-middle.png").c_str() ) ;
  GtkWidget *interface_size_big_image          = gtk_image_new_from_file((settings.path_to_button_icons + "interface-big.png").c_str()    ) ;

  gtk_widget_set_tooltip_markup(interface_size_radiobutton_little, "Set the <b>interface size</b> on <b>little</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
  gtk_widget_set_tooltip_markup(interface_size_radiobutton_middle, "Set the <b>interface size</b> on <b>middle</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
  gtk_widget_set_tooltip_markup(interface_size_radiobutton_big,    "Set the <b>interface size</b> on <b>big</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.")    ;

  gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_little), interface_size_little_image) ;
  gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_middle), interface_size_middle_image) ;
  gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_big),    interface_size_big_image   ) ;

  gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_little), TRUE) ;
  gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_middle), TRUE) ;
  gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_big),    TRUE) ;

  gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), FALSE) ;
  gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), FALSE) ;
  gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big),    FALSE) ;


  switch (settings.image_resized_size) {

    case IMAGE_RESIZED_SIZE_LITTLE :

      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), TRUE) ;
      break ;

    case IMAGE_RESIZED_SIZE_MIDDLE :

      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), TRUE) ;
      break ;

    case IMAGE_RESIZED_SIZE_BIG :

      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big),    TRUE) ;
      break ;

    default :
      break ;
  }


  gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_little, TRUE, TRUE, 0) ;
  gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_middle, TRUE, TRUE, 0) ;
  gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_big,    TRUE, TRUE, 0) ;

  gtk_box_set_homogeneous(GTK_BOX(interface_size_hbox), TRUE) ;

  gtk_box_set_spacing(GTK_BOX(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;

  gtk_container_add(GTK_CONTAINER(interface_size_frame), interface_size_hbox) ;

  /** ***** [END] Interface size setting [END] ***** **/



  /** ***** [START] Music folder setting [START] ***** **/

  GtkWidget *folder_selecting_frame = gtk_frame_new(" Music folder ") ;

  GtkWidget *folder_selecting_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;

  gtk_container_set_border_width(GTK_CONTAINER(folder_selecting_box), DIALOG_DEFAULT_SPACE) ;


  GtkWidget *folder_selecting_button = gtk_file_chooser_button_new("Set the Music folder to open per default.", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ;

  gtk_widget_set_tooltip_markup(folder_selecting_button, "Set the folder to open per default: your <b>default music folder</b>.\n<i>The default folder from the folder selector</i>.\nSet it simply to your <b>Music folder</b>.\nChanges are immediatly applied.\nBut you must press the <b>Apply</b> button to store your configuration.") ;

  gtk_file_chooser_button_set_title(GTK_FILE_CHOOSER_BUTTON(folder_selecting_button), "Set the Music folder to open per default.") ;

  const char *user_music_folder = g_get_user_special_dir(G_USER_DIRECTORY_MUSIC) ;

  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_selecting_button), (g_file_test(settings.path_to_music_folder.c_str(), G_FILE_TEST_IS_DIR)) ? settings.path_to_music_folder.c_str() : (user_music_folder != NULL) ? user_music_folder : g_get_home_dir()  ) ;


  gtk_box_pack_start(GTK_BOX(folder_selecting_box), folder_selecting_button,  TRUE, TRUE, 0)   ;

  gtk_container_add(GTK_CONTAINER(folder_selecting_frame), folder_selecting_box) ;

  /** ***** [END] Music folder setting [END] ***** **/



  /** ***** [START] Dialog main content box [START] ***** **/

  GtkWidget *content_area = gtk_dialog_get_content_area( GTK_DIALOG(configure_dialog) ) ;

  gtk_box_pack_start(GTK_BOX(content_area), icon_set_choice_frame,  FALSE, FALSE, 0) ;
  gtk_box_pack_start(GTK_BOX(content_area), playing_settings_frame, FALSE, FALSE, 0) ;
  gtk_box_pack_start(GTK_BOX(content_area), interface_size_frame,   FALSE, FALSE, 0) ;
  gtk_box_pack_start(GTK_BOX(content_area), folder_selecting_frame, FALSE, FALSE, 0) ;

  gtk_box_set_spacing(GTK_BOX(content_area), DIALOG_DEFAULT_SPACE) ;

  /** ***** [END] Dialog main content box [END] ***** **/



  /** ***** [START] Dialog action buttons [START] ***** **/

  GtkWidget *button_close = gtk_button_new_with_label("Close") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Cancel", GTK_RESPONSE_CANCEL) ;

  GtkWidget *image_close  = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-close.png").c_str()) ;

  gtk_widget_set_tooltip_markup(button_close, "<b>Close</b> the configuration window and don't store any setting.") ;

  gtk_button_set_image(GTK_BUTTON(button_close), image_close) ;

  gtk_button_set_always_show_image(GTK_BUTTON(button_close), TRUE) ;


  GtkWidget *button_ok = gtk_button_new_with_label("Apply") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Apply", GTK_RESPONSE_APPLY) ;

  GtkWidget *image_ok  = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-ok.png").c_str()) ;

  gtk_widget_set_tooltip_markup(button_ok, "<b>Register</b> all the settings as <i>your default configuration</i> at start.") ;

  gtk_button_set_image(GTK_BUTTON(button_ok), image_ok) ;

  gtk_button_set_always_show_image(GTK_BUTTON(button_ok), TRUE) ;


  gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_close, GTK_RESPONSE_CLOSE) ;

  gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_ok,     GTK_RESPONSE_APPLY)  ;

  GtkWidget *action_area = gtk_dialog_get_action_area(GTK_DIALOG(configure_dialog)) ;

  gtk_container_set_border_width(GTK_CONTAINER(action_area), 0) ;

  gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_EDGE) ;

  /** ***** [END] Dialog action buttons [END] ***** **/



  Radio_Config high_contrast_radiobutton ;

  high_contrast_radiobutton.button  = radiobutton_icons_high_contrast ;
  high_contrast_radiobutton.image   = image_icons_high_contrast       ;

  high_contrast_radiobutton.volume  = playing_settings_volume_image       ;
  high_contrast_radiobutton.cancel  = image_close    ;
  high_contrast_radiobutton.apply   = image_ok       ;

  high_contrast_radiobutton.little  = interface_size_little_image ;
  high_contrast_radiobutton.middle  = interface_size_middle_image ;
  high_contrast_radiobutton.big     = interface_size_big_image    ;


  Radio_Config oxygen_radiobutton ;

  oxygen_radiobutton.button  = radiobutton_icons_oxygen ;
  oxygen_radiobutton.image   = image_icons_oxygen       ;

  oxygen_radiobutton.volume  = playing_settings_volume_image       ;
  oxygen_radiobutton.cancel  = image_close    ;
  oxygen_radiobutton.apply   = image_ok       ;

  oxygen_radiobutton.little  = interface_size_little_image ;
  oxygen_radiobutton.middle  = interface_size_middle_image ;
  oxygen_radiobutton.big     = interface_size_big_image    ;

  g_signal_connect(G_OBJECT(radiobutton_icons_high_contrast), "clicked", G_CALLBACK(configure_high_contrast_radiobutton), &high_contrast_radiobutton) ;
  g_signal_connect(G_OBJECT(radiobutton_icons_oxygen),        "clicked", G_CALLBACK(configure_oxygen_radiobutton),        &oxygen_radiobutton       ) ;


  int little = -1 ;
  int middle =  0 ;
  int big    =  1 ;

  g_signal_connect(G_OBJECT(interface_size_radiobutton_little), "clicked",       G_CALLBACK(reconfigure_interface_size), &little) ;
  g_signal_connect(G_OBJECT(interface_size_radiobutton_middle), "clicked",       G_CALLBACK(reconfigure_interface_size), &middle) ;
  g_signal_connect(G_OBJECT(interface_size_radiobutton_big),    "clicked",       G_CALLBACK(reconfigure_interface_size), &big)    ;


  g_signal_connect(G_OBJECT(playing_settings_repeat_all),       "toggled",       G_CALLBACK(repeat_all_feature_set),     NULL)    ;
  g_signal_connect(G_OBJECT(playing_settings_shuffle),          "toggled",       G_CALLBACK(shuffle_feature_set),        NULL)    ;
  g_signal_connect(G_OBJECT(playing_settings_volume_scale),     "value-changed", G_CALLBACK(get_volume),                 NULL)    ;
  g_signal_connect(G_OBJECT(folder_selecting_button),           "file-set",      G_CALLBACK(set_default_folder),         NULL)    ;


  gtk_widget_show_all(configure_dialog) ;



  int response = gtk_dialog_run(GTK_DIALOG(configure_dialog))  ;

  switch (response) {

    case GTK_RESPONSE_APPLY :

      {

        GKeyFile *conf_file = g_key_file_new() ;

        GError *error = NULL ;

        settings.is_repeat_all = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all)) ;

        settings.is_shuffle       = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle))    ;



        // Set configuration settings to configuration file buffer.
        g_key_file_set_string(conf_file,   "Config",  "Buttons_Icons_Path",   settings.path_to_button_icons.c_str()) ;

        g_key_file_set_string(conf_file,   "Config",  "Menu_Icons_Path",      settings.path_to_menu_icons.c_str())   ;

        g_key_file_set_string(conf_file,   "Config",  "Music_Folder",         settings.path_to_music_folder.c_str())   ;

        g_key_file_set_boolean(conf_file,  "Config",  "Is_Oxygen",            settings.icon_set_oxygen) ;
        g_key_file_set_boolean(conf_file,  "Config",  "Repeat_all",           settings.is_repeat_all)  ;
        g_key_file_set_boolean(conf_file,  "Config",  "Shuffle",              settings.is_shuffle) ;

        g_key_file_set_double(conf_file,   "Config",  "Volume",               settings.volume) ;

        g_key_file_set_uint64(conf_file,   "Config",  "Buttons_space",        settings.space_buttons) ;

        g_key_file_set_uint64(conf_file,   "Config",  "Display_Size",         settings.display_size) ;

        g_key_file_set_uint64(conf_file,   "Config",  "Image_Resizing",       settings.image_resized_size) ;

        g_key_file_set_string(conf_file,   "Config",  "Sized_Default_Image",  settings.path_to_default_image.c_str())   ;

        // Write to configuration file
        g_key_file_save_to_file(conf_file, PATH_TO_CONF_FILE, &error);

        // Setting global variables.
        cover_image    = settings.path_to_default_image ;
        current_folder = settings.path_to_music_folder ;

        if ( error != NULL ) {

          display_message_dialog("Error store configuration !", "Cannot store the configuration.") ;

          #ifdef DEBUG
          fprintf(stdout,"\n%s: Error store configuratiom settings.\n", prgname.c_str() )    ; fflush(stdout) ;
          #endif
        }
        else { // Success
          #ifdef DEBUG
          fprintf(stdout,"\n%s: Success store configuratiom settings.\n", prgname.c_str() )  ;
          #endif
        }

      }

      break ;

    case GTK_RESPONSE_CLOSE :
      // Do nothing.
      break ;
  }

  gtk_widget_destroy(configure_dialog) ;

  return ;

}
Exemple #14
0
void get_files_to_play(GtkWidget *widget, gpointer user_data) {

  /** User single file selection. **/

  #ifdef DEBUG
  DEBUG_FUNC_MARK
  #endif

  GtkWidget *file_chooser_dialog = gtk_file_chooser_dialog_new("Choose music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);

  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser_dialog),  current_folder.c_str() ) ;
  gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ;
  gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ;
  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ;
  gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ;


  GtkFileFilter *file_filter = gtk_file_filter_new() ;

  for (int c=0  ; c < static_cast<int>(extension_list.size()) ; c++) {

    gtk_file_filter_add_pattern(GTK_FILE_FILTER(file_filter),  extension_list.at(c).c_str())         ;

  }

  gtk_file_filter_set_name(GTK_FILE_FILTER(file_filter), "Supported music filetypes") ;

  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser_dialog), GTK_FILE_FILTER(file_filter)) ;



  gtk_window_set_position(GTK_WINDOW(file_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
  gtk_widget_set_size_request(file_chooser_dialog,-1,-1) ;
  gtk_window_set_modal(GTK_WINDOW(file_chooser_dialog), TRUE) ;
  gtk_window_set_destroy_with_parent(GTK_WINDOW(file_chooser_dialog), TRUE) ;
  gtk_window_set_type_hint(GTK_WINDOW(file_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ;
  gtk_window_set_transient_for(GTK_WINDOW(file_chooser_dialog), GTK_WINDOW(gui->window)) ;


  GSList *filepath_list = NULL ;

  gint result = gtk_dialog_run (GTK_DIALOG (file_chooser_dialog));

  switch (result) {
     
    case GTK_RESPONSE_CANCEL :
    
     gtk_widget_destroy(file_chooser_dialog);
     return ;

    case GTK_RESPONSE_ACCEPT :
  
      filepath_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser_dialog)) ;
  
      gtk_widget_destroy(file_chooser_dialog) ;

      break ;
  }

  if (filepath_list != NULL) {

    gchar *file_dirname  = g_path_get_dirname((const gchar *) g_slist_nth_data(filepath_list, 0)) ;

    check_files(filepath_list) ;

    current_folder = file_dirname ;

    g_free(file_dirname) ;

    #ifdef DEBUG
    fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ;
    #endif

    g_slist_free(filepath_list) ;

  }

}
Exemple #15
0
static void foldersel_create(void)
{
	GtkWidget *vbox;
	GtkWidget *scrolledwin;
	GtkWidget *confirm_area;
	GtkTreeViewColumn *column;
	GtkCellRenderer *renderer;
	GtkTreeSelection *selection;
	static GdkGeometry geometry;

	window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "foldersel");
	gtk_window_set_title(GTK_WINDOW(window), _("Select folder"));
	gtk_container_set_border_width(GTK_CONTAINER(window), 4);
	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_resizable(GTK_WINDOW(window), TRUE);

	gtk_widget_realize(window);
	g_signal_connect(G_OBJECT(window), "delete_event",
			 G_CALLBACK(delete_event), NULL);
	g_signal_connect(G_OBJECT(window), "key_press_event",
			 G_CALLBACK(key_pressed), NULL);
	g_signal_connect(G_OBJECT(window), "size_allocate",
			 G_CALLBACK(foldersel_size_allocate_cb), NULL);
	MANAGE_WINDOW_SIGNALS_CONNECT(window);

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

	scrolledwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
				       GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
					    GTK_SHADOW_IN);
	gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);

	tree_store = gtk_tree_store_new(N_FOLDERSEL_COLUMNS,
					G_TYPE_STRING,
					G_TYPE_POINTER,
					GDK_TYPE_PIXBUF,
					GDK_TYPE_PIXBUF,
					GDK_TYPE_COLOR,
					G_TYPE_INT);
	gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_store),
					FOLDERSEL_FOLDERNAME,
					foldersel_folder_name_compare,
					NULL, NULL);

	treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));
	g_object_unref(G_OBJECT(tree_store));
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview),
	                             prefs_common.use_stripes_everywhere);
	gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE);
	gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview),
					FOLDERSEL_FOLDERNAME);
	if (prefs_common.folder_search_wildcard)
 		gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview),
 				foldersel_search_name_func, NULL, NULL);

	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
	gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
	gtk_tree_selection_set_select_function(selection, foldersel_selected,
					       NULL, NULL);

	g_signal_connect(G_OBJECT(treeview), "row-activated",
			 G_CALLBACK(foldersel_tree_activated), NULL);
	gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_spacing(column, 2);
	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_attributes
		(column, renderer,
		 "pixbuf", FOLDERSEL_PIXBUF,
		 "pixbuf-expander-open", FOLDERSEL_PIXBUF_OPEN,
		 "pixbuf-expander-closed", FOLDERSEL_PIXBUF,
		 NULL);

	/* create text renderer */
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes
		(column, renderer,
		 "text", FOLDERSEL_FOLDERNAME,
		 "foreground-gdk", FOLDERSEL_FOREGROUND,
		 "weight", FOLDERSEL_BOLD,
		 NULL);
	g_object_set(G_OBJECT(renderer), "weight", PANGO_WEIGHT_BOLD, NULL);
	gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);

	gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);

	entry = gtk_entry_new();
	gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
	gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
	g_signal_connect(G_OBJECT(entry), "activate",
			 G_CALLBACK(foldersel_entry_activated), NULL);

	gtkut_stock_button_set_create(&confirm_area,
				      &new_button,    GTK_STOCK_NEW,
				      &cancel_button, GTK_STOCK_CANCEL,
				      &ok_button,     GTK_STOCK_OK);

	gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
	gtk_widget_grab_default(ok_button);

	g_signal_connect(G_OBJECT(ok_button), "clicked",
			 G_CALLBACK(foldersel_ok), NULL);
	g_signal_connect(G_OBJECT(cancel_button), "clicked",
			 G_CALLBACK(foldersel_cancel), NULL);
	g_signal_connect(G_OBJECT(new_button), "clicked",
			 G_CALLBACK(foldersel_new_folder), NULL);

	if (!geometry.min_height) {
		geometry.min_width = 300;
		geometry.min_height = 360;
	}

	gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
				      GDK_HINT_MIN_SIZE);
	gtk_widget_set_size_request(window, prefs_common.folderselwin_width,
				    prefs_common.folderselwin_height);

	gtk_widget_show_all(vbox);
}
Exemple #16
0
GtkWidget*
create_converterdlg (void)
{
  GtkWidget *converterdlg;
  GtkWidget *dialog_vbox6;
  GtkWidget *hbox105;
  GtkWidget *vbox26;
  GtkWidget *hbox67;
  GtkWidget *label103;
  GtkWidget *hbox68;
  GtkWidget *output_folder;
  GtkWidget *converter_output_browse;
  GtkWidget *write_to_source_folder;
  GtkWidget *preserve_folders;
  GtkWidget *bypass_same_format;
  GtkWidget *retag_after_copy;
  GtkWidget *hbox100;
  GtkWidget *label122;
  GtkWidget *hbox101;
  GtkWidget *output_file;
  GtkWidget *custom6;
  GtkWidget *hbox69;
  GtkWidget *label104;
  GtkWidget *hbox90;
  GtkWidget *encoder;
  GtkWidget *edit_encoder_presets;
  GtkWidget *image469;
  GtkWidget *hbox86;
  GtkWidget *label114;
  GtkWidget *hbox91;
  GtkWidget *dsp_preset;
  GtkWidget *edit_dsp_presets;
  GtkWidget *image470;
  GtkWidget *hbox88;
  GtkWidget *label116;
  GObject *numthreads_adj;
  GtkWidget *numthreads;
  GtkWidget *hbox89;
  GtkWidget *label117;
  GtkWidget *output_format;
  GtkWidget *hbox99;
  GtkWidget *label121;
  GtkWidget *overwrite_action;
  GtkWidget *scrolledwindow9;
  GtkWidget *preview_tree;
  GtkWidget *dialog_action_area5;
  GtkWidget *converter_cancel;
  GtkWidget *converter_ok;

  converterdlg = gtk_dialog_new ();
  gtk_widget_set_size_request (converterdlg, 720, -1);
  gtk_window_set_title (GTK_WINDOW (converterdlg), "Converter");
  gtk_window_set_position (GTK_WINDOW (converterdlg), GTK_WIN_POS_MOUSE);
  gtk_window_set_modal (GTK_WINDOW (converterdlg), TRUE);
  gtk_window_set_destroy_with_parent (GTK_WINDOW (converterdlg), TRUE);
  gtk_window_set_type_hint (GTK_WINDOW (converterdlg), GDK_WINDOW_TYPE_HINT_DIALOG);
  gtk_dialog_set_has_separator (GTK_DIALOG (converterdlg), FALSE);

  dialog_vbox6 = gtk_dialog_get_content_area (GTK_DIALOG (converterdlg));
  gtk_widget_show (dialog_vbox6);

  hbox105 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox105);
  gtk_box_pack_start (GTK_BOX (dialog_vbox6), hbox105, TRUE, TRUE, 0);

  vbox26 = gtk_vbox_new (FALSE, 8);
  gtk_widget_show (vbox26);
  gtk_box_pack_start (GTK_BOX (hbox105), vbox26, FALSE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (vbox26), 12);

  hbox67 = gtk_hbox_new (FALSE, 8);
  gtk_widget_show (hbox67);
  gtk_box_pack_start (GTK_BOX (vbox26), hbox67, FALSE, TRUE, 0);

  label103 = gtk_label_new (_("Output folder:"));
  gtk_widget_show (label103);
  gtk_box_pack_start (GTK_BOX (hbox67), label103, FALSE, FALSE, 0);

  hbox68 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox68);
  gtk_box_pack_start (GTK_BOX (hbox67), hbox68, TRUE, TRUE, 0);

  output_folder = gtk_entry_new ();
  gtk_widget_show (output_folder);
  gtk_box_pack_start (GTK_BOX (hbox68), output_folder, TRUE, TRUE, 0);
  gtk_entry_set_invisible_char (GTK_ENTRY (output_folder), 9679);

  converter_output_browse = gtk_button_new_with_mnemonic ("...");
  gtk_widget_show (converter_output_browse);
  gtk_box_pack_start (GTK_BOX (hbox68), converter_output_browse, FALSE, FALSE, 0);

  write_to_source_folder = gtk_check_button_new_with_mnemonic (_("Write to source track folder"));
  gtk_widget_show (write_to_source_folder);
  gtk_box_pack_start (GTK_BOX (vbox26), write_to_source_folder, FALSE, FALSE, 0);

  preserve_folders = gtk_check_button_new_with_mnemonic (_("Preserve folder structure"));
  gtk_widget_show (preserve_folders);
  gtk_box_pack_start (GTK_BOX (vbox26), preserve_folders, FALSE, FALSE, 0);

  bypass_same_format = gtk_check_button_new_with_mnemonic (_("Copy if the format is not changing"));
  gtk_widget_show (bypass_same_format);
  gtk_box_pack_start (GTK_BOX (vbox26), bypass_same_format, FALSE, FALSE, 0);

  retag_after_copy = gtk_check_button_new_with_mnemonic (_("Re-tag after copy"));
  gtk_widget_show (retag_after_copy);
  gtk_box_pack_start (GTK_BOX (vbox26), retag_after_copy, FALSE, FALSE, 0);

  hbox100 = gtk_hbox_new (FALSE, 8);
  gtk_widget_show (hbox100);
  gtk_box_pack_start (GTK_BOX (vbox26), hbox100, FALSE, TRUE, 0);

  label122 = gtk_label_new (_("Output file name:"));
  gtk_widget_show (label122);
  gtk_box_pack_start (GTK_BOX (hbox100), label122, FALSE, FALSE, 0);

  hbox101 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox101);
  gtk_box_pack_start (GTK_BOX (hbox100), hbox101, TRUE, TRUE, 0);

  output_file = gtk_entry_new ();
  gtk_widget_show (output_file);
  gtk_box_pack_start (GTK_BOX (hbox101), output_file, TRUE, TRUE, 0);
  gtk_widget_set_tooltip_text (output_file, _("Extension (e.g. .mp3) will be appended automatically.\nLeave the field empty for default (%artist% - %title%)."));
  gtk_entry_set_invisible_char (GTK_ENTRY (output_file), 8226);

  custom6 = title_formatting_help_link_create ("custom6", "", "", 0, 0);
  gtk_widget_show (custom6);
  gtk_box_pack_start (GTK_BOX (hbox101), custom6, TRUE, TRUE, 0);
  gtk_widget_set_can_focus(custom6, FALSE);
  gtk_widget_set_can_default(custom6, FALSE);

  hbox69 = gtk_hbox_new (FALSE, 8);
  gtk_widget_show (hbox69);
  gtk_box_pack_start (GTK_BOX (vbox26), hbox69, FALSE, TRUE, 0);

  label104 = gtk_label_new (_("Encoder:"));
  gtk_widget_show (label104);
  gtk_box_pack_start (GTK_BOX (hbox69), label104, FALSE, FALSE, 0);

  hbox90 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox90);
  gtk_box_pack_start (GTK_BOX (hbox69), hbox90, TRUE, TRUE, 0);

  encoder = gtk_combo_box_text_new ();
  gtk_widget_show (encoder);
  gtk_box_pack_start (GTK_BOX (hbox90), encoder, TRUE, TRUE, 0);

  edit_encoder_presets = gtk_button_new ();
  gtk_widget_show (edit_encoder_presets);
  gtk_box_pack_start (GTK_BOX (hbox90), edit_encoder_presets, FALSE, FALSE, 0);

  image469 = gtk_image_new_from_stock ("gtk-edit", GTK_ICON_SIZE_BUTTON);
  gtk_widget_show (image469);
  gtk_container_add (GTK_CONTAINER (edit_encoder_presets), image469);

  hbox86 = gtk_hbox_new (FALSE, 8);
  gtk_widget_show (hbox86);
  gtk_box_pack_start (GTK_BOX (vbox26), hbox86, FALSE, TRUE, 0);

  label114 = gtk_label_new (_("DSP preset:"));
  gtk_widget_show (label114);
  gtk_box_pack_start (GTK_BOX (hbox86), label114, FALSE, FALSE, 0);

  hbox91 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox91);
  gtk_box_pack_start (GTK_BOX (hbox86), hbox91, TRUE, TRUE, 0);

  dsp_preset = gtk_combo_box_text_new ();
  gtk_widget_show (dsp_preset);
  gtk_box_pack_start (GTK_BOX (hbox91), dsp_preset, TRUE, TRUE, 0);

  edit_dsp_presets = gtk_button_new ();
  gtk_widget_show (edit_dsp_presets);
  gtk_box_pack_start (GTK_BOX (hbox91), edit_dsp_presets, FALSE, FALSE, 0);

  image470 = gtk_image_new_from_stock ("gtk-edit", GTK_ICON_SIZE_BUTTON);
  gtk_widget_show (image470);
  gtk_container_add (GTK_CONTAINER (edit_dsp_presets), image470);

  hbox88 = gtk_hbox_new (FALSE, 8);
  gtk_box_pack_start (GTK_BOX (vbox26), hbox88, FALSE, TRUE, 0);

  label116 = gtk_label_new (_("Number of threads:"));
  gtk_widget_show (label116);
  gtk_box_pack_start (GTK_BOX (hbox88), label116, FALSE, FALSE, 0);

  numthreads_adj = G_OBJECT(gtk_adjustment_new (1, 0, 100, 1, 10, 0));
  numthreads = gtk_spin_button_new (GTK_ADJUSTMENT (numthreads_adj), 1, 0);
  gtk_widget_show (numthreads);
  gtk_box_pack_start (GTK_BOX (hbox88), numthreads, TRUE, TRUE, 0);

  hbox89 = gtk_hbox_new (FALSE, 8);
  gtk_widget_show (hbox89);
  gtk_box_pack_start (GTK_BOX (vbox26), hbox89, FALSE, TRUE, 0);

  label117 = gtk_label_new (_("Output sample format:"));
  gtk_widget_show (label117);
  gtk_box_pack_start (GTK_BOX (hbox89), label117, FALSE, FALSE, 0);

  output_format = gtk_combo_box_text_new ();
  gtk_widget_show (output_format);
  gtk_box_pack_start (GTK_BOX (hbox89), output_format, TRUE, TRUE, 0);
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("Keep source format"));
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("8 bit signed int"));
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("16 bit signed int"));
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("24 bit signed int"));
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("32 bit signed int"));
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("32 bit float"));

  hbox99 = gtk_hbox_new (FALSE, 8);
  gtk_widget_show (hbox99);
  gtk_box_pack_start (GTK_BOX (vbox26), hbox99, FALSE, TRUE, 0);

  label121 = gtk_label_new (_("When file exists:"));
  gtk_widget_show (label121);
  gtk_box_pack_start (GTK_BOX (hbox99), label121, FALSE, FALSE, 0);

  overwrite_action = gtk_combo_box_text_new ();
  gtk_widget_show (overwrite_action);
  gtk_box_pack_start (GTK_BOX (hbox99), overwrite_action, TRUE, TRUE, 0);
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Skip"));
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Prompt"));
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Overwrite"));

  scrolledwindow9 = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_show (scrolledwindow9);
  gtk_box_pack_start (GTK_BOX (hbox105), scrolledwindow9, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow9), 12);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow9), GTK_SHADOW_IN);

  preview_tree = gtk_tree_view_new ();
  gtk_widget_show (preview_tree);
  gtk_container_add (GTK_CONTAINER (scrolledwindow9), preview_tree);
  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (preview_tree), TRUE);

  dialog_action_area5 = gtk_dialog_get_action_area (GTK_DIALOG (converterdlg));
  gtk_widget_show (dialog_action_area5);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area5), GTK_BUTTONBOX_END);

  converter_cancel = gtk_button_new_from_stock ("gtk-cancel");
  gtk_widget_show (converter_cancel);
  gtk_dialog_add_action_widget (GTK_DIALOG (converterdlg), converter_cancel, GTK_RESPONSE_CANCEL);
  gtk_widget_set_can_default(converter_cancel, TRUE);

  converter_ok = gtk_button_new_from_stock ("gtk-ok");
  gtk_widget_show (converter_ok);
  gtk_dialog_add_action_widget (GTK_DIALOG (converterdlg), converter_ok, GTK_RESPONSE_OK);
  gtk_widget_set_can_default(converter_ok, TRUE);

  g_signal_connect ((gpointer) output_folder, "changed",
                    G_CALLBACK (on_output_folder_changed),
                    NULL);
  g_signal_connect ((gpointer) converter_output_browse, "clicked",
                    G_CALLBACK (on_converter_output_browse_clicked),
                    NULL);
  g_signal_connect ((gpointer) preserve_folders, "toggled",
                    G_CALLBACK (on_preserve_folders_toggled),
                    NULL);
  g_signal_connect ((gpointer) bypass_same_format, "toggled",
                    G_CALLBACK (on_bypass_same_format_toggled),
                    NULL);
  g_signal_connect ((gpointer) retag_after_copy, "toggled",
                    G_CALLBACK (on_retag_after_copy_toggled),
                    NULL);
  g_signal_connect ((gpointer) encoder, "changed",
                    G_CALLBACK (on_converter_encoder_changed),
                    NULL);
  g_signal_connect ((gpointer) edit_encoder_presets, "clicked",
                    G_CALLBACK (on_edit_encoder_presets_clicked),
                    NULL);
  g_signal_connect ((gpointer) dsp_preset, "changed",
                    G_CALLBACK (on_converter_dsp_preset_changed),
                    NULL);
  g_signal_connect ((gpointer) edit_dsp_presets, "clicked",
                    G_CALLBACK (on_edit_dsp_presets_clicked),
                    NULL);
  g_signal_connect ((gpointer) numthreads, "changed",
                    G_CALLBACK (on_numthreads_changed),
                    NULL);
  g_signal_connect ((gpointer) output_format, "changed",
                    G_CALLBACK (on_converter_output_format_changed),
                    NULL);
  g_signal_connect ((gpointer) overwrite_action, "changed",
                    G_CALLBACK (on_overwrite_action_changed),
                    NULL);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, converterdlg, "converterdlg");
  GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, dialog_vbox6, "dialog_vbox6");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox105, "hbox105");
  GLADE_HOOKUP_OBJECT (converterdlg, vbox26, "vbox26");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox67, "hbox67");
  GLADE_HOOKUP_OBJECT (converterdlg, label103, "label103");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox68, "hbox68");
  GLADE_HOOKUP_OBJECT (converterdlg, output_folder, "output_folder");
  GLADE_HOOKUP_OBJECT (converterdlg, converter_output_browse, "converter_output_browse");
  GLADE_HOOKUP_OBJECT (converterdlg, write_to_source_folder, "write_to_source_folder");
  GLADE_HOOKUP_OBJECT (converterdlg, preserve_folders, "preserve_folders");
  GLADE_HOOKUP_OBJECT (converterdlg, bypass_same_format, "bypass_same_format");
  GLADE_HOOKUP_OBJECT (converterdlg, retag_after_copy, "retag_after_copy");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox100, "hbox100");
  GLADE_HOOKUP_OBJECT (converterdlg, label122, "label122");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox101, "hbox101");
  GLADE_HOOKUP_OBJECT (converterdlg, output_file, "output_file");
  GLADE_HOOKUP_OBJECT (converterdlg, custom6, "custom6");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox69, "hbox69");
  GLADE_HOOKUP_OBJECT (converterdlg, label104, "label104");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox90, "hbox90");
  GLADE_HOOKUP_OBJECT (converterdlg, encoder, "encoder");
  GLADE_HOOKUP_OBJECT (converterdlg, edit_encoder_presets, "edit_encoder_presets");
  GLADE_HOOKUP_OBJECT (converterdlg, image469, "image469");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox86, "hbox86");
  GLADE_HOOKUP_OBJECT (converterdlg, label114, "label114");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox91, "hbox91");
  GLADE_HOOKUP_OBJECT (converterdlg, dsp_preset, "dsp_preset");
  GLADE_HOOKUP_OBJECT (converterdlg, edit_dsp_presets, "edit_dsp_presets");
  GLADE_HOOKUP_OBJECT (converterdlg, image470, "image470");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox88, "hbox88");
  GLADE_HOOKUP_OBJECT (converterdlg, label116, "label116");
  GLADE_HOOKUP_OBJECT (converterdlg, numthreads, "numthreads");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox89, "hbox89");
  GLADE_HOOKUP_OBJECT (converterdlg, label117, "label117");
  GLADE_HOOKUP_OBJECT (converterdlg, output_format, "output_format");
  GLADE_HOOKUP_OBJECT (converterdlg, hbox99, "hbox99");
  GLADE_HOOKUP_OBJECT (converterdlg, label121, "label121");
  GLADE_HOOKUP_OBJECT (converterdlg, overwrite_action, "overwrite_action");
  GLADE_HOOKUP_OBJECT (converterdlg, scrolledwindow9, "scrolledwindow9");
  GLADE_HOOKUP_OBJECT (converterdlg, preview_tree, "preview_tree");
  GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, dialog_action_area5, "dialog_action_area5");
  GLADE_HOOKUP_OBJECT (converterdlg, converter_cancel, "converter_cancel");
  GLADE_HOOKUP_OBJECT (converterdlg, converter_ok, "converter_ok");

  return converterdlg;
}
static void alertpanel_create(const gchar *title,
			      const gchar *message,
			      AlertType    type,
			      AlertValue   default_value,
			      gboolean	   can_disable,
			      const gchar *button1_label,
			      const gchar *button2_label,
			      const gchar *button3_label)
{
	static PangoFontDescription *font_desc;
	GtkWidget *image;
	GtkWidget *label;
	GtkWidget *hbox;
	GtkWidget *vbox;
	GtkWidget *disable_chkbtn;
	GtkWidget *confirm_area;
	GtkWidget *button1;
	GtkWidget *button2;
	GtkWidget *button3;
	const gchar *label2;
	const gchar *label3;

	debug_print(_("Creating alert panel dialog...\n"));

	dialog = gtk_dialog_new();
	gtk_window_set_title(GTK_WINDOW(dialog), title);
	gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
	gtk_window_set_position(GTK_WINDOW(dialog),
				GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
	manage_window_set_transient(GTK_WINDOW(dialog));
	gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
	gtk_widget_realize(dialog);
	g_signal_connect(G_OBJECT(dialog), "delete_event",
			 G_CALLBACK(alertpanel_deleted),
			 (gpointer)G_ALERTCANCEL);
	g_signal_connect(G_OBJECT(dialog), "key_press_event",
			 G_CALLBACK(alertpanel_close),
			 (gpointer)G_ALERTCANCEL);
	g_signal_connect(G_OBJECT(dialog), "focus_out_event",
			 G_CALLBACK(alertpanel_focus_out), NULL);

	/* for title icon, label and message */
	hbox = gtk_hbox_new(FALSE, 12);
	gtk_container_set_border_width(GTK_CONTAINER(hbox), 12);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
			   hbox, FALSE, FALSE, 0);

	/* title icon */
	switch (type) {
	case ALERT_QUESTION:
		image = gtk_image_new_from_stock
			(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
		break;
	case ALERT_WARNING:
		image = gtk_image_new_from_stock
			(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
		break;
	case ALERT_ERROR:
		image = gtk_image_new_from_stock
			(GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG);
		break;
	case ALERT_NOTICE:
	default:
		image = gtk_image_new_from_stock
			(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
		break;
	}
	gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0.0);
	gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);

	/* for title and message */
	vbox = gtk_vbox_new(FALSE, 12);
	gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);

	label = gtk_label_new(title);
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
	if (!font_desc) {
		gint size;

		size = pango_font_description_get_size
			(label->style->font_desc);
		font_desc = pango_font_description_new();
		pango_font_description_set_weight
			(font_desc, PANGO_WEIGHT_BOLD);
		pango_font_description_set_size
			(font_desc, size * PANGO_SCALE_LARGE);
	}
	if (font_desc)
		gtk_widget_modify_font(label, font_desc);

	/* message label */
	label = gtk_label_new(message);
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
	gtk_label_set_selectable(GTK_LABEL(label), TRUE);
	GTK_WIDGET_UNSET_FLAGS(label, GTK_CAN_FOCUS);
#ifdef G_OS_WIN32
	{
		GtkStyle *style;
		style = gtk_widget_get_style(dialog);
		gtk_widget_modify_base(label, GTK_STATE_ACTIVE,
				       &style->base[GTK_STATE_SELECTED]);
		gtk_widget_modify_text(label, GTK_STATE_ACTIVE,
				       &style->text[GTK_STATE_SELECTED]);
	}
#endif

	if (can_disable) {
		hbox = gtk_hbox_new(FALSE, 0);
		gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
				   FALSE, FALSE, 0);

		disable_chkbtn = gtk_check_button_new_with_label
			(_("Show this message next time"));
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(disable_chkbtn),
					     TRUE);
		gtk_box_pack_start(GTK_BOX(hbox), disable_chkbtn,
				   FALSE, FALSE, 12);
		g_signal_connect(G_OBJECT(disable_chkbtn), "toggled",
				 G_CALLBACK(alertpanel_button_toggled),
				 GUINT_TO_POINTER(G_ALERTDISABLE));
	}

	/* for button(s) */
	if (!button1_label)
		button1_label = GTK_STOCK_OK;
	label2 = button2_label;
	label3 = button3_label;
	if (label2 && *label2 == '+') label2++;
	if (label3 && *label3 == '+') label3++;

	gtkut_stock_button_set_create(&confirm_area,
				      &button1, button1_label,
				      button2_label ? &button2 : NULL, label2,
				      button3_label ? &button3 : NULL, label3);

	gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area),
			 confirm_area, FALSE, FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
	gtk_widget_grab_default(button1);
	gtk_widget_grab_focus(button1);
	if (button2_label &&
	    (default_value == G_ALERTALTERNATE || *button2_label == '+')) {
		gtk_widget_grab_default(button2);
		gtk_widget_grab_focus(button2);
	}
	if (button3_label &&
	    (default_value == G_ALERTOTHER || *button3_label == '+')) {
		gtk_widget_grab_default(button3);
		gtk_widget_grab_focus(button3);
	}

	g_signal_connect(G_OBJECT(button1), "clicked",
			 G_CALLBACK(alertpanel_button_clicked),
			 GUINT_TO_POINTER(G_ALERTDEFAULT));
	if (button2_label)
		g_signal_connect(G_OBJECT(button2), "clicked",
				 G_CALLBACK(alertpanel_button_clicked),
				 GUINT_TO_POINTER(G_ALERTALTERNATE));
	if (button3_label)
		g_signal_connect(G_OBJECT(button3), "clicked",
				 G_CALLBACK(alertpanel_button_clicked),
				 GUINT_TO_POINTER(G_ALERTOTHER));

	gtk_widget_show_all(dialog);
}
Exemple #18
0
int l_klient_imp(const char *imaf,
GtkWidget *wpredok)
{
char strsql[500];
iceb_u_spisok repl_s;
class l_klient_imp_data data;

data.imafz.new_plus(imaf);

data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW  (data.window),400,-1);
sprintf(strsql,"%s %s",name_system,gettext("Импорт карточек из файла"));

gtk_window_set_title(GTK_WINDOW(data.window),strsql);

gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_klient_imp_key_press),&data);

if(wpredok != NULL)
 {
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
  //Удерживать окно над породившем его окном всегда
  gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
  //Закрыть окно если окно предок удалено
  gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
 }

GtkWidget *vbox=gtk_vbox_new(FALSE, 2);

gtk_container_add(GTK_CONTAINER(data.window), vbox);

data.label=gtk_label_new(gettext("Ждите !!!"));

gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);

GtkWidget *label=NULL;

label=gtk_label_new(gettext("Импорт карточек из файла"));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);

data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),450,300);

gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
//PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 12");
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);

data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));

GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
//gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);

data.bar=gtk_progress_bar_new();

gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);

gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);

gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);



sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(l_klient_imp_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);

gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна

gtk_widget_show_all(data.window);


//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна

//gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна

gtk_idle_add((GtkFunction)l_klient_imp1,&data);

gtk_main();

if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

return(data.voz);
}
Exemple #19
0
static void
panel_start_gui(panel *p)
{
    ENTER;

    // main toplevel window
    p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0);
    g_signal_connect(G_OBJECT(p->topgwin), "destroy-event",
        (GCallback) panel_destroy_event, p);
    g_signal_connect(G_OBJECT(p->topgwin), "size-request",
        (GCallback) panel_size_req, p);
    g_signal_connect(G_OBJECT(p->topgwin), "size-allocate",
        (GCallback) panel_size_alloc, p);
    g_signal_connect(G_OBJECT(p->topgwin), "map-event",
        (GCallback) panel_mapped, p);
    g_signal_connect(G_OBJECT(p->topgwin), "configure-event",
        (GCallback) panel_configure_event, p);
    g_signal_connect(G_OBJECT(p->topgwin), "button-press-event",
        (GCallback) panel_button_press_event, p);
    g_signal_connect(G_OBJECT(p->topgwin), "scroll-event",
        (GCallback) panel_scroll_event, p);

    gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE);
    gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "fbpanel");
    gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel");
    gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_NONE);
    gtk_window_set_decorated(GTK_WINDOW(p->topgwin), FALSE);
    gtk_window_set_accept_focus(GTK_WINDOW(p->topgwin), FALSE);
    if (p->setdocktype)
        gtk_window_set_type_hint(GTK_WINDOW(p->topgwin),
            GDK_WINDOW_TYPE_HINT_DOCK);

    if (p->layer == LAYER_ABOVE)
        gtk_window_set_keep_above(GTK_WINDOW(p->topgwin), TRUE);
    else if (p->layer == LAYER_BELOW)
        gtk_window_set_keep_below(GTK_WINDOW(p->topgwin), TRUE);
    gtk_window_stick(GTK_WINDOW(p->topgwin));

    gtk_widget_realize(p->topgwin);
    p->topxwin = GDK_WINDOW_XWINDOW(p->topgwin->window);
    DBG("topxwin = %lx\n", p->topxwin);
    /* ensure configure event */
    XMoveWindow(GDK_DISPLAY(), p->topxwin, 20, 20);
    XSync(GDK_DISPLAY(), False);

    gtk_widget_set_app_paintable(p->topgwin, TRUE);
    calculate_position(p);
    gtk_window_move(GTK_WINDOW(p->topgwin), p->ax, p->ay);
    gtk_window_resize(GTK_WINDOW(p->topgwin), p->aw, p->ah);
    DBG("move-resize x %d y %d w %d h %d\n", p->ax, p->ay, p->aw, p->ah);
    //XSync(GDK_DISPLAY(), False);
    //gdk_flush();

    // background box all over toplevel
    p->bbox = gtk_bgbox_new();
    gtk_container_add(GTK_CONTAINER(p->topgwin), p->bbox);
    gtk_container_set_border_width(GTK_CONTAINER(p->bbox), 0);
    if (p->transparent) {
        p->bg = fb_bg_get_for_display();
        gtk_bgbox_set_background(p->bbox, BG_ROOT, p->tintcolor, p->alpha);
    }

    // main layout manager as a single child of background widget box
    p->lbox = p->my_box_new(FALSE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0);
    gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox);

    p->box = p->my_box_new(FALSE, p->spacing);
    gtk_container_set_border_width(GTK_CONTAINER(p->box), 0);
    gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE,
        (p->round_corners) ? p->round_corners_radius : 0);
    if (p->round_corners) {
        DBG("make_round_corners\n");
        make_round_corners(p);
    }
    /* start window creation process */
    gtk_widget_show_all(p->topgwin);
    /* .. and hide it from user until everything is done */
    gtk_widget_hide(p->topgwin);

    p->menu = panel_make_menu(p);

    if (p->setstrut)
        panel_set_wm_strut(p);

    XSelectInput(GDK_DISPLAY(), GDK_ROOT_WINDOW(), PropertyChangeMask);
    gdk_window_add_filter(gdk_get_default_root_window(),
          (GdkFilterFunc)panel_event_filter, p);
    //XSync(GDK_DISPLAY(), False);
    gdk_flush();
    RET();
}
Exemple #20
0
GtkWidget* dialogGameFinderCreate(bool useTrack, char *title) {
  GtkWidget *dialogGameFinder;
  GtkWidget *vbox1;
  GtkWidget *hbox1;
  GtkWidget *vbox2;
  GtkWidget *frame1;
  GtkWidget *table2;
  GtkWidget *label4;
  GtkWidget *label3;
  GtkWidget *label2;
  GtkWidget *label5;
  GtkWidget *label6;
  GtkWidget *label7;
  GtkWidget *label8;
  GtkWidget *label9;
  GtkWidget *label11;
  GtkWidget *label10;
  GtkWidget *label25;
  GtkWidget *table1;
  GtkWidget *label13;
  GtkWidget *label14;
  GtkWidget *label12;

  useTracker = useTrack;

  dialogGameFinder = gtk_window_new (GTK_WINDOW_DIALOG);
  gtk_object_set_data (GTK_OBJECT (dialogGameFinder), "dialogGameFinder", dialogGameFinder);
  gtk_container_set_border_width (GTK_CONTAINER (dialogGameFinder), 15);
  gtk_window_set_title (GTK_WINDOW (dialogGameFinder), title);
  gtk_window_set_modal (GTK_WINDOW (dialogGameFinder), TRUE);
  gtk_window_set_position (GTK_WINDOW (dialogGameFinder), GTK_WIN_POS_CENTER);
  gtk_window_set_policy (GTK_WINDOW (dialogGameFinder), FALSE, FALSE, FALSE);
  vbox1 = gtk_vbox_new (FALSE, 0);
  gtk_widget_ref (vbox1);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "vbox1", vbox1,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (vbox1);
  gtk_container_add (GTK_CONTAINER (dialogGameFinder), vbox1);

  hbox1 = gtk_hbox_new (FALSE, 0);
  gtk_widget_ref (hbox1);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "hbox1", hbox1,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (hbox1);
  gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);

  list1 = gtk_list_new ();
  gtk_widget_ref (list1);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "list1", list1,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (list1);
  gtk_box_pack_start (GTK_BOX (hbox1), list1, TRUE, TRUE, 10);

  vbox2 = gtk_vbox_new (FALSE, 0);
  gtk_widget_ref (vbox2);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "vbox2", vbox2,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (vbox2);
  gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);

  frame1 = gtk_frame_new ("Selected Game Information");
  gtk_widget_ref (frame1);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "frame1", frame1,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (frame1);
  gtk_box_pack_start (GTK_BOX (vbox2), frame1, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (frame1), 7);

  table2 = gtk_table_new (11, 2, FALSE);
  gtk_widget_ref (table2);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "table2", table2,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (table2);
  gtk_container_add (GTK_CONTAINER (frame1), table2);
  gtk_container_set_border_width (GTK_CONTAINER (table2), 7);

  label4 = gtk_label_new ("Version: ");
  gtk_widget_ref (label4);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label4", label4,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label4);
  gtk_table_attach (GTK_TABLE (table2), label4, 0, 1, 3, 4,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (label4), 1, 0.5);

  label3 = gtk_label_new ("Server Port: ");
  gtk_widget_ref (label3);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label3", label3,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label3);
  gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 1, 2,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (label3), 1, 0.5);

  label2 = gtk_label_new ("Server Address: ");
  gtk_widget_ref (label2);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label2", label2,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label2);
  gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (label2), 1, 0.5);

  label5 = gtk_label_new ("Number of Players:");
  gtk_widget_ref (label5);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label5", label5,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label5);
  gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 4, 5,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (label5), 0.5, 1);

  label6 = gtk_label_new ("Game Type: ");
  gtk_widget_ref (label6);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label6", label6,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label6);
  gtk_table_attach (GTK_TABLE (table2), label6, 0, 1, 5, 6,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (label6), 1, 0.5);

  label7 = gtk_label_new ("No of free Bases: ");
  gtk_widget_ref (label7);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label7", label7,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label7);
  gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 6, 7,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label7), 1, 0.5);

  label8 = gtk_label_new ("No of free Pillboxes: ");
  gtk_widget_ref (label8);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label8", label8,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label8);
  gtk_table_attach (GTK_TABLE (table2), label8, 0, 1, 7, 8,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label8), 1, 0.5);

  label9 = gtk_label_new ("Hidden Mines: ");
  gtk_widget_ref (label9);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label9", label9,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label9);
  gtk_table_attach (GTK_TABLE (table2), label9, 0, 1, 8, 9,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label9), 1, 0.5);

  label11 = gtk_label_new ("Brains: ");
  gtk_widget_ref (label11);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label11", label11,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label11);
  gtk_table_attach (GTK_TABLE (table2), label11, 0, 1, 10, 11,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label11), 1, 0.5);

  label10 = gtk_label_new ("Password: "******"label10", label10,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label10);
  gtk_table_attach (GTK_TABLE (table2), label10, 0, 1, 9, 10,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (label10), 1, 0.5);

  idc_address = gtk_label_new ("");
  gtk_widget_ref (idc_address);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_address", idc_address,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_address);
  gtk_table_attach (GTK_TABLE (table2), idc_address, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (idc_address), GTK_JUSTIFY_LEFT);

  idc_gamefindport = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindport);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindport", idc_gamefindport,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindport);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindport, 1, 2, 1, 2,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  idc_gamefindversion = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindversion);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindversion", idc_gamefindversion,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindversion);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindversion, 1, 2, 3, 4,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  idc_gamefindnumplayers = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindnumplayers);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindnumplayers", idc_gamefindnumplayers,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindnumplayers);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindnumplayers, 1, 2, 4, 5,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  idc_gamefindtype = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindtype);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindtype", idc_gamefindtype,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindtype);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindtype, 1, 2, 5, 6,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  idc_gamefindbases = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindbases);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindbases", idc_gamefindbases,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindbases);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindbases, 1, 2, 6, 7,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (idc_gamefindbases), GTK_JUSTIFY_LEFT);

  idc_gamefindpills = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindpills);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindpills", idc_gamefindpills,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindpills);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindpills, 1, 2, 7, 8,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (idc_gamefindpills), GTK_JUSTIFY_LEFT);

  idc_gamefindmines = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindmines);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindmines", idc_gamefindmines,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindmines);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindmines, 1, 2, 8, 9,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (idc_gamefindmines), GTK_JUSTIFY_LEFT);

  idc_gamefindpass = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindpass);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindpass", idc_gamefindpass,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindpass);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindpass, 1, 2, 9, 10,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (idc_gamefindpass), GTK_JUSTIFY_LEFT);

  idc_gamefindbrains = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindbrains);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindbrains", idc_gamefindbrains,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindbrains);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindbrains, 1, 2, 10, 11,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (idc_gamefindbrains), GTK_JUSTIFY_LEFT);

  label25 = gtk_label_new ("Map Name: ");
  gtk_widget_ref (label25);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label25", label25,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label25);
  gtk_table_attach (GTK_TABLE (table2), label25, 0, 1, 2, 3,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label25), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (label25), 1, 0.5);

  idc_gamefindmapname = gtk_label_new ("");
  gtk_widget_ref (idc_gamefindmapname);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindmapname", idc_gamefindmapname,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindmapname);
  gtk_table_attach (GTK_TABLE (table2), idc_gamefindmapname, 1, 2, 2, 3,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  idc_gamefindstatus = gtk_label_new ("Status: Idle");
  gtk_widget_ref (idc_gamefindstatus);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindstatus", idc_gamefindstatus,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindstatus);
  gtk_box_pack_start (GTK_BOX (vbox2), idc_gamefindstatus, FALSE, TRUE, 3);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindstatus), 0.04, 0.5);

  table1 = gtk_table_new (3, 4, FALSE);
  gtk_widget_ref (table1);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "table1", table1,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (table1);
  gtk_box_pack_start (GTK_BOX (vbox1), table1, TRUE, TRUE, 15);

  button2 = gtk_button_new_with_label ("Join by Address");
  gtk_widget_ref (button2);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "button2", button2,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (button2);
  gtk_table_attach (GTK_TABLE (table1), button2, 2, 3, 0, 1,
                    (GtkAttachOptions) (0),
                    (GtkAttachOptions) (0), 0, 0);

  button1 = gtk_button_new_with_label ("Tracker Setup");
  gtk_widget_ref (button1);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "button1", button1,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (button1);
  gtk_table_attach (GTK_TABLE (table1), button1, 0, 1, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  button8 = gtk_button_new_with_label ("Set Player Name");
  gtk_widget_ref (button8);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "button8", button8,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (button8);
  gtk_table_attach (GTK_TABLE (table1), button8, 0, 1, 1, 2,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  button9 = gtk_button_new_with_label ("Message of the Day");
  gtk_widget_ref (button9);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "button9", button9,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (button9);
  gtk_table_attach (GTK_TABLE (table1), button9, 0, 1, 2, 3,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  button4 = gtk_button_new_with_label ("Refresh");
  gtk_widget_ref (button4);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "button4", button4,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (button4);
  gtk_table_attach (GTK_TABLE (table1), button4, 2, 3, 1, 2,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  button6 = gtk_button_new_with_label ("New");
  gtk_widget_ref (button6);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "button6", button6,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (button6);
  gtk_table_attach (GTK_TABLE (table1), button6, 2, 3, 2, 3,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  idc_gamefindjoin = gtk_button_new_with_label ("Join");
  gtk_widget_ref (idc_gamefindjoin);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindjoin", idc_gamefindjoin,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindjoin);
  gtk_table_attach (GTK_TABLE (table1), idc_gamefindjoin, 3, 4, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_widget_set_sensitive (idc_gamefindjoin, FALSE);

  idc_gamefindrejoin = gtk_button_new_with_label ("Rejoin");
  gtk_widget_ref (idc_gamefindrejoin);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "idc_gamefindrejoin", idc_gamefindrejoin,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (idc_gamefindrejoin);
  gtk_table_attach (GTK_TABLE (table1), idc_gamefindrejoin, 3, 4, 1, 2,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_widget_set_sensitive (idc_gamefindrejoin, FALSE);

  button7 = gtk_button_new_with_label ("Cancel");
  gtk_widget_ref (button7);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "button7", button7,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (button7);
  gtk_table_attach (GTK_TABLE (table1), button7, 3, 4, 2, 3,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  label13 = gtk_label_new ("");
  gtk_widget_ref (label13);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label13", label13,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label13);
  gtk_table_attach (GTK_TABLE (table1), label13, 1, 2, 1, 2,
                    (GtkAttachOptions) (0),
                    (GtkAttachOptions) (0), 0, 0);

  label14 = gtk_label_new ("");
  gtk_widget_ref (label14);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label14", label14,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label14);
  gtk_table_attach (GTK_TABLE (table1), label14, 1, 2, 2, 3,
                    (GtkAttachOptions) (0),
                    (GtkAttachOptions) (0), 0, 0);

  label12 = gtk_label_new ("                                                            ");
  gtk_widget_ref (label12);
  gtk_object_set_data_full (GTK_OBJECT (dialogGameFinder), "label12", label12,
                            (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (label12);
  gtk_table_attach (GTK_TABLE (table1), label12, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  /* Signals */
//  gtk_signal_connect (GTK_OBJECT(list1), "select", GTK_SIGNAL_FUNC(dialogGameFinderSelect), NULL);
  gtk_signal_connect(GTK_OBJECT(dialogGameFinder), "show", GTK_SIGNAL_FUNC(dialogGameFinderShow), 0);
  gtk_signal_connect(GTK_OBJECT(button1), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderTracker), 0);
  gtk_signal_connect(GTK_OBJECT(button8), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderSetName), 0);
   gtk_signal_connect(GTK_OBJECT(button4), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderRefresh), 0);
  gtk_signal_connect(GTK_OBJECT(button7), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderCancel), 0);
  gtk_signal_connect(GTK_OBJECT(button9), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderMOTD), 0);
  gtk_signal_connect(GTK_OBJECT(dialogGameFinder), "delete_event", GTK_SIGNAL_FUNC(dialogGameFinderCancel), 0);
  gtk_signal_connect(GTK_OBJECT(idc_gamefindrejoin), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderReJoin), 0);
  gtk_signal_connect(GTK_OBJECT(idc_gamefindjoin), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderJoin), 0);
  gtk_signal_connect(GTK_OBJECT(button2), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderJoinByAddress), 0);
  gtk_signal_connect(GTK_OBJECT(button6), "clicked", GTK_SIGNAL_FUNC(dialogGameFinderNew), 0);
  /* My Stuff */
  cg = currentGamesCreate();
  if (useTracker == TRUE) {
    strcpy(motd, langGetText(STR_DLGGAMEFINDER_REFRESHFIRST));
  } else {
    gtk_widget_set_sensitive (button1, FALSE);
    gtk_widget_set_sensitive (button9, FALSE);
  }

  dialogGameFindUs = dialogGameFinder;
  gtk_misc_set_alignment (GTK_MISC (idc_address), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindport), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindversion), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindnumplayers), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindtype), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindbases), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindmines), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindmapname), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindpills), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindpass), 0, 0.5);
  gtk_misc_set_alignment (GTK_MISC (idc_gamefindbrains), 0, 0.5);

  return dialogGameFinder;
}
Exemple #21
0
static GtkWidget *create_dialog(void)
{
	GtkWidget *dialog;
	GtkWidget *header_image;
	GtkWidget *header_label;
	GtkWidget *label_info;
	GtkWidget *codename_label;
	GtkWidget *builddate_label;
	GtkWidget *url_button;
	GtkWidget *cop_label;
	GtkWidget *label;
	GtkWidget *license_textview;
	GtkWidget *notebook;
	GtkWidget *box;
	GtkWidget *credits_scrollwin;
	GtkWidget *table;
	GtkWidget *license_scrollwin;
	GtkWidget *info_box;
	GtkWidget *header_hbox;
	GtkWidget *header_eventbox;
	GdkPixbuf *icon;
	GtkTextBuffer* tb;
	gchar *license_text = NULL;
	gchar buffer[512];
	gchar buffer2[128];
	guint i, row = 0;

	dialog = gtk_dialog_new();

	/* configure dialog */
	gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
	gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
	gtk_widget_set_name(dialog, "GeanyDialog");
	gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
	gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
	g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);

	/* create header */
	header_eventbox = gtk_event_box_new();
	gtk_widget_show(header_eventbox);
	header_hbox = gtk_hbox_new(FALSE, 12);
	gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
	gtk_widget_show(header_hbox);
	gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
	header_image = gtk_image_new();
	gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
	header_label = gtk_label_new(NULL);
	gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
	/* print the subversion revision generated by ./configure if it is available */
	g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
	gtk_label_set_markup(GTK_LABEL(header_label), buffer);
	gtk_widget_show(header_label);
	gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
	header_eventbox_style_set(header_eventbox);
	header_label_style_set(header_label);
	g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
	g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0);

	/* set image */
	icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO);
	gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon);
	gtk_window_set_icon(GTK_WINDOW(dialog), icon);
	g_object_unref(icon);	/* free our reference */

	/* create notebook */
	notebook = gtk_notebook_new();
	gtk_widget_show(notebook);
	gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);

	/* create "Info" tab */
	info_box = gtk_vbox_new(FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
	gtk_widget_show(info_box);

	label_info = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
	g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
	gtk_label_set_markup(GTK_LABEL(label_info), buffer);
	gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
	gtk_widget_show(label_info);
	gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);

	/* Codename label */
	codename_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
	gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
	gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
	gtk_widget_show(codename_label);
	gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);

	/* build date label */
	builddate_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
	g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);
	g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
	gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
	gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
	gtk_widget_show(builddate_label);
	gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);

	box = gtk_hbutton_box_new();
	url_button = gtk_button_new();
	gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
	g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
	label = gtk_label_new(NULL);
	gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
	gtk_widget_show(label);
	gtk_container_add(GTK_CONTAINER(url_button), label);
	gtk_widget_show(url_button);
	gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
	gtk_widget_show(box);
	gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);

	/* copyright label */
	cop_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
	gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
	gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
	gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
	gtk_widget_show(cop_label);
	gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
	/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */

	label = gtk_label_new(_("Info"));
	gtk_widget_show(label);
	gtk_widget_show_all(info_box);
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);

	/* create "Credits" tab */
	credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 10);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
		GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

	table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
	gtk_table_set_col_spacings(GTK_TABLE(table), 10);

	row = 0;
	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	for (i = 0; i < translators_len; i++)
	{
		ROW(translators[i][0], row, 0, 1, 4, 0);
		ROW(translators[i][1], row, 1, 0, 4, 0);
		row++;
	}

	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	for (i = 0; i < prev_translators_len; i++)
	{
		ROW(prev_translators[i][0], row, 0, 1, 4, 0);
		ROW(prev_translators[i][1], row, 1, 0, 4, 0);
		row++;
	}


	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
			"Thanks.txt"
#else
			"THANKS"
#endif
		);
	label = geany_wrap_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	label = geany_wrap_label_new(contributors);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
	gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
	gtk_widget_show_all(table);
	label = gtk_label_new(_("Credits"));
	gtk_widget_show(label);
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);

	/* create "License" tab */
	license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	license_textview = gtk_text_view_new();
	gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
	gtk_widget_show(license_textview);
	gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
	label = gtk_label_new(_("License"));
	gtk_widget_show(label);

	g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);

	g_file_get_contents(buffer, &license_text, NULL, NULL);
	if (license_text == NULL)
	{
		license_text = g_strdup(
			_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
	}
	tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
	gtk_text_buffer_set_text(tb, license_text, -1);

	g_free(license_text);

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

	gtk_widget_show_all(dialog);
	return dialog;
}
Exemple #22
0
int   l_mater1(iceb_u_str *kod,iceb_u_str *naim,
int skl_poi, // склад
const char *grup,
int metka_skl, //0-все 1-только материалы карточки которых есть на складе
int metka_cen, //0-с нулевой ценой не выбирать 1-выбирать с любой ценой
GtkWidget *wpredok)
{
printf("l_mater1-%s\n",naim->ravno());

class mater1_data data;
char bros[512];
GdkColor color;

data.poisk.clear_zero();

data.skl_poi=skl_poi;
data.metka_skl=metka_skl;
data.poisk.grupa.new_plus(grup);
data.metka_cen=metka_cen;

if(naim->getdlinna() > 1)
 {
  data.poisk.metka_poi=1;
  data.poisk.naim.new_plus(naim->ravno());
 }
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);

//gtk_window_set_default_size (GTK_WINDOW  (data.window),400,-1);
//gdk_color_parse("black",&color);
//gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color);


sprintf(bros,"%s %s",name_system,gettext("Список материаллов"));

gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);

gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);


if(wpredok != NULL)
 {
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
  //Удерживать окно над породившем его окном всегда
  gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
  //Закрыть окно если окно предок удалено
  gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
 }

gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(mater1_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);

GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);

GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);

gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);

data.label_kolstr=gtk_label_new (gettext("Список материалов"));
//gdk_color_parse("green",&color);
//gtk_widget_modify_fg(data.label_kolstr,GTK_STATE_NORMAL,&color);


gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);

gtk_widget_show(vbox1);
gtk_widget_show(vbox2);

data.label_sklad=gtk_label_new ("");
data.label_poisk=gtk_label_new ("");
gdk_color_parse("red",&color);
gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color);
gtk_widget_modify_fg(data.label_sklad,GTK_STATE_NORMAL,&color);

gtk_box_pack_start (GTK_BOX (vbox2),data.label_sklad,FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0);

data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300);

gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);

//Кнопки
GtkTooltips *tooltips[KOL_F_KL];

sprintf(bros,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(mater1_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);


sprintf(bros,"F4 %s",gettext("Поиск"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(mater1_knopka),&data);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_widget_show(data.knopka[FK4]);

sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(mater1_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);


sprintf(bros,"F7 %s",gettext("Остаток"));
data.knopka[FK7]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK7],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK7]), "clicked",GTK_SIGNAL_FUNC(mater1_knopka),&data);
tooltips[FK7]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK7],data.knopka[FK7],gettext("Включить/выключить показ записей с остатками"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK7]),(gpointer)FK7);
gtk_widget_show(data.knopka[FK7]);


sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(mater1_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);


gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));


mater1_create_list(&data);

gtk_widget_grab_focus(data.knopka[FK10]);
gtk_widget_show(data.window);

// gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));


gtk_main();

if(data.metka_voz == 0 )
 {
  kod->new_plus(data.kodv.ravno());
  naim->new_plus(data.naimv.ravno());
 }

printf("l_mater1 end\n");
if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

return(data.metka_voz);

}
Exemple #23
0
GtkWidget *createMainWindow( void )
{
  GtkWidget *app;//!< Main container
  GtkWidget *buttonCalc, *buttonClose; 
  GtkWidget *labelHeader;
  GtkWidget *label;
  GtkWidget *boxResistors, *boxConnType;
  GtkWidget *hbox, *vbox;

  // Create new Gnome application
  app = gnome_app_new("gnome1","Menus, menus, menus");

  // Set window properties
  gtk_window_set_title(GTK_WINDOW(app), "Den mest fantastiska elektronikkalkylatorn");
  gtk_window_set_position(GTK_WINDOW(app), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(app), 300, 200);
  gnome_app_create_menus( GNOME_APP(app), menubar);

  // Labels
  labelHeader = gtk_label_new("Räkna ut resistansen v1.0");
  label       = gtk_label_new("Typ av koppling:");

  // Entry
  entryNr = gtk_spin_button_new_with_range(1,3,1);
  entryV  = gtk_spin_button_new_with_range(56.34,10000,0.01);
  entryR1 = gtk_spin_button_new_with_range(1234.5 ,1000000000,0.1);
  entryR2 = gtk_spin_button_new_with_range(4321.0,1000000000,0.1);
  entryR3 = gtk_spin_button_new_with_range(5555.5,1000000000,0.1);
  
  // Buttons
  buttonCalc    = gtk_button_new_with_label("Räkna ut");
  buttonClose   = gtk_button_new_with_label("Avsluta");
  radioSerial   = gtk_radio_button_new(NULL);
  radioParalell = gtk_radio_button_new_from_widget( GTK_RADIO_BUTTON( radioSerial ));

  // Set callback functions
  g_signal_connect( GTK_OBJECT (app), "destroy", GTK_SIGNAL_FUNC (closeApp), NULL );
  g_signal_connect( GTK_OBJECT (buttonCalc), "clicked", GTK_SIGNAL_FUNC (buttonClicked), NULL );
  g_signal_connect( GTK_OBJECT (buttonClose), "clicked", GTK_SIGNAL_FUNC (closeApp), NULL );

  // Boxes
  boxResistors = gtk_vbox_new(FALSE, 5);
  boxConnType = gtk_vbox_new(TRUE, 5);
  hbox = gtk_hbox_new(TRUE, 5);
  vbox = gtk_vbox_new(FALSE, 10);

  // Packing boxes and adding labels
  gtk_box_pack_start(GTK_BOX(boxConnType), label, TRUE, FALSE, 5);
  addWidgetWithLabel( GTK_CONTAINER( boxConnType ), "Seriell", radioSerial );
  addWidgetWithLabel( GTK_CONTAINER( boxConnType ), "Parallell", radioParalell );
  addWidgetWithLabel( GTK_CONTAINER( boxConnType ), "Spänning (V):", entryV );
  gtk_box_pack_start(GTK_BOX(boxConnType), buttonClose, TRUE, FALSE, 5);

  addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Antal resistorer:", entryNr);
  addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Resistor #1:", entryR1);
  addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Resistor #2:", entryR2);
  addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Resistor #3:", entryR3);

  gtk_box_pack_start(GTK_BOX(boxResistors), buttonCalc, TRUE, FALSE, 5);
  
  gtk_box_pack_start(GTK_BOX(hbox), boxConnType, FALSE, FALSE, 5);
  gtk_box_pack_start(GTK_BOX(hbox), boxResistors, FALSE, FALSE, 5);

  // Add containers to gnome application
  gnome_app_set_contents( GNOME_APP(app), hbox);

  // Return Gnome app
  return app;
}
PrintProjectDialog::PrintProjectDialog(int dummy)
{
  extern Settings *settings;

  Shortcuts shortcuts(0);

  printprojectdialog = gtk_dialog_new();
  gtk_window_set_title(GTK_WINDOW(printprojectdialog), _("Print project"));
  gtk_window_set_position(GTK_WINDOW(printprojectdialog), GTK_WIN_POS_CENTER_ON_PARENT);
  gtk_window_set_modal(GTK_WINDOW(printprojectdialog), TRUE);
  gtk_window_set_destroy_with_parent(GTK_WINDOW(printprojectdialog), TRUE);
  gtk_window_set_type_hint(GTK_WINDOW(printprojectdialog), GDK_WINDOW_TYPE_HINT_DIALOG);

  dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(printprojectdialog));
  gtk_widget_show(dialog_vbox1);

  vbox1 = gtk_vbox_new(FALSE, 2);
  gtk_widget_show(vbox1);
  gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0);

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

  label1 = gtk_label_new(_("Portion:"));
  gtk_widget_show(label1);
  gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0);

  label_portion = gtk_label_new("");
  gtk_widget_show(label_portion);
  gtk_box_pack_start(GTK_BOX(hbox1), label_portion, FALSE, FALSE, 0);

  button_portion = gtk_button_new();
  gtk_widget_show(button_portion);
  gtk_box_pack_start(GTK_BOX(hbox1), button_portion, FALSE, FALSE, 0);

  alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0);
  gtk_widget_show(alignment1);
  gtk_container_add(GTK_CONTAINER(button_portion), alignment1);

  hbox2 = gtk_hbox_new(FALSE, 2);
  gtk_widget_show(hbox2);
  gtk_container_add(GTK_CONTAINER(alignment1), hbox2);

  image1 = gtk_image_new_from_stock("gtk-properties", GTK_ICON_SIZE_BUTTON);
  gtk_widget_show(image1);
  gtk_box_pack_start(GTK_BOX(hbox2), image1, FALSE, FALSE, 0);

  label5 = gtk_label_new_with_mnemonic(_("Change"));
  gtk_widget_show(label5);
  gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0);

  shortcuts.label(label5);

  bool expand = false;
  if (settings->session.print_references_in_notes_in_full) {
    expand = true;
  }

  expander1 = gtk_expander_new(NULL);
  gtk_widget_show(expander1);
  gtk_box_pack_start(GTK_BOX(vbox1), expander1, TRUE, TRUE, 0);
  gtk_expander_set_expanded(GTK_EXPANDER(expander1), expand);

  vbox_expander = gtk_vbox_new(FALSE, 5);
  gtk_widget_show(vbox_expander);
  gtk_container_add(GTK_CONTAINER(expander1), vbox_expander);

  checkbutton_full_references = gtk_check_button_new_with_mnemonic(_("Write the references in the notes in full"));
  gtk_widget_show(checkbutton_full_references);
  gtk_box_pack_start(GTK_BOX(vbox_expander), checkbutton_full_references, FALSE, FALSE, 0);

  // TO DO: Add options for 1 column, double spaced here
  
  shortcuts.button(checkbutton_full_references);

  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_full_references), settings->session.print_references_in_notes_in_full);

  label_expander = gtk_label_new(_("Options"));
  gtk_widget_show(label_expander);
  gtk_expander_set_label_widget(GTK_EXPANDER(expander1), label_expander);

  shortcuts.label(label_expander);

  dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(printprojectdialog));
  gtk_widget_show(dialog_action_area1);
  gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);

  new InDialogHelp(printprojectdialog, NULL, &shortcuts, "file/print/project");

  cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
  gtk_widget_show(cancelbutton1);
  gtk_dialog_add_action_widget(GTK_DIALOG(printprojectdialog), cancelbutton1, GTK_RESPONSE_CANCEL);
  gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);

  okbutton1 = gtk_button_new_from_stock("gtk-ok");
  gtk_widget_show(okbutton1);
  gtk_dialog_add_action_widget(GTK_DIALOG(printprojectdialog), okbutton1, GTK_RESPONSE_OK);
  gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true);

  shortcuts.stockbutton(cancelbutton1);
  shortcuts.stockbutton(okbutton1);
  shortcuts.process();

  g_signal_connect((gpointer) button_portion, "clicked", G_CALLBACK(on_button_portion_clicked), gpointer(this));
  g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this));

  gtk_widget_grab_focus(okbutton1);
  gtk_widget_grab_default(okbutton1);

  // Set gui.
  gui_reorder_include();
}
Exemple #25
0
void bestelakoak()
{
	GtkWidget *frame;
	GtkWidget *alignment;
	GtkWidget *fixed;
	GtkWidget *cmdGehi;
	GtkWidget *cmdKendu;
	GtkWidget *cmdAdos;
	GtkWidget *cmdUtzi;
	GtkWidget *cmdKen;
	GtkWidget *labela;
	GtkWidget *cmdGehitu;
	GtkWidget *taula;
	GtkWidget *eventbox;
	GtkWidget *cmdZenbakiak3;
	GtkWidget *cmdZenbakiak2;
	GtkWidget *cmdZenbakiak4;
	GtkWidget *cmdZenbakiak5;
	GtkWidget *cmdZenbakiak6;
	GtkWidget *cmdZenbakiak9;
	GtkWidget *cmdZenbakiak8;
	GtkWidget *cmdZenbakiak7;
	GtkWidget *cmdZenbakiak0;
	GtkWidget *cmdZenbakiak10;
	GtkWidget *cmdZenbakiak11;
	GtkWidget *cmdZenbakiak1;
	GtkTreeModel *model;
	GtkCellRenderer *renderer;
	
	/* Lehioa sortu eta konfiguratu */
	frmBestelakoak = gtk_window_new (GTK_WINDOW_POPUP);
	gtk_window_set_position (GTK_WINDOW (frmBestelakoak), GTK_WIN_POS_CENTER_ALWAYS);
	gtk_window_set_modal (GTK_WINDOW (frmBestelakoak), TRUE);
	gtk_window_set_decorated (GTK_WINDOW (frmBestelakoak), FALSE);
	//gtk_window_set_type_hint (GTK_WINDOW (frmBestelakoak), GDK_WINDOW_TYPE_HINT_DIALOG);
	//gtk_window_set_transient_for(GTK_WINDOW(frmBestelakoak), GTK_WINDOW(frmKontua));
	
	/* Lehioaren egitura sortu eta kokatu */
	frame = gtk_frame_new ("");
	gtk_container_add (GTK_CONTAINER (frmBestelakoak), frame);
	gdk_color_parse("#e3e0e0", &kolorea);
	gtk_widget_modify_bg(frame, GTK_STATE_NORMAL, &kolorea);
	
	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_container_add (GTK_CONTAINER (frame), alignment);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
	
	fixed = gtk_fixed_new ();
	gtk_container_add (GTK_CONTAINER (alignment), fixed);

	labela = gtk_label_new ("<span size='large'><b> Sartu zerrendan bestelako gastuak </b></span>");
	gtk_fixed_put (GTK_FIXED (fixed), labela, 0, 0);
	gtk_widget_set_size_request (labela, 312, 32);
	gtk_label_set_use_markup (GTK_LABEL (labela), TRUE);

	/* Kalkulagailua sortu eta kokatu */
	frame = gtk_frame_new (NULL);
	gtk_fixed_put (GTK_FIXED (fixed), frame, 0, 32);
	gdk_color_parse("#858484", &kolorea);
	gtk_widget_modify_bg(frame, GTK_STATE_NORMAL, &kolorea);
	gtk_widget_set_size_request (frame, 250, 300);
	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_container_add(GTK_CONTAINER(frame), alignment);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
	
	taula = gtk_table_new (10, 3, TRUE);
	gtk_container_add (GTK_CONTAINER (alignment), taula);
	gtk_table_set_row_spacings (GTK_TABLE (taula), 4);
	gtk_table_set_col_spacings (GTK_TABLE (taula), 4);
	
	txtZenbakiak = gtk_entry_new ();
	gtk_table_attach (GTK_TABLE (taula), txtZenbakiak, 0, 3, 0, 2,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_FILL), 0, 0);
	gtk_entry_set_invisible_char (GTK_ENTRY (txtZenbakiak), 9679);
	gtk_entry_set_text(GTK_ENTRY(txtZenbakiak), "0");
	
	cmdZenbakiak3 = gtk_button_new_with_label("3");
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak3, 2, 3, 6, 8,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak3), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak2 = gtk_button_new_with_label("2");
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak2, 1, 2, 6, 8,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak2), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak4 = gtk_button_new_with_label("4");
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak4, 0, 1, 4, 6,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak4), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak5 = gtk_button_new_with_label("5");
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak5, 1, 2, 4, 6,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak5), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak6 = gtk_button_new_with_label("6");
	gtk_widget_show (cmdZenbakiak6);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak6, 2, 3, 4, 6,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak6), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak9 = gtk_button_new_with_label("9");
	gtk_widget_show (cmdZenbakiak9);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak9, 2, 3, 2, 4,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak9), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak8 = gtk_button_new_with_label("8");
	gtk_widget_show (cmdZenbakiak8);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak8, 1, 2, 2, 4,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak8), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak7 = gtk_button_new_with_label("7");
	gtk_widget_show (cmdZenbakiak7);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak7, 0, 1, 2, 4,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak7), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak0 = gtk_button_new_with_label("0");
	gtk_widget_show (cmdZenbakiak0);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak0, 0, 1, 8, 10,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak0), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak10 = gtk_button_new_with_label(",");
	gtk_widget_show (cmdZenbakiak10);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak10, 1, 2, 8, 10,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak10), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak11 = gtk_button_new_with_label("C");
	gtk_widget_show (cmdZenbakiak11);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak11, 2, 3, 8, 10,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak11), "clicked",
				G_CALLBACK(btmZenbakia), NULL);
	
	cmdZenbakiak1 = gtk_button_new_with_label("1");
	gtk_widget_show (cmdZenbakiak1);
	gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak1, 0, 1, 6, 8,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (GTK_FILL), 0, 0);
	g_signal_connect(G_OBJECT(cmdZenbakiak1), "clicked",
				G_CALLBACK(btmZenbakia), NULL);

	labela = gtk_label_new("<span size='x-large'>>></span>");
	gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
	cmdGehitu = gtk_button_new();
	gtk_container_add(GTK_CONTAINER(cmdGehitu), labela);
	gtk_fixed_put (GTK_FIXED (fixed), cmdGehitu, 256, 136);
	gtk_widget_set_size_request (cmdGehitu, 96, 64);
	g_signal_connect(G_OBJECT(cmdGehitu), "clicked",
			G_CALLBACK(btmGehitu), NULL);
	
	labela = gtk_label_new("<span size='x-large'> Kendu </span>");
	gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
	cmdKendu = gtk_button_new();
	gtk_container_add(GTK_CONTAINER(cmdKendu), labela);
	gtk_fixed_put (GTK_FIXED (fixed), cmdKendu, 256, 216);
	gtk_widget_set_size_request (cmdKendu, 96, 64);
	g_signal_connect(G_OBJECT(cmdKendu), "clicked",
			G_CALLBACK(btmKendu), NULL);

	model = GTK_TREE_MODEL (gtk_tree_store_new(1, G_TYPE_STRING));
	lista = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (lista),
					-1, "Sartutakoak", renderer,
					"text", 0,
					NULL);
	gtk_fixed_put (GTK_FIXED (fixed), lista, 368, 0);
	gtk_widget_set_size_request (lista, 208, 560);

	labela = gtk_label_new ("<span size='large'><b> Zenbat zarete ordaintzeko? </b></span>");
	gtk_fixed_put (GTK_FIXED (fixed), labela, 16, 344);
	gtk_widget_set_size_request (labela, 296, 32);
	gtk_label_set_use_markup (GTK_LABEL (labela), TRUE);

	labela = gtk_label_new("<span size='x-large'>+</span>");
	gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
	cmdGehi = gtk_button_new();
	gtk_container_add(GTK_CONTAINER(cmdGehi), labela);
	gtk_fixed_put (GTK_FIXED (fixed), cmdGehi, 112, 384);
	gtk_widget_set_size_request (cmdGehi, 64, 48);
	g_signal_connect(G_OBJECT(cmdGehi), "clicked",
			G_CALLBACK(btmGehi), NULL);
	gdk_color_parse("#bff9ed", &kolorea);
	gtk_widget_modify_bg(cmdGehi, GTK_STATE_NORMAL, &kolorea);
	gtk_widget_modify_bg(cmdGehi, GTK_STATE_PRELIGHT, &kolorea);
	
	labela = gtk_label_new("<span size='x-large'>-</span>");
	gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
	cmdKen = gtk_button_new();
	gtk_container_add(GTK_CONTAINER(cmdKen), labela);
	gtk_fixed_put (GTK_FIXED (fixed), cmdKen, 176, 384);
	gtk_widget_set_size_request (cmdKen, 64, 48);
	g_signal_connect(G_OBJECT(cmdKen), "clicked",
			G_CALLBACK(btmKen), NULL);
	gdk_color_parse("#fdb5d5", &kolorea);
	gtk_widget_modify_bg(cmdKen, GTK_STATE_NORMAL, &kolorea);
	gtk_widget_modify_bg(cmdKen, GTK_STATE_PRELIGHT, &kolorea);
	
	lblZenbat = gtk_label_new ("<span size='xx-large'><b>1</b></span>");
	gtk_widget_set_size_request (lblZenbat, 96, 48);
	gtk_label_set_use_markup (GTK_LABEL (lblZenbat), TRUE);
	eventbox = gtk_event_box_new();
	gtk_widget_set_size_request (eventbox, 96, 48);
	gtk_container_add(GTK_CONTAINER(eventbox), lblZenbat);
	gdk_color_parse("black", &kolorea);
	gtk_widget_modify_bg(eventbox, GTK_STATE_NORMAL, &kolorea);
	gdk_color_parse("yellow", &kolorea);
	gtk_widget_modify_fg(lblZenbat, GTK_STATE_NORMAL, &kolorea);
	gtk_fixed_put (GTK_FIXED (fixed), eventbox, 16, 384);

	labela = gtk_label_new("<span size='x-large'>Ados</span>");
	gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
	cmdAdos = gtk_button_new();
	gtk_container_add(GTK_CONTAINER(cmdAdos), labela);
	gtk_widget_show (cmdAdos);
	gtk_fixed_put (GTK_FIXED (fixed), cmdAdos, 24, 480);
	gtk_widget_set_size_request (cmdAdos, 136, 48);
	g_signal_connect(G_OBJECT(cmdAdos), "clicked",
			G_CALLBACK(btmAdos), NULL);
	
	labela = gtk_label_new("<span size='x-large'>Utzi</span>");
	gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
	cmdUtzi = gtk_button_new();
	gtk_container_add(GTK_CONTAINER(cmdUtzi), labela);
	gtk_widget_show (cmdUtzi);
	gtk_fixed_put (GTK_FIXED (fixed), cmdUtzi, 192, 480);
	gtk_widget_set_size_request (cmdUtzi, 136, 48);
	g_signal_connect(G_OBJECT(cmdUtzi), "clicked",
			G_CALLBACK(btmUtzi), NULL);

	/* Dena bistaratu eta martxan jarri */
	form_load();
	gtk_widget_show_all(frmBestelakoak);
	gtk_main();
}
Exemple #26
0
int main(int argc, char** argv){
	gtk_init(&argc, &argv);
	
	GtkWidget *window;
	GtkWidget *VBox;
	GtkWidget *table;
	GtkWidget *MenuBar;
	GtkWidget *MenuItem;
	GtkWidget *MenuIgem;
	GtkWidget *MenuIhem;
	GtkWidget *Entrer;
	GtkWidget *Bouton[18];
	GtkWidget *label;
	
	//*Création de fenêtre principal
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(window), 255, 200);
	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_title(GTK_WINDOW(window)," Calculatrice");
	gtk_window_set_modal(GTK_WINDOW(window), TRUE);
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL );
	
	table = gtk_table_new(4, 4, 1);
	gtk_container_add(GTK_CONTAINER(window), table);
	gtk_container_set_border_width(GTK_CONTAINER(table),5);

	gchar buffer[G_ASCII_DTOSTR_BUF_SIZE];
	int i=0,x=5,y=6;
	for (i = 0; i < 9; i++)
	{
		Bouton[i+1] = gtk_button_new_with_label(g_ascii_dtostr (buffer,
					G_ASCII_DTOSTR_BUF_SIZE,
					i+1));
		if((i%3)==0){
			x--;y--;
		}
		gtk_table_attach(GTK_TABLE(table), Bouton[i+1], i%3, i%3+1, x, y,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
		
	}
	Bouton[0] = gtk_button_new_with_label("0");
	gtk_table_attach(GTK_TABLE(table), Bouton[0],0, 1, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	Bouton[10] = gtk_button_new_with_label(",");
	gtk_table_attach(GTK_TABLE(table), Bouton[10],1, 2, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	Bouton[11] = gtk_button_new_with_label("=");
	gtk_table_attach(GTK_TABLE(table), Bouton[11],2, 3, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	Bouton[12] = gtk_button_new_with_label("x");
	gtk_table_attach(GTK_TABLE(table), Bouton[12],3, 4, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	Bouton[13] = gtk_button_new_with_label("/");
	gtk_table_attach(GTK_TABLE(table), Bouton[13],3, 4, 4, 5,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	Bouton[14] = gtk_button_new_with_label("+");
	gtk_table_attach(GTK_TABLE(table), Bouton[14],3, 4, 3, 4,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	Bouton[15] = gtk_button_new_with_label("-");
	gtk_table_attach(GTK_TABLE(table), Bouton[15],3, 4, 2, 3,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	Bouton[16] = gtk_button_new_with_label("clear");
	gtk_table_attach(GTK_TABLE(table), Bouton[16],0, 4, 6, 7,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	
	MyData data;
	data.Entrer = gtk_entry_new();
	gtk_entry_set_text(GTK_ENTRY(data.Entrer), "0");
	gtk_widget_set_can_focus(GTK_WIDGET(data.Entrer), FALSE);
	gtk_table_attach(GTK_TABLE(table), data.Entrer, 0, 4, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0);
	
	
	for(i=0;i<11;i++){
		g_signal_connect(G_OBJECT(Bouton[i]),  "clicked", G_CALLBACK(_setText),(GtkWidget*)data.Entrer);
	}
	g_signal_connect(G_OBJECT(Bouton[11]),  "clicked", G_CALLBACK(result),&data);
	g_signal_connect(G_OBJECT(Bouton[12]),  "clicked", G_CALLBACK(mul),&data);
	g_signal_connect(G_OBJECT(Bouton[13]),  "clicked", G_CALLBACK(divide),&data);
	g_signal_connect(G_OBJECT(Bouton[14]),  "clicked", G_CALLBACK(add),&data);
	g_signal_connect(G_OBJECT(Bouton[15]),  "clicked", G_CALLBACK(sub),&data);
	g_signal_connect(G_OBJECT(Bouton[16]),  "clicked", G_CALLBACK(clear),&data);
	
	gtk_widget_show_all(window);

	gtk_main();
	return 0;
}
GtkWidget * create_FileSelect( void )
{
 GtkWidget     * vbox4;
 GtkWidget     * hbox4;
 GtkWidget     * vseparator1;
 GtkWidget     * hbox6;
 GtkWidget     * fsFNameListWindow;
 GtkWidget     * hbuttonbox3;

 GtkWidget     * uppixmapwid;
 GdkPixmap     * uppixmap;
 GdkBitmap     * upmask;
 GtkStyle      * upstyle;


 fsFileSelect=gtk_window_new( GTK_WINDOW_TOPLEVEL );
 gtk_widget_set_name( fsFileSelect,"fsFileSelect" );
 gtk_object_set_data( GTK_OBJECT( fsFileSelect ),"fsFileSelect",fsFileSelect );
 gtk_widget_set_usize( fsFileSelect,512,300 );
 GTK_WIDGET_SET_FLAGS( fsFileSelect,GTK_CAN_DEFAULT );
 gtk_widget_set_events( fsFileSelect,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK | GDK_VISIBILITY_NOTIFY_MASK );
 gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_FileSelect );
 gtk_window_set_position( GTK_WINDOW( fsFileSelect ),GTK_WIN_POS_CENTER );
 gtk_window_set_policy( GTK_WINDOW( fsFileSelect ),TRUE,TRUE,TRUE );
 gtk_window_set_wmclass( GTK_WINDOW( fsFileSelect ),"FileSelect","MPlayer" );
 fsColorMap=gdk_colormap_get_system();

 gtk_widget_realize( fsFileSelect );
 gtkAddIcon( fsFileSelect );

 style=gtk_widget_get_style( fsFileSelect );
 dpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&dmask,&style->bg[GTK_STATE_NORMAL],(gchar **)dir_xpm );
 fpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&fmask,&style->bg[GTK_STATE_NORMAL],(gchar **)file_xpm );

 vbox4=AddVBox( AddDialogFrame( fsFileSelect ),0 );
 hbox4=AddHBox( vbox4,1 );

 fsCombo4=gtk_combo_new();
 gtk_widget_set_name( fsCombo4,"fsCombo4" );
 gtk_widget_show( fsCombo4 );
 gtk_box_pack_start( GTK_BOX( hbox4 ),fsCombo4,TRUE,TRUE,0 );
 gtk_widget_set_usize( fsCombo4,-2,20 );

 fsPathCombo=GTK_COMBO( fsCombo4 )->entry;
 gtk_widget_set_name( fsPathCombo,"fsPathCombo" );
 gtk_widget_show( fsPathCombo );
 gtk_widget_set_usize( fsPathCombo,-2,20 );

 vseparator1=gtk_vseparator_new();
 gtk_widget_set_name( vseparator1,"vseparator1" );
 gtk_widget_show( vseparator1 );
 gtk_box_pack_start( GTK_BOX( hbox4 ),vseparator1,FALSE,TRUE,0 );
 gtk_widget_set_usize( vseparator1,7,20 );

 upstyle=gtk_widget_get_style( fsFileSelect );
 uppixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&upmask,&upstyle->bg[GTK_STATE_NORMAL],(gchar **)up_xpm );
 uppixmapwid=gtk_pixmap_new( uppixmap,upmask );
 gtk_widget_show( uppixmapwid );

 fsUp=gtk_button_new();
 gtk_container_add( GTK_CONTAINER(fsUp ),uppixmapwid );
 gtk_widget_show( fsUp );
 gtk_box_pack_start( GTK_BOX( hbox4 ),fsUp,FALSE,FALSE,0 );
 gtk_widget_set_usize( fsUp,65,15 );

 AddHSeparator( vbox4 );

 hbox6=AddHBox( NULL,0 );
   gtk_box_pack_start( GTK_BOX( vbox4 ),hbox6,TRUE,TRUE,0 );

 fsFNameListWindow=gtk_scrolled_window_new( NULL,NULL );
 gtk_widget_set_name( fsFNameListWindow,"fsFNameListWindow" );
 gtk_widget_show( fsFNameListWindow );
 gtk_box_pack_start( GTK_BOX( hbox6 ),fsFNameListWindow,TRUE,TRUE,0 );
 gtk_widget_set_usize( fsFNameListWindow,-2,145 );
 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( fsFNameListWindow ),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC );

 fsFNameList=gtk_clist_new( 2 );
 gtk_widget_set_name( fsFNameList,"fsFNameList" );
 gtk_container_add( GTK_CONTAINER( fsFNameListWindow ),fsFNameList );
 gtk_clist_set_column_width( GTK_CLIST( fsFNameList ),0,80 );
 gtk_clist_set_selection_mode( GTK_CLIST( fsFNameList ),GTK_SELECTION_BROWSE );
 gtk_clist_column_titles_hide( GTK_CLIST( fsFNameList ) );
 gtk_clist_set_shadow_type( GTK_CLIST( fsFNameList ),GTK_SHADOW_ETCHED_OUT );

 AddHSeparator( vbox4 );

 List=gtk_combo_new();
 gtk_widget_set_name( List,"List" );
 gtk_widget_ref( List );
 gtk_object_set_data_full( GTK_OBJECT( fsFileSelect ),"List",List,(GtkDestroyNotify)gtk_widget_unref );
 gtk_widget_show( List );
 gtk_box_pack_start( GTK_BOX( vbox4 ),List,FALSE,FALSE,0 );
 gtk_widget_set_usize( List,-2,20 );

 fsFilterCombo=GTK_COMBO( List )->entry;
 gtk_widget_set_name( fsFilterCombo,"fsFilterCombo" );
 gtk_widget_show( fsFilterCombo );
 gtk_entry_set_editable (GTK_ENTRY( fsFilterCombo ),FALSE );

 AddHSeparator( vbox4 );

 hbuttonbox3=AddHButtonBox( vbox4 );
   gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox3 ),GTK_BUTTONBOX_END );
   gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox3 ),10 );

 fsOk=AddButton( MSGTR_Ok,hbuttonbox3 );
 fsCancel=AddButton( MSGTR_Cancel,hbuttonbox3 );

 gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"destroy",GTK_SIGNAL_FUNC( fs_Destroy ), NULL );
 gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"key_release_event",GTK_SIGNAL_FUNC( on_FileSelect_key_release_event ),NULL );

 gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsFilterCombo_changed ),fsFilterCombo );
 gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsFilterCombo_activate ),fsFilterCombo );
 gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsPathCombo_changed ),fsPathCombo );
 gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsPathCombo_activate ),fsPathCombo );
 gtk_signal_connect( GTK_OBJECT( fsUp ),"released",GTK_SIGNAL_FUNC( fs_Up_released ),fsFNameList );
 gtk_signal_connect( GTK_OBJECT( fsOk ),"released",GTK_SIGNAL_FUNC( fs_Ok_released ),fsCombo4 );
 gtk_signal_connect( GTK_OBJECT( fsCancel ),"released",GTK_SIGNAL_FUNC( fs_Cancel_released ),NULL );
 gtk_signal_connect( GTK_OBJECT( fsFNameList ),"select_row",(GtkSignalFunc)fs_fsFNameList_select_row,NULL );
 gtk_signal_connect( GTK_OBJECT( fsFNameList ),"event", (GtkSignalFunc)fs_fsFNameList_event,NULL );

 gtk_widget_grab_focus( fsFNameList );

 return fsFileSelect;
}
Exemple #28
0
int main( int argc, char **argv ) {
    extern const char *source_modtime_str, *source_version_str;
    const char *load_prefs = getenv("FONTFORGE_LOADPREFS");
    int i;
    extern int splash;
    int recover=1;
    GtkWidget *notices, *ffsplash;
    gchar *home_dir, *rc_path;
    struct argcontext args;

#ifdef FONTFORGE_CONFIG_TYPE3
    fprintf( stderr, "Copyright (c) 2000-2012 by George Williams.\n Executable based on sources from %s-ML.\n",
	    source_modtime_str );
#else
    fprintf( stderr, "Copyright (c) 2000-2012 by George Williams.\n Executable based on sources from %s.\n",
	    source_modtime_str );
#endif
    fprintf( stderr, " Library based on sources from %s.\n", library_version_configuration.library_source_modtime_string );

    gtk_set_locale ();

    home_dir = (gchar*) g_get_home_dir();
    rc_path = g_strdup_printf("%s/.fontforgerc", home_dir);
    gtk_rc_add_default_file(rc_path);
    g_free(rc_path);

    gtk_init (&argc, &argv);

#if defined(SHAREDIR)
    add_pixmap_directory( SHAREDIR "/pixmaps");
#elif defined(PREFIX)
    add_pixmap_directory( PREFIX "/share/fontforge/pixmaps" );
#else
    add_pixmap_directory( "./pixmaps" );
#endif

    bind_textdomain_codeset("FontForge","UTF-8");
    bindtextdomain("FontForge", getLocaleDir());
    textdomain("FontForge");

#if defined(__Mac)
    /* Start X if they haven't already done so. Well... try anyway */
    /* Must be before we change DYLD_LIBRARY_PATH or X won't start */
    if ( uses_local_x(argc,argv) && getenv("DISPLAY")==NULL ) {
	system( "open /Applications/Utilities/X11.app/" );
	setenv("DISPLAY",":0.0",0);
    }
#endif

    FF_SetUiInterface(&gtk_ui_interface);
    FF_SetPrefsInterface(&gtk_prefs_interface);
    /*FF_SetSCInterface(&gtk_sc_interface);*/
    /*FF_SetCVInterface(&gtk_cv_interface);*/
    /*FF_SetBCInterface(&gtk_bc_interface);*/
    FF_SetFVInterface(&gtk_fv_interface);
    /*FF_SetFIInterface(&gtk_fi_interface);*/
    /*FF_SetMVInterface(&gtk_mv_interface);*/
    /*FF_SetClipInterface(&gtk_clip_interface);*/
#ifndef _NO_PYTHON
    PythonUI_Init();
#endif

    InitSimpleStuff();
    if ( load_prefs!=NULL && strcasecmp(load_prefs,"Always")==0 )
	LoadPrefs();
    if ( default_encoding==NULL )
	default_encoding=FindOrMakeEncoding("ISO8859-1");
    if ( default_encoding==NULL )
	default_encoding=&custom;	/* In case iconv is broken */
    CheckIsScript(argc,argv);		/* Will run the script and exit if it is a script */
					/* If there is no UI, there is always a script */
			                /*  and we will never return from the above */
    if ( load_prefs==NULL ||
	    (strcasecmp(load_prefs,"Always")!=0 &&	/* Already loaded */
	     strcasecmp(load_prefs,"Never")!=0 ))
	LoadPrefs();
    for ( i=1; i<argc; ++i ) {
	char *pt = argv[i];
	if ( pt[0]=='-' && pt[1]=='-' )
	    ++pt;

	if ( strcmp(pt,"-nosplash")==0 )
	    splash = 0;
	else if ( strcmp(pt,"-recover")==0 && i<argc-1 ) {
	    ++i;
	    if ( strcmp(argv[i],"none")==0 )
		recover=0;
	    else if ( strcmp(argv[i],"clean")==0 )
		recover= -1;
	    else if ( strcmp(argv[i],"auto")==0 )
		recover= 1;
	    else if ( strcmp(argv[i],"inquire")==0 )
		recover= 2;
	    else {
		fprintf( stderr, "Invalid argument to -recover, must be none, auto, inquire or clean\n" );
		dousage();
	    }
	} else if ( strcmp(pt,"-recover=none")==0 ) {
	    recover = 0;
	} else if ( strcmp(pt,"-recover=clean")==0 ) {
	    recover = -1;
	} else if ( strcmp(pt,"-recover=auto")==0 ) {
	    recover = 1;
	} else if ( strcmp(pt,"-recover=inquire")==0 ) {
	    recover = 2;
	} else if ( strcmp(pt,"-help")==0 )
	    dohelp();
	else if ( strcmp(pt,"-usage")==0 )
	    dousage();
	else if ( strcmp(pt,"-version")==0 )
	    doversion(source_version_str);
	else if ( strcmp(pt,"-library-status")==0 )
	    dolibrary();
    }

    InitCursors();
#ifndef _NO_PYTHON
    PyFF_ProcessInitFiles();
#endif

    if ( splash ) {
	splashw = create_FontForgeSplash ();
	splash_window_tooltip_fun( splashw );
	notices = lookup_widget(splashw,"Notices");
	if ( notices!=NULL )
	    gtk_widget_hide(notices);
	ffsplash = lookup_widget(splashw,"ffsplash2");
	if ( ffsplash!=NULL )
	    gtk_widget_hide(ffsplash);
	ffsplash = lookup_widget(splashw,"ffsplash3");
	if ( ffsplash!=NULL )
	    gtk_widget_hide(ffsplash);
	gtk_window_set_position(GTK_WINDOW(splashw),GTK_WIN_POS_CENTER_ALWAYS);
	gtk_widget_show (splashw);
	ff_progress_allow_events();
	gtk_timeout_add(1000,Splash_Changes,splashw);
    }

    gtk_timeout_add(30*1000,__DoAutoSaves,NULL);		/* Check for autosave every 30 seconds */

    args.argc = argc; args.argv = argv; args.recover = recover;
    gtk_timeout_add(100,ParseArgs,&args);
	/* Parse arguments within the main loop */

    gtk_main ();
return( 0 );
}
/*
 Creates & runs dialog setting
*/
void
touchatag_applet_setting_dialog_run (touchatag_applet_core_s *touchatag_applet_core)
{
	GtkWidget *dialog;
	GtkWidget *label, *h_box, *v_box;
	GtkWidget *notebook;
	GtkWidget *scrolled_win;
	GtkWidget *v_box_info;
	GtkWidget *h_box_info;
	GtkWidget *separator;

	GtkWidget *button_db_delete_all;
	GtkWidget *button_db_remove_tag;
	GtkWidget *button_db_remove_tag_action;
	GtkWidget *check_save_tag;
	int i;

	/* Create dialog */
	dialog = gtk_dialog_new_with_buttons ("Setting", NULL, GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
    gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
	gtk_window_set_default_size (GTK_WINDOW(dialog), 400, -1);
	gtk_window_set_title (GTK_WINDOW(dialog), " Setting ");
	gtk_dialog_set_has_separator (GTK_DIALOG(dialog), FALSE);
	gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);

	/* Create notebook */
	notebook = gtk_notebook_new ();
	gtk_notebook_set_scrollable (GTK_NOTEBOOK(notebook), FALSE);
	gtk_widget_set_size_request (notebook, 300, 400);

	/* Create scrolled window */
	scrolled_win = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_NONE);

	/* Create info section */
	v_box_info = gtk_vbox_new (FALSE, 0);

		/* Header */
		h_box = gtk_hbox_new (FALSE, 0);	
			label = gtk_label_new ("Devices Info");	
			gtk_widget_modify_font (label, pango_font_description_from_string ("sans center bold 9"));		
			gtk_box_pack_start(GTK_BOX(h_box), label, FALSE, FALSE, 10);		
			gtk_widget_show (label);	
		gtk_box_pack_start(GTK_BOX(v_box_info), h_box, FALSE, FALSE, 15);
		gtk_widget_show (h_box);

		
		h_box_info = gtk_hbox_new (FALSE, 0);
	
			v_box = gtk_vbox_new (FALSE, 0);
	
				for (i = 0; i < touchatag_applet_core->numofdev; i++) {

						/* Reader ID */
						h_box = gtk_hbox_new (FALSE, 0);
							label = touchatag_applet_setting_create_label ("Reader ID:");
							gtk_box_pack_start(GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
							label = touchatag_applet_setting_create_label ((char *) touchatag_reader_return_reader_id (&touchatag_applet_core->reader[i]));
							gtk_box_pack_start (GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
						gtk_widget_show(h_box);
						gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 0);
		
						/* Reader FIRMWARE */
						h_box = gtk_hbox_new (FALSE, 0);
							label = touchatag_applet_setting_create_label ("Firmware:");
							gtk_box_pack_start(GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
							label = touchatag_applet_setting_create_label ((char *) touchatag_reader_return_reader_firmware (&touchatag_applet_core->reader[i]));
							gtk_box_pack_start (GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
						gtk_widget_show(h_box);
						gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 0);

						/* Reader SERIAL SAM */
						h_box = gtk_hbox_new (FALSE, 0);
							label = touchatag_applet_setting_create_label ("Serial number SAM:");
							gtk_box_pack_start(GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
							label = touchatag_applet_setting_create_label ((char *) touchatag_reader_return_reader_serial_sam (&touchatag_applet_core->reader[i]));
							gtk_box_pack_start (GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
						gtk_widget_show(h_box);
						gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 0);

						/* Reader IDENTIFICATION SAM */
						h_box = gtk_hbox_new (FALSE, 0);
							label = touchatag_applet_setting_create_label ("Id. number SAM:");
							gtk_box_pack_start(GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
							label = touchatag_applet_setting_create_label ((char *) touchatag_reader_return_reader_identification_sam (&touchatag_applet_core->reader[i]));
							gtk_box_pack_start (GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
						gtk_widget_show(h_box);
						gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 0);

						/* Reader HANDLER POSITION */
						h_box = gtk_hbox_new (FALSE, 0);
							label = touchatag_applet_setting_create_label ("Handler:");
							gtk_box_pack_start(GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
							label = touchatag_applet_setting_create_label (g_strdup_printf("%d", touchatag_applet_core->reader[i].hand));
							gtk_box_pack_start (GTK_BOX(h_box), label, TRUE, FALSE, 0);
							gtk_widget_show (label);
						gtk_widget_show(h_box);
						gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 0);	

				
						/* Separator */
						h_box = gtk_hbox_new(FALSE, 0);
							separator = gtk_hseparator_new();
							gtk_widget_set_size_request (separator, 200, 3);
							gtk_box_pack_start(GTK_BOX(h_box), separator, TRUE, FALSE, 2);
							gtk_widget_show (separator);
						gtk_widget_show(h_box);
						gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 10);
					}
	
			gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win), v_box);
			gtk_widget_show (v_box);
	
			gtk_box_pack_start(GTK_BOX(h_box_info), scrolled_win, TRUE, TRUE, 5);
			gtk_widget_show (scrolled_win);
	
			gtk_box_pack_start(GTK_BOX(v_box_info), h_box_info, TRUE, TRUE, 10);
			gtk_widget_show (h_box_info);

 	label = gtk_label_new ("Readers");
	gtk_notebook_append_page (GTK_NOTEBOOK(notebook), v_box_info, label);
	gtk_widget_show (h_box_info);

	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, FALSE, FALSE, 10);
	gtk_widget_show_all (notebook);	


	/* run the dialog */
	gint result = gtk_dialog_run (GTK_DIALOG (dialog));

	switch (result){
		case GTK_RESPONSE_DELETE_EVENT:
			gtk_widget_destroy (dialog);
			break;
		case GTK_RESPONSE_CANCEL:
			gtk_widget_destroy (dialog);
			break;	
		case GTK_RESPONSE_OK:
			gtk_widget_destroy (dialog);
			break;
	}
	return;
}
Exemple #30
0
BOOL
create_connectionpool (HWND hwnd, TCONNECTIONPOOLING *choose_t)
{
  GtkWidget *connectionpool, *dialog_vbox1, *fixed1, *l_question;
  GtkWidget *t_cptimeout, *dialog_action_area1, *hbuttonbox1;
  GtkWidget *t_probe, *l_time, *l_probe;
  GtkWidget *b_finish, *b_cancel;
  guint b_finish_key, b_cancel_key;
  GtkAccelGroup *accel_group;
  char msg[1024];

  if (hwnd == NULL || !GTK_IS_WIDGET (hwnd) || !choose_t)
    return FALSE;

  accel_group = gtk_accel_group_new ();

  connectionpool = gtk_dialog_new ();
  gtk_object_set_data (GTK_OBJECT (connectionpool), "connectionpool",
      connectionpool);
  gtk_window_set_title (GTK_WINDOW (connectionpool), "Connection pooling attributes");
  gtk_window_set_position (GTK_WINDOW (connectionpool), GTK_WIN_POS_CENTER);
  gtk_window_set_modal (GTK_WINDOW (connectionpool), TRUE);
  gtk_window_set_policy (GTK_WINDOW (connectionpool), FALSE, FALSE, FALSE);

#if GTK_CHECK_VERSION(2,0,0)
  gtk_widget_show (connectionpool);
#endif

  dialog_vbox1 = GTK_DIALOG (connectionpool)->vbox;
  gtk_object_set_data (GTK_OBJECT (connectionpool), "dialog_vbox1",
      dialog_vbox1);
  gtk_widget_show (dialog_vbox1);

  fixed1 = gtk_fixed_new ();
  gtk_widget_ref (fixed1);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "fixed1", fixed1,
      (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (fixed1);
  gtk_box_pack_start (GTK_BOX (dialog_vbox1), fixed1, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (fixed1), 6);

  l_question =
      gtk_label_new
      ("You have now to specify the connection pooling timeout\nin seconds of the specified driver and probe query");
  gtk_widget_ref (l_question);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "l_question",
      l_question, (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (l_question);
  gtk_fixed_put (GTK_FIXED (fixed1), l_question, 8, 8);
  gtk_widget_set_uposition (l_question, 8, 8);
#if GTK_CHECK_VERSION(2,0,0)
  gtk_widget_set_usize (l_question, 376, 36);
#else
  gtk_widget_set_usize (l_question, 376, 24);
#endif
  gtk_label_set_justify (GTK_LABEL (l_question), GTK_JUSTIFY_LEFT);

  l_time = gtk_label_new ("Timeout:");
  gtk_widget_ref (l_time);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "l_time",
      l_time, (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (l_time);
#if GTK_CHECK_VERSION(2,0,0)
  gtk_fixed_put (GTK_FIXED (fixed1), l_time, 8, 48);
  gtk_widget_set_uposition (l_time, 8, 48);
#else
  gtk_fixed_put (GTK_FIXED (fixed1), l_time, 8, 40);
  gtk_widget_set_uposition (l_time, 8, 40);
#endif
  gtk_widget_set_usize (l_time, 60, 24);
  gtk_label_set_justify (GTK_LABEL (l_time), GTK_JUSTIFY_RIGHT);

  t_cptimeout = gtk_entry_new ();
  gtk_widget_ref (t_cptimeout);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "t_cptimeout",
      t_cptimeout, (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (t_cptimeout);
#if GTK_CHECK_VERSION(2,0,0)
  gtk_fixed_put (GTK_FIXED (fixed1), t_cptimeout, 80, 48);
  gtk_widget_set_uposition (t_cptimeout, 80, 48);
#else
  gtk_fixed_put (GTK_FIXED (fixed1), t_cptimeout, 80, 40);
  gtk_widget_set_uposition (t_cptimeout, 80, 40);
#endif
  gtk_widget_set_usize (t_cptimeout, 300, 22);

  if (choose_t)
    gtk_entry_set_text (GTK_ENTRY (t_cptimeout), choose_t->timeout);

  l_probe = gtk_label_new ("Query:");
  gtk_widget_ref (l_probe);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "l_probe",
      l_probe, (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (l_probe);
#if GTK_CHECK_VERSION(2,0,0)
  gtk_fixed_put (GTK_FIXED (fixed1), l_probe, 8, 78);
  gtk_widget_set_uposition (l_probe, 8, 78);
#else
  gtk_fixed_put (GTK_FIXED (fixed1), l_probe, 8, 70);
  gtk_widget_set_uposition (l_probe, 8, 70);
#endif
  gtk_widget_set_usize (l_probe, 60, 24);
  gtk_label_set_justify (GTK_LABEL (l_probe), GTK_JUSTIFY_RIGHT);

  t_probe = gtk_entry_new ();
  gtk_widget_ref (t_probe);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "t_probe",
      t_probe, (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (t_probe);
#if GTK_CHECK_VERSION(2,0,0)
  gtk_fixed_put (GTK_FIXED (fixed1), t_probe, 80, 78);
  gtk_widget_set_uposition (t_probe, 80, 78);
#else
  gtk_fixed_put (GTK_FIXED (fixed1), t_probe, 80, 70);
  gtk_widget_set_uposition (t_probe, 80, 70);
#endif
  gtk_widget_set_usize (t_probe, 300, 22);

  if (choose_t)
    gtk_entry_set_text (GTK_ENTRY (t_probe), choose_t->probe);

  dialog_action_area1 = GTK_DIALOG (connectionpool)->action_area;
  gtk_object_set_data (GTK_OBJECT (connectionpool), "dialog_action_area1",
      dialog_action_area1);
  gtk_widget_show (dialog_action_area1);
  gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 5);

  hbuttonbox1 = gtk_hbutton_box_new ();
  gtk_widget_ref (hbuttonbox1);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "hbuttonbox1",
      hbuttonbox1, (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (hbuttonbox1);
  gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE,
      0);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
  gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);

  b_finish = gtk_button_new_with_label ("");
  b_finish_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_finish)->child),
      "_Finish");
  gtk_widget_add_accelerator (b_finish, "clicked", accel_group,
      b_finish_key, GDK_MOD1_MASK, 0);
  gtk_widget_ref (b_finish);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "b_finish", b_finish,
      (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (b_finish);
  gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_finish);
  GTK_WIDGET_SET_FLAGS (b_finish, GTK_CAN_DEFAULT);
  gtk_widget_add_accelerator (b_finish, "clicked", accel_group,
      'F', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);

  b_cancel = gtk_button_new_with_label ("");
  b_cancel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_cancel)->child),
      "_Cancel");
  gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
      b_cancel_key, GDK_MOD1_MASK, 0);
  gtk_widget_ref (b_cancel);
  gtk_object_set_data_full (GTK_OBJECT (connectionpool), "b_cancel", b_cancel,
      (GtkDestroyNotify) gtk_widget_unref);
  gtk_widget_show (b_cancel);
  gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_cancel);
  GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
  gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
      'C', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);

  /* Finish button events */
  gtk_signal_connect (GTK_OBJECT (b_finish), "clicked",
      GTK_SIGNAL_FUNC (connectionpool_finish_clicked), choose_t);
  /* Cancel button events */
  gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
      GTK_SIGNAL_FUNC (connectionpool_cancel_clicked), choose_t);
  /* Close window button events */
  gtk_signal_connect (GTK_OBJECT (connectionpool), "delete_event",
      GTK_SIGNAL_FUNC (delete_event), choose_t);
  gtk_signal_connect (GTK_OBJECT (connectionpool), "destroy",
      GTK_SIGNAL_FUNC (gtk_main_quit), NULL);

  gtk_window_add_accel_group (GTK_WINDOW (connectionpool), accel_group);

  choose_t->timeout_entry = t_cptimeout;
  choose_t->probe_entry = t_probe;
  choose_t->mainwnd = connectionpool;

  gtk_widget_show_all (connectionpool);
  gtk_main ();

  return choose_t->changed;
}