static void exec_autoforward_menu_cb(void)
{
  /* show modal dialog */
  GtkWidget *window;
  GtkWidget *vbox;
  GtkWidget *confirm_area;
  GtkWidget *ok_btn;
  GtkWidget *cancel_btn;
  GtkWidget *hbox;
  GtkWidget *label;
  GtkWidget *radio1;
  GtkWidget *radio2;
  GtkWidget *frame;
  GtkWidget *vbox_cond;
  GtkTreeIter iter;
  GtkTreeViewColumn *column;
  GtkWidget *view;
  GtkWidget *sw;
  GtkWidget *bbox;
  gchar *rcpath;
  gchar *to;
  gsize sz=0;
  GError *errval;
  gchar **folders;
  int nindex;
  
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_container_set_border_width(GTK_CONTAINER(window), 8);
  /*gtk_widget_set_size_request(window, 200, 100);*/
  gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_modal(GTK_WINDOW(window), TRUE);
  gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, FALSE);
  gtk_widget_realize(window);

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

  confirm_area = gtk_hbutton_box_new();
  gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);
  gtk_box_set_spacing(GTK_BOX(confirm_area), 6);


  ok_btn = gtk_button_new_from_stock(GTK_STOCK_OK);
  GTK_WIDGET_SET_FLAGS(ok_btn, GTK_CAN_DEFAULT);
  gtk_box_pack_start(GTK_BOX(confirm_area), ok_btn, FALSE, FALSE, 0);
  gtk_widget_show(ok_btn);

  cancel_btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
  GTK_WIDGET_SET_FLAGS(cancel_btn, GTK_CAN_DEFAULT);
  gtk_box_pack_start(GTK_BOX(confirm_area), cancel_btn, FALSE, FALSE, 0);
  gtk_widget_show(cancel_btn);

  gtk_widget_show(confirm_area);
	
  gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
  gtk_widget_grab_default(ok_btn);

  gtk_window_set_title(GTK_WINDOW(window), _("Autoforward Settings [autoforward]"));

  g_signal_connect(G_OBJECT(ok_btn), "clicked",
                   G_CALLBACK(prefs_ok_cb), window);
  g_signal_connect(G_OBJECT(cancel_btn), "clicked",
                   G_CALLBACK(prefs_cancel_cb), window);

  /* email settings */
  hbox = gtk_hbox_new(FALSE, 6);
  gtk_widget_show(hbox);
  gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

  label = gtk_label_new(_("Forward to(E-mail):"));
  gtk_widget_show(label);
  gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

  g_address = gtk_entry_new();
  gtk_widget_show(g_address);
  gtk_box_pack_start(GTK_BOX(hbox), g_address, FALSE, TRUE, 0);

  /* email settings */
  g_startup = gtk_check_button_new_with_label(_("Enable plugin on startup"));
  gtk_widget_show(g_startup);
  gtk_box_pack_start(GTK_BOX(vbox), g_startup, FALSE, FALSE, 0);

#if 0
  g_unreadonly = gtk_check_button_new_with_label(_("Forward unread mail only"));
  gtk_widget_show(g_unreadonly);
  gtk_box_pack_start(GTK_BOX(vbox), g_unreadonly, FALSE, FALSE, 0);
#endif

  /* all */
  radio1 = gtk_radio_button_new_with_label(NULL, _("Forward all mail"));
  /* folder filtered */
  radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
                                                                   _("Forward mail in folder"));

  frame = gtk_frame_new(_("Forward condition:"));
  gtk_widget_show(frame);
  gtk_container_add(GTK_CONTAINER(vbox), frame);
    
  vbox_cond = gtk_vbox_new(FALSE, 6);
  gtk_widget_show(vbox_cond);
  gtk_container_add(GTK_CONTAINER(frame), vbox_cond);
    
  gtk_box_pack_start(GTK_BOX(vbox_cond), radio1, FALSE, FALSE, 6);
  gtk_box_pack_start(GTK_BOX(vbox_cond), radio2, FALSE, FALSE, 6);

  /* treeview */
  g_folders = gtk_list_store_new(1, G_TYPE_STRING);
  
  column = gtk_tree_view_column_new_with_attributes (_("Forward mail in following folder:"),
                                                     gtk_cell_renderer_text_new (),
                                                     "text", 0,
                                                     NULL);
  view=gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_folders));
  gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
  sw = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_container_add (GTK_CONTAINER (sw), view);
  gtk_box_pack_start (GTK_BOX(vbox_cond), sw, TRUE, TRUE, 2);


  /* add and delete */
  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);
  g_add_btn = gtk_button_new_from_stock(GTK_STOCK_ADD);
  g_delete_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);

  gtk_box_pack_start(GTK_BOX(bbox), g_add_btn, FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(bbox), g_delete_btn, FALSE, FALSE, 0);
  gtk_widget_show_all(bbox);
    
  gtk_box_pack_end(GTK_BOX(vbox_cond), bbox, FALSE, FALSE, 6);
  gtk_widget_show_all(vbox_cond);
    

  g_signal_connect (g_add_btn, "clicked",
                    G_CALLBACK (add_mail_folder_cb), view);

  g_signal_connect (g_delete_btn, "clicked",
                    G_CALLBACK (delete_mail_folder_cb), view);

  g_signal_connect(GTK_BUTTON(radio1), "clicked",
                   G_CALLBACK(forward_mail_all_cb), view);

  g_signal_connect(GTK_BUTTON(radio2), "clicked",
                   G_CALLBACK(forward_mail_folder_cb), view);

  /* load settings */

  rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL);
  g_keyfile = g_key_file_new();
  if (g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL)){
    g_startup_flg = g_key_file_get_boolean (g_keyfile, "forward", "startup", NULL);
    debug_print("startup:%s\n", g_startup_flg ? "true" : "false");
    if (g_startup_flg){
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_startup), TRUE);
    }

#if 0
    g_unreadonly_flg = g_key_file_get_boolean (g_keyfile, "forward", "unreadonly", NULL);
    debug_print("unreadonly:%s\n", g_unreadonly_flg ? "true" : "false");
    if (g_unreadonly_flg){
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_unreadonly), TRUE);
    }
#endif

    to=g_key_file_get_string (g_keyfile, "forward", "to", NULL);
    gtk_entry_set_text(GTK_ENTRY(g_address), to);

    g_forward_flg=g_key_file_get_boolean (g_keyfile, "forward", "all", NULL);
    if (g_forward_flg){
      gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE);
      gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE);
      gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE);
    }else{
      g_print("activate view and radio2\n");
      gtk_widget_set_sensitive(GTK_WIDGET(view), TRUE);
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), TRUE);
    }
    /**/
    
    folders = g_key_file_get_string_list(g_keyfile, "forward", "folder", &sz, &errval);
    if (folders!=NULL){
      nindex=0;
      for (nindex = 0; nindex < sz; nindex++){
        gtk_list_store_append(g_folders, &iter);
        gtk_list_store_set(g_folders, &iter, 0, folders[nindex], -1);
      }
    }
  }else{
    /* default settings */
    g_startup_flg = FALSE;
    g_forward_flg = TRUE;
    gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE);
    gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE);
    gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE);
  }
  g_free(rcpath);

  gtk_widget_show(window);
}
Exemple #2
0
void gui_create_window_layout() {
    gtk_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(gtk_window), "Travelling Salesman Problem");

    g_signal_connect(G_OBJECT(gtk_window), "delete_event", G_CALLBACK(delete_event_cb), NULL);

    g_signal_connect(G_OBJECT(gtk_window), "destroy", G_CALLBACK(destroy_cb), NULL);

    gtk_container_set_border_width(GTK_CONTAINER(gtk_window), 0);

    // Create the menu vbox for holding the menu and the rest of the application.
    GtkWidget *menu_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
    gtk_container_add(GTK_CONTAINER(gtk_window), menu_vbox);
    // Create the menu items.
    GtkWidget *menu_item_new_cities = gtk_menu_item_new_with_label("New cities");
    g_signal_connect(G_OBJECT(menu_item_new_cities), "activate", G_CALLBACK(menu_item_new_cities_activate_cb), NULL);
    GtkWidget *menu_item_run = gtk_menu_item_new_with_label("Run");
    g_signal_connect(G_OBJECT(menu_item_run), "activate", G_CALLBACK(menu_item_run_activate_cb), NULL);
    GtkWidget *menu_item_stop = gtk_menu_item_new_with_label("Stop");
    g_signal_connect(G_OBJECT(menu_item_stop), "activate", G_CALLBACK(menu_item_stop_activate_cb), NULL);
    GtkWidget *menu_item_benchmark_current_settings = gtk_menu_item_new_with_label("Benchmark (current settings)");
    g_signal_connect(G_OBJECT(menu_item_benchmark_current_settings), "activate",
        G_CALLBACK(menu_item_benchmark_current_settings_activate_cb), NULL);
    GtkWidget *menu_item_benchmark_operators = gtk_menu_item_new_with_label("Benchmark (operators)");
    g_signal_connect(G_OBJECT(menu_item_benchmark_operators), "activate",
        G_CALLBACK(menu_item_benchmark_operators_activate_cb), NULL);
    GtkWidget *menu_item_benchmark_rates = gtk_menu_item_new_with_label("Benchmark (rates)");
    g_signal_connect(G_OBJECT(menu_item_benchmark_rates), "activate", G_CALLBACK(menu_item_benchmark_rates_activate_cb), NULL);
    GtkWidget *menu_item_quit = gtk_menu_item_new_with_label("Quit");
    g_signal_connect(G_OBJECT(menu_item_quit), "activate", G_CALLBACK(menu_item_quit_activate_cb), NULL);
    GtkWidget *action_menu = gtk_menu_new();
    gtk_menu_shell_append(GTK_MENU_SHELL(action_menu), menu_item_new_cities);
    gtk_menu_shell_append(GTK_MENU_SHELL(action_menu), menu_item_run);
    gtk_menu_shell_append(GTK_MENU_SHELL(action_menu), menu_item_stop);
    gtk_menu_shell_append(GTK_MENU_SHELL(action_menu), menu_item_benchmark_current_settings);
    gtk_menu_shell_append(GTK_MENU_SHELL(action_menu), menu_item_benchmark_operators);
    gtk_menu_shell_append(GTK_MENU_SHELL(action_menu), menu_item_benchmark_rates);
    gtk_menu_shell_append(GTK_MENU_SHELL(action_menu), menu_item_quit);
    // Create the menu bar.
    GtkWidget *menu_bar = gtk_menu_bar_new();
    // Create the Action menu.
    GtkWidget *action_item = gtk_menu_item_new_with_label("Action");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(action_item), action_menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), action_item);
    // Add the whole menu.
    gtk_box_pack_start(GTK_BOX(menu_vbox), menu_bar, FALSE, FALSE, 0);

    window = (Window *)malloc(sizeof(Window));
    // Create a hbox.
    GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
    // Create a vbox that holds the settings to the left.
    GtkWidget *settings_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
    // Create the number of cities label and entry.
    GtkWidget *label_nu_cities = gtk_label_new("Number of cities:");
    GtkWidget *entry_nu_cities = gtk_entry_new();
    gtk_entry_set_max_length(GTK_ENTRY(entry_nu_cities), 4);
    entry_nu_cities_reset_text(GTK_ENTRY(entry_nu_cities));
    g_signal_connect(G_OBJECT(entry_nu_cities), "activate", G_CALLBACK(entry_nu_cities_activate_cb), window);
    gtk_box_pack_start(GTK_BOX(settings_vbox), label_nu_cities, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), entry_nu_cities, FALSE, FALSE, 0);
    // Create the population size label and radio buttons.
    GtkWidget *label_population_size = gtk_label_new("Population size:");
    population_size_radio_button1 = gtk_radio_button_new_with_label(NULL, "64");
    population_size_radio_button2 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(population_size_radio_button1)), "128");
    population_size_radio_button3 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(population_size_radio_button1)), "256");
    population_size_radio_button4 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(population_size_radio_button1)), "512");
    population_size_radio_button5 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(population_size_radio_button1)), "1024");
    population_size_radio_button6 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(population_size_radio_button1)), "2048");
    population_size_radio_button7 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(population_size_radio_button1)), "4096");
    population_size_radio_button8 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(population_size_radio_button1)), "8192");
    g_signal_connect(G_OBJECT(population_size_radio_button1), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(population_size_radio_button2), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(population_size_radio_button3), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(population_size_radio_button4), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(population_size_radio_button5), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(population_size_radio_button6), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(population_size_radio_button7), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(population_size_radio_button8), "toggled",
        G_CALLBACK(population_size_radio_button_toggled_cb), NULL);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(population_size_radio_button3), TRUE);
    gtk_box_pack_start(GTK_BOX(settings_vbox), label_population_size, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button1, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button2, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button3, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button4, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button5, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button6, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button7, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), population_size_radio_button8, FALSE, FALSE, 0);
    // Create the mutation probability label and entry.
    GtkWidget *label_mutation_prob = gtk_label_new("Mutation probability:");
    entry_mutation_prob = gtk_entry_new();
    gtk_entry_set_max_length(GTK_ENTRY(entry_mutation_prob), 5);
    entry_mutation_prob_reset_text(GTK_ENTRY(entry_mutation_prob));
    g_signal_connect(G_OBJECT(entry_mutation_prob), "activate", G_CALLBACK(entry_mutation_prob_activate_cb), window);
    gtk_box_pack_start(GTK_BOX(settings_vbox), label_mutation_prob, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), entry_mutation_prob, FALSE, FALSE, 0);
    // Create the crossover probability label and entry.
    GtkWidget *label_crossover_prob = gtk_label_new("Crossover probability:");
    entry_crossover_prob = gtk_entry_new();
    gtk_entry_set_max_length(GTK_ENTRY(entry_crossover_prob), 5);
    entry_crossover_prob_reset_text(GTK_ENTRY(entry_crossover_prob));
    g_signal_connect(G_OBJECT(entry_crossover_prob), "activate", G_CALLBACK(entry_crossover_prob_activate_cb), window);
    gtk_box_pack_start(GTK_BOX(settings_vbox), label_crossover_prob, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), entry_crossover_prob, FALSE, FALSE, 0);
    // Create the mutation type label and radio buttons.
    GtkWidget *label_mutation_type = gtk_label_new("Mutation type:");
    mutation_type_radio_button1 = gtk_radio_button_new_with_label(NULL, "Swap");
    mutation_type_radio_button2 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(mutation_type_radio_button1)), "Swap neighbours");
    mutation_type_radio_button3 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(mutation_type_radio_button1)), "Insert");
    mutation_type_radio_button4 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(mutation_type_radio_button1)), "Invert");
    mutation_type_radio_button5 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(mutation_type_radio_button1)), "No operation");
    g_signal_connect(G_OBJECT(mutation_type_radio_button1), "toggled",
        G_CALLBACK(mutation_type_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(mutation_type_radio_button2), "toggled",
        G_CALLBACK(mutation_type_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(mutation_type_radio_button3), "toggled",
        G_CALLBACK(mutation_type_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(mutation_type_radio_button4), "toggled",
        G_CALLBACK(mutation_type_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(mutation_type_radio_button5), "toggled",
        G_CALLBACK(mutation_type_radio_button_toggled_cb), NULL);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mutation_type_radio_button4), TRUE);
    gtk_box_pack_start(GTK_BOX(settings_vbox), label_mutation_type, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), mutation_type_radio_button1, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), mutation_type_radio_button2, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), mutation_type_radio_button3, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), mutation_type_radio_button4, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), mutation_type_radio_button5, FALSE, FALSE, 0);
    // Create the crossover type label and radio buttons.
    GtkWidget *label_crossover_type = gtk_label_new("Crossover type:");
    crossover_type_radio_button1 = gtk_radio_button_new_with_label(NULL, "Order Based 1");
    crossover_type_radio_button2 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(crossover_type_radio_button1)), "Position Based");
    crossover_type_radio_button3 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(crossover_type_radio_button1)), "No operation");
    g_signal_connect(G_OBJECT(crossover_type_radio_button1), "toggled",
        G_CALLBACK(crossover_type_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(crossover_type_radio_button2), "toggled",
        G_CALLBACK(crossover_type_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(crossover_type_radio_button3), "toggled",
        G_CALLBACK(crossover_type_radio_button_toggled_cb), NULL);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(crossover_type_radio_button1), TRUE);
    gtk_box_pack_start(GTK_BOX(settings_vbox), label_crossover_type, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), crossover_type_radio_button1, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), crossover_type_radio_button2, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), crossover_type_radio_button3, FALSE, FALSE, 0);
    // Create the reporting frequency label and radio buttons.
    GtkWidget *label_reporting_frequency = gtk_label_new("Reporting frequency:");
    reporting_frequency_radio_button1 = gtk_radio_button_new_with_label(NULL, "Every generation");
    reporting_frequency_radio_button2 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(reporting_frequency_radio_button1)), "Every 10th generation");
    reporting_frequency_radio_button3 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(reporting_frequency_radio_button1)), "Every 100th generation");
    reporting_frequency_radio_button4 = gtk_radio_button_new_with_label(
        gtk_radio_button_get_group(GTK_RADIO_BUTTON(reporting_frequency_radio_button1)), "Every 1000th generation");
    g_signal_connect(G_OBJECT(reporting_frequency_radio_button1), "toggled",
        G_CALLBACK(reporting_frequency_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(reporting_frequency_radio_button2), "toggled",
        G_CALLBACK(reporting_frequency_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(reporting_frequency_radio_button3), "toggled",
        G_CALLBACK(reporting_frequency_radio_button_toggled_cb), NULL);
    g_signal_connect(G_OBJECT(reporting_frequency_radio_button4), "toggled",
        G_CALLBACK(reporting_frequency_radio_button_toggled_cb), NULL);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(reporting_frequency_radio_button1), TRUE);
    gtk_box_pack_start(GTK_BOX(settings_vbox), label_reporting_frequency, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), reporting_frequency_radio_button1, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), reporting_frequency_radio_button2, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), reporting_frequency_radio_button3, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(settings_vbox), reporting_frequency_radio_button4, FALSE, FALSE, 0);
    // Create the steady-state check box.
    GtkWidget *steady_state_check_button = gtk_check_button_new_with_label("Use steady-state evolution");
    g_signal_connect(G_OBJECT(steady_state_check_button), "toggled",
        G_CALLBACK(steady_state_check_button_toggled_cb), NULL);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(steady_state_check_button), FALSE);
    gtk_box_pack_start(GTK_BOX(settings_vbox), steady_state_check_button, FALSE, FALSE, 0);

    // Add the settings vbox to the hbox
    gtk_box_pack_start(GTK_BOX(hbox), settings_vbox, FALSE, FALSE, 8);

    // Add the drawing area to the hbox.
    window->image_drawing_area = gtk_drawing_area_new();
    gtk_widget_set_size_request(window->image_drawing_area, window_size, window_size);
    gtk_box_pack_start(GTK_BOX(hbox), window->image_drawing_area, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(menu_vbox), hbox, TRUE, TRUE, 0);

    window->surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, window_size, window_size);
    window->area_width = window_size;
    window->area_height = window_size;
    g_signal_connect(window->image_drawing_area, "draw", G_CALLBACK(area_draw_cb), window);
    g_signal_connect(window->image_drawing_area, "configure-event", G_CALLBACK(area_configure_event_cb), window);

    gtk_widget_show_all(gtk_window);
    GUI_initialized = 1;
}
Exemple #3
0
int  l_zkartmat1(const char *skl,const char *n_kart,GtkWidget *wpredok)
{
zkartmat_data data;
char strsql[512];
char bros[512];
GdkColor color;
SQL_str row;
SQLCURSOR cur;
iceb_u_str soob;
short ddd,mmm,ggg;
iceb_u_poltekdat(&ddd,&mmm,&ggg);


//Чтаем наименование склада
sprintf(strsql,"select naik from Sklad where kod=%s",skl);
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1)
 {
  iceb_u_str repl;
  repl.plus(gettext("Не найден код склада"));
  repl.plus(" ");
  repl.plus(skl);
  repl.plus(" !");
  iceb_menu_soob(&repl,wpredok);
  data.rk.naimskl.new_plus("");
 }
else
  data.rk.naimskl.new_plus(row[0]);

//читаем реквизиты карточки
sprintf(strsql,"select * from Kart where sklad=%s and nomk=%s",skl,n_kart);
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1)
 {
  iceb_u_str repl;
  repl.plus(gettext("Не найдена карточка"));
  repl.plus(" ");
  repl.plus(n_kart);
  repl.ps_plus(gettext("Склад"));
  repl.plus(skl);
  iceb_menu_soob(&repl,wpredok);
  return(1);
   
 }
data.rk.kodm.plus(row[2]);
data.rk.skl.plus(skl);
data.rk.n_kart.plus(n_kart);
data.rk.shet.plus(row[5]);
data.rk.cena.plus(row[6]);
data.rk.ei.plus(row[4]);
data.rk.nds.plus(row[9]);
data.rk.krat.plus(row[8]);
data.rk.cenapr.plus(row[7]);
data.rk.innom.plus(row[15]);
data.rk.rnd.plus(row[16]);
data.rk.nomzak.plus(row[17]);
data.rk.mnds.plus(row[3]);
data.rk.fas.plus(row[10]);
data.rk.kodtar.plus(row[11]);
short d,m,g;
if(iceb_u_rsdat(&d,&m,&g,row[14],2) == 0)
 {
  sprintf(strsql,"%d.%d.%d",d,m,g);
  data.rk.datv.plus(strsql);
 }
else
  data.rk.datv.plus("");

data.rk.data_kon_is.plus_sqldata(row[18]);

data.dn=1;
data.mn=1;
data.gn=startgod;
if(startgod == 0)
  data.gn=ggg;
  
data.dk=ddd;
data.mk=mmm;
data.gk=ggg;

sprintf(strsql,"%d.%d.%d",data.dn,data.mn,data.gn);
data.poi.datan.new_plus(strsql);

sprintf(strsql,"%d.%d.%d",data.dk,data.mk,data.gk);
data.poi.datak.new_plus(strsql);

//Читаем наименование материалла
sprintf(strsql,"select kodgr,naimat from Material where kodm=%s",data.rk.kodm.ravno());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
 {
  data.rk.kodgr.plus(row[0]);
  data.rk.naimat.plus(row[1]);
 }
else 
 {
  data.rk.kodgr.plus("");
  data.rk.naimat.plus("");
 }

//читаем наименование группы
sprintf(strsql,"select naik from Grup where kod=%s",data.rk.kodgr.ravno());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
 data.rk.naimgr.plus(row[0]);
else 
 data.rk.naimgr.plus("");

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(zkartmat_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);

soob.new_plus(gettext("Просмотр карточки"));
soob.ps_plus(data.rk.kodm.ravno());
soob.plus(" ");
soob.plus(data.rk.naimat.ravno());

data.label_kolstr=gtk_label_new (soob.ravno_toutf());


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 ("");
data.label_ost=gtk_label_new ("");

PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.label_ost),font_pango);
pango_font_description_free(font_pango);


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_ost,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),-1,200);

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(zkartmat_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,"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(zkartmat_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,"F4 %s",gettext("Поиск"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
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(zkartmat_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,"F6 %s",gettext("Смена даты"));
data.knopka[FK6]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK6],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK6]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK6]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK6],data.knopka[FK6],gettext("Включение/выключение просмотра записей за текущий месяц"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK6]),(gpointer)FK6);
gtk_widget_show(data.knopka[FK6]);

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(zkartmat_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,"F8 %s",gettext("Слияние"));
data.knopka[FK8]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK8],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK8]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK8]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK8],data.knopka[FK8],gettext("Слияние записей из нужной карточки в текущюю с удалением первой"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK8]),(gpointer)FK8);
gtk_widget_show(data.knopka[FK8]);

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(zkartmat_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]);

zkartmat_create_list(&data);

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


gtk_main();


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

return(data.metka_voz);

}
Exemple #4
0
int spizw_r(class spizw_rr *datark,GtkWidget *wpredok)
{
char strsql[512];
iceb_u_str repl;
class spizw_r_data data;

data.rk=datark;

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(spizw_r_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);

repl.plus(gettext("Списание материалов изделия с карточек"));
sprintf(strsql,"%s:%s %s\n",gettext("База данных"),imabaz,organ);
repl.ps_plus(strsql);

GtkWidget *label=gtk_label_new(repl.ravno_toutf());

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(spizw_r_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)spizw_r1,&data);

gtk_main();

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

return(data.voz);
}
Exemple #5
0
gint main (gint argc, gchar *argv[])
{
    gtk_init (&argc, &argv);
    gst_init (&argc, &argv);

    GstElement* pipeline = gst_pipeline_new ("pipeline");

    //window that contains several ares where the video is drawn
    GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_size_request (window, 640, 240);
    gtk_window_move (GTK_WINDOW (window), 300, 10);
    gtk_window_set_title (GTK_WINDOW (window), "click on left, right or outside the main window to switch the drawing area");
    GdkGeometry geometry;
    geometry.min_width = 1;
    geometry.min_height = 1;
    geometry.max_width = -1;
    geometry.max_height = -1;
    gtk_window_set_geometry_hints (GTK_WINDOW (window), window, &geometry, GDK_HINT_MIN_SIZE);

    //window to control the states
    GtkWidget* window_control = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    geometry.min_width = 1;
    geometry.min_height = 1;
    geometry.max_width = -1;
    geometry.max_height = -1;
    gtk_window_set_geometry_hints (GTK_WINDOW (window_control), window_control, &geometry, GDK_HINT_MIN_SIZE);
    gtk_window_set_resizable (GTK_WINDOW (window_control), FALSE);
    gtk_window_move (GTK_WINDOW (window_control), 10, 10);
    GtkWidget* table = gtk_grid_new ();
    gtk_container_add (GTK_CONTAINER (window_control), table);

    //control state null
    GtkWidget* button_state_null = gtk_button_new_with_label ("GST_STATE_NULL");
    g_signal_connect (G_OBJECT (button_state_null), "clicked",
        G_CALLBACK (button_state_null_cb), pipeline);
    gtk_grid_attach (GTK_GRID (table), button_state_null, 0, 0, 1, 1);
    gtk_widget_show (button_state_null);

    //control state ready
    GtkWidget* button_state_ready = gtk_button_new_with_label ("GST_STATE_READY");
    g_signal_connect (G_OBJECT (button_state_ready), "clicked",
        G_CALLBACK (button_state_ready_cb), pipeline);
    gtk_grid_attach (GTK_GRID (table), button_state_ready, 0, 1, 1, 1);
    gtk_widget_show (button_state_ready);

    //control state paused
    GtkWidget* button_state_paused = gtk_button_new_with_label ("GST_STATE_PAUSED");
    g_signal_connect (G_OBJECT (button_state_paused), "clicked",
        G_CALLBACK (button_state_paused_cb), pipeline);
    gtk_grid_attach (GTK_GRID (table), button_state_paused, 0, 2, 1, 1);
    gtk_widget_show (button_state_paused);

    //control state playing
    GtkWidget* button_state_playing = gtk_button_new_with_label ("GST_STATE_PLAYING");
    g_signal_connect (G_OBJECT (button_state_playing), "clicked",
        G_CALLBACK (button_state_playing_cb), pipeline);
    gtk_grid_attach (GTK_GRID (table), button_state_playing, 0, 3, 1, 1);
    gtk_widget_show (button_state_playing);

    gtk_widget_show (table);
    gtk_widget_show (window_control);

    //configure the pipeline
    g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(destroy_cb), pipeline);

    GstElement* videosrc  = gst_element_factory_make ("videotestsrc", "videotestsrc");
    GstElement* videosink = gst_element_factory_make ("glimagesink", "glimagesink");

    gst_bin_add_many (GST_BIN (pipeline), videosrc, videosink, NULL);

    gboolean link_ok = gst_element_link_many(videosrc, videosink, NULL);
    if(!link_ok)
    {
        g_warning("Failed to link videosrc to videosink!\n") ;
        return -1;
    }

    //areas where the video is drawn
    GtkWidget* table_areas = gtk_grid_new ();
    gtk_container_add (GTK_CONTAINER (window), table_areas);
    GtkWidget* area_top_left = gtk_drawing_area_new();
    gtk_widget_add_events(area_top_left, GDK_BUTTON_PRESS_MASK);
    gtk_widget_set_size_request (area_top_left, 320, 240);
    gtk_grid_attach (GTK_GRID (table_areas), area_top_left, 0, 0, 1, 1);
    GtkWidget* area_top_right = gtk_drawing_area_new();
    gtk_widget_add_events(area_top_right, GDK_BUTTON_PRESS_MASK);
    gtk_widget_set_size_request (area_top_right, 320, 240);
    gtk_grid_attach (GTK_GRID (table_areas), area_top_right, 1, 0, 1, 1);

    //set window id on this event
    g_signal_connect(area_top_left, "realize", G_CALLBACK(area_realize_cb), NULL);
    g_signal_connect(area_top_right, "realize", G_CALLBACK(area_realize_cb), NULL);

    gtk_widget_set_redraw_on_allocate (area_top_left, TRUE);
    gtk_widget_set_redraw_on_allocate (area_top_right, TRUE);
    gtk_widget_realize(area_top_left);
    gtk_widget_realize(area_top_right);

    GstBus* bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
    gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, area_top_right, NULL);
    gst_bus_add_signal_watch (bus);
    g_signal_connect(bus, "message::error", G_CALLBACK(end_stream_cb), pipeline);
    g_signal_connect(bus, "message::warning", G_CALLBACK(end_stream_cb), pipeline);
    g_signal_connect(bus, "message::eos", G_CALLBACK(end_stream_cb), pipeline);
    gst_object_unref (bus);

    //needed when being in GST_STATE_READY, GST_STATE_PAUSED
    //or resizing/obscuring the window
    g_signal_connect(area_top_left, "draw", G_CALLBACK(expose_cb), videosink);
    g_signal_connect(area_top_left, "configure-event", G_CALLBACK(resize_cb), videosink);
    g_signal_connect(area_top_right, "draw", G_CALLBACK(expose_cb), videosink);
    g_signal_connect(area_top_right, "configure-event", G_CALLBACK(resize_cb), videosink);

    //switch the drawing area
    g_signal_connect(area_top_left, "button-press-event", G_CALLBACK(on_click_drawing_area), videosink);
    g_signal_connect(area_top_right, "button-press-event", G_CALLBACK(on_click_drawing_area), videosink);

    gtk_widget_show_all (window);

    gst_element_set_state(pipeline, GST_STATE_PLAYING);

    gtk_main();

    return 0;
}
Exemple #6
0
void initIOPorts()
{
  int i;
  //R00 Dial Data (Input + pullup)
  //R04 Key tone (output)
  //R05 Dial In  (Input + pullup)
  //R06 Power Key Input/RDA1846 sck output
  //R07 Keypad +? / CHG Det Input

  //                      Dial Data 
  R0IO = 0x50; //0101 0000
  R0PSR= 0x00; //0000 0000  //Disable Enable buzzer
  R0PU = 0x21; //0010 0001
  R0 = 0x00;


  //R10 Lap (Output)
  //R11 Backlight (Output)
  //R12 TXD (output)
  //R13 PPT/RXD (Input)
  //R14 GPIO6 (Input)
  //R15 RDA1846 SEN (Output)
  //R16 RDA1846 SDIO (INput/Output)
  //R17 Speker Enable (Output)

  R1IO=0xE7; 	// 1110 0111
  R1PSR = 0x00; //Normal pins

  //R20 Vox Det (Input analog)
  //R21 Bat Det (Input analog)
  //R22 RDA1846 GPIO0 (input)
  //R23 Key Pad (Input Analog)
  //R24 Pow SW (output)

  //Reg on, turn on the radio
  R2IO = 0x10; //0001 0000
  R2PU		= 0x00;			// off,  off,  off,  off,  off,  off		 				 
  R2OD		= 0x00;			// PP,   PP,   PP,   PP,   PP,   PP
  R2		  = 0x00;			//  0     0     0     0     0     0   		         
  // ADC   IO    IO    IO    IO    IO 


  //Init interrupts
  IENH  = 0x0C;     //  x, INT0(6), INT1(5), INT2(4),RX(3),TX(2),x,x  // TX/RX enable 
  //IENM    = 0x80;     // T0E(7),T1E(6),T2E(5),T3E(4), -, -, -, ADCE(0) 
  //IENL    = 0x10;     // SPIE(7),BITE(6),WDTE(5),WTE(4),INT3(3),I2CE(2),x,x               
  
  RADIO_PW = 1; //Power on the radio
  SPK_EN = 0;  //Turn off the speaker


  GtkWidget *window;

  int argc = 0;
  char **argv  = NULL;
  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size(GTK_WINDOW(window), 400, 380);
  gtk_window_set_title(GTK_WINDOW(window), "+-");

  GtkWidget* frame = gtk_fixed_new();
  gtk_container_add(GTK_CONTAINER(window), frame);

  gtkArea = gtk_drawing_area_new();
  gtk_widget_set_usize(gtkArea,400,200);
  gtk_fixed_put(GTK_FIXED(frame), gtkArea, 0, 0);

  buttons[0] = gtk_button_new_with_label("LR");
  gtk_widget_set_size_request(buttons[0], 35, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[0], 30, 200);
  g_signal_connect(buttons[0], "clicked", G_CALLBACK(buttonPress), GINT_TO_POINTER(LR_KEY));

  buttons[1] = gtk_button_new_with_label("FA");
  gtk_widget_set_size_request(buttons[1], 35, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[1], 30, 240);
  g_signal_connect(buttons[1], "clicked", G_CALLBACK(buttonPress), GINT_TO_POINTER(FA_KEY));

  buttons[2] = gtk_button_new_with_label("UV");
  gtk_widget_set_size_request(buttons[2], 35, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[2], 120, 240);
  g_signal_connect(buttons[2], "clicked", G_CALLBACK(buttonPress), GINT_TO_POINTER(UV_KEY));

  buttons[3] = gtk_button_new_with_label("M");
  gtk_widget_set_size_request(buttons[3], 35, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[3], 160, 240);
  g_signal_connect(buttons[3], "clicked", G_CALLBACK(buttonPress), GINT_TO_POINTER(MENU_KEY));

  buttons[4] = gtk_button_new_with_label("V");
  gtk_widget_set_size_request(buttons[4], 35, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[4], 200, 240);
  g_signal_connect(buttons[4], "clicked", G_CALLBACK(buttonPress), GINT_TO_POINTER(VOL_KEY));

  buttons[5] = gtk_button_new_with_label("PTT");
  gtk_widget_set_size_request(buttons[5], 100, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[5], 20, 280);
  g_signal_connect(buttons[5], "clicked", G_CALLBACK(buttonPress), GINT_TO_POINTER(PTT_KEY));


  buttons[6] = gtk_button_new_with_label("+");
  gtk_widget_set_size_request(buttons[6], 35, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[6], 120, 200);
  g_signal_connect(buttons[6], "clicked", G_CALLBACK(encoderPress), GINT_TO_POINTER(1));

  buttons[7] = gtk_button_new_with_label("-");
  gtk_widget_set_size_request(buttons[7], 35, 35);
  gtk_fixed_put(GTK_FIXED(frame), buttons[7], 155, 200);
  g_signal_connect(buttons[7], "clicked", G_CALLBACK(encoderPress), GINT_TO_POINTER(0));

  gtk_widget_show_all(window);

  for(i=0; i<6; i++)
  {
  }
  

  for(i=0; i<80; i++)
    displayBuff[i] = 0;
  
}
Exemple #7
0
int main(int argc, char *argv[])
{
	GtkWidget *window;
	GtkWidget *image;
	GtkWidget *fixed;
	// GtkWidget *item;
	GtkWidget *mainWindow;
	GdkScreen*  scr;
	GdkBitmap *window_mask;
	GdkPixmap *pixmap;
	GdkBitmap *pixmap_mask;
	int lang = get_lang();
	switch(lang)
	{
		case 0:
			item_labels[0] = g_strdup_printf("重启");
			item_labels[1] = g_strdup_printf("待机");
			item_labels[2] = g_strdup_printf("关机");
			item_labels[3] = g_strdup_printf("取消");
		break;
		case 1:
			item_labels[0] = g_strdup_printf("Restart");
			item_labels[1] = g_strdup_printf("Stand By");
			item_labels[2] = g_strdup_printf("Turn off");
			item_labels[3] = g_strdup_printf("Cancel");
		break;
		case 2:
			item_labels[0] = g_strdup_printf("再起動");
			item_labels[1] = g_strdup_printf("スタンバイ");
			item_labels[2] = g_strdup_printf("電源を切る");
			item_labels[3] = g_strdup_printf("キャンセル");
		break;
	}
	gtk_init(&argc, &argv);
//----------------------------------------------
	mainWindow = gtk_window_new( GTK_WINDOW_POPUP);
	scr = gtk_window_get_screen( GTK_WINDOW( mainWindow));
   GdkColor white;
gdk_color_parse("#9c9c9c",&white);
gtk_widget_modify_bg(mainWindow,GTK_STATE_NORMAL,&white);	
	gtk_window_set_default_size( GTK_WINDOW( mainWindow), 
		gdk_screen_get_width( scr), 
		gdk_screen_get_height( scr));
//gtk_widget_set_size_request(mainWindow, window_width, window_height);
	gtk_window_fullscreen( GTK_WINDOW( mainWindow));
	gtk_widget_show_all( mainWindow);
	gtk_widget_realize(GTK_WIDGET(mainWindow));
	Display *xdpy = XOpenDisplay(getenv("DISPLAY"));
  	GdkWindow *gdkwin = GTK_WIDGET(mainWindow)->window;
  	Window xwin = GDK_WINDOW_XID(gdkwin);

  	unsigned int opacity = (unsigned int) (0.70 * OPAQUE);
  
  	XChangeProperty(xdpy, xwin, XInternAtom(xdpy, OPACITY, False), 
		    XA_CARDINAL, 32, PropModeReplace, 
		    (unsigned char *) &opacity, 1L);
  	// XSync(xdpy, False);
//----------------------------------------------
	window = gtk_window_new(GTK_WINDOW_POPUP);
	g_signal_connect(G_OBJECT(window), "destroy",
						G_CALLBACK(destroy), NULL);

	gtk_window_set_default_size(GTK_WINDOW(window), window_width, window_height);
//gtk_widget_set_size_request(window, window_width, window_height);
	 //gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_move(GTK_WINDOW(window), 249,163);
	gtk_window_set_modal(window,FALSE);
	gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
	gtk_window_set_title (GTK_WINDOW (window),"CloseWindow");
	
	/*gdk_pointer_grab (window->window, FALSE,
			(GdkEventMask)EVENT_MASKS, 0,
			NULL,
			GDK_CURRENT_TIME);*/



	gdk_pixmap_create_from_xpm(window->window, &window_mask, NULL, background_png);
	gtk_widget_shape_combine_mask (window, window_mask, 0, 0);

 gtk_widget_realize(GTK_WIDGET(window));

  Display *xdpy2 = XOpenDisplay(getenv("DISPLAY"));
  GdkWindow *gdkwin2 = GTK_WIDGET(window)->window;
  Window xwin2 = GDK_WINDOW_XID(gdkwin2);

  unsigned int opacity2 = (unsigned int) (0.80 * OPAQUE);
  
  XChangeProperty(xdpy2, xwin2, XInternAtom(xdpy2, OPACITY, False), 
		    XA_CARDINAL, 32, PropModeReplace, 
		    (unsigned char *) &opacity2, 1L);
  
gtk_widget_show_all(window);

	fixed = gtk_fixed_new();
	gtk_container_add(GTK_CONTAINER(window), fixed);
	gtk_widget_show(fixed);

	pixmap = gdk_pixmap_create_from_xpm(window->window, &pixmap_mask, NULL, background_png);
	image = gtk_image_new_from_pixmap(pixmap, pixmap_mask);
	gtk_fixed_put(GTK_FIXED(fixed), image, 0, 0);
	gtk_widget_show(image);

	make_icon_area(fixed);

	//make_cancel_button(fixed);
	XSync(xdpy, False);XSync(xdpy2, False);
	gtk_main();

	return 0;
}
static int
passphrase_dialog(char *message)
{
	const char *failed;
	char *passphrase, *local;
	char **messages;
	int result, i, grab_server, grab_pointer;
	GtkWidget *dialog, *entry, *label;
	GdkGrabStatus status;

	grab_server = (getenv("GNOME_SSH_ASKPASS_GRAB_SERVER") != NULL);
	grab_pointer = (getenv("GNOME_SSH_ASKPASS_GRAB_POINTER") != NULL);

	dialog = gtk_message_dialog_new(NULL, 0,
					GTK_MESSAGE_QUESTION,
					GTK_BUTTONS_OK_CANCEL,
					"%s",
					message);

	entry = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), entry, FALSE, 
	    FALSE, 0);
	gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
	gtk_widget_grab_focus(entry);
	gtk_widget_show(entry);

	gtk_window_set_title(GTK_WINDOW(dialog), "OpenSSH");
	gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
	gtk_label_set_line_wrap(GTK_LABEL((GTK_MESSAGE_DIALOG(dialog))->label),
				TRUE);

	/* Make <enter> close dialog */
	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
	g_signal_connect(G_OBJECT(entry), "activate",
			 G_CALLBACK(ok_dialog), dialog);

	/* Grab focus */
	gtk_widget_show_now(dialog);
	if (grab_server) {
		gdk_x11_grab_server();
	}
	if (grab_pointer) {
		status =  gdk_pointer_grab((GTK_WIDGET(dialog))->window, TRUE,
					   0, NULL, NULL, GDK_CURRENT_TIME);
		if (status != GDK_GRAB_SUCCESS) {
			failed = "mouse";
			goto nograb;
		}
	}
	status = gdk_keyboard_grab((GTK_WIDGET(dialog))->window, FALSE,
				   GDK_CURRENT_TIME);
	if (status != GDK_GRAB_SUCCESS) {
		failed = "keyboard";
		goto nograbkb;
	}
	result = gtk_dialog_run(GTK_DIALOG(dialog));

	/* Ungrab */
	if (grab_server)
		XUngrabServer(GDK_DISPLAY());
	if (grab_pointer)
		gdk_pointer_ungrab(GDK_CURRENT_TIME);
	gdk_keyboard_ungrab(GDK_CURRENT_TIME);
	gdk_flush();

	/* Report passphrase if user selected OK */
	passphrase = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
	if (result == GTK_RESPONSE_OK) {
		local = g_locale_from_utf8(passphrase, strlen(passphrase),
					   NULL, NULL, NULL);
		if (local != NULL) {
			puts(local);
			memset(local, '\0', strlen(local));
			g_free(local);
		} else {
			puts(passphrase);
		}
	}
		
	/* Zero passphrase in memory */
	memset(passphrase, '\b', strlen(passphrase));
	gtk_entry_set_text(GTK_ENTRY(entry), passphrase);
	memset(passphrase, '\0', strlen(passphrase));
	g_free(passphrase);
			
	gtk_widget_destroy(dialog);
	return (result == GTK_RESPONSE_OK ? 0 : -1);

	/* At least one grab failed - ungrab what we got, and report
	   the failure to the user.  Note that XGrabServer() cannot
	   fail.  */
 nograbkb:
	gdk_pointer_ungrab(GDK_CURRENT_TIME);
 nograb:
	if (grab_server)
		XUngrabServer(GDK_DISPLAY());
	gtk_widget_destroy(dialog);
	
	report_failed_grab(failed);

	return (-1);
}
/* Initialize and display the preferences dialog. */
void terminal_preferences_dialog(GtkAction * action, LXTerminal * terminal)
{
    Setting * setting = terminal->setting;

    GtkBuilder * builder = gtk_builder_new();
    if ( ! gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "/lxterminal/lxterminal-preferences.ui", NULL))
    {
        g_object_unref(builder);
        return;
    }

    GtkWidget * dialog = GTK_WIDGET(gtk_builder_get_object(builder, "lxterminal_preferences"));
    gtk_window_set_title(GTK_WINDOW(dialog), _("LXTerminal"));
    gtk_window_set_icon_from_file(GTK_WINDOW(dialog), PACKAGE_DATA_DIR "/pixmaps/lxterminal.png", NULL);
    g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(preferences_dialog_response_event), terminal);

    GtkWidget * w = GTK_WIDGET(gtk_builder_get_object(builder, "terminal_font"));
    gtk_font_button_set_font_name(GTK_FONT_BUTTON(w), setting->font_name);
    g_signal_connect(G_OBJECT(w), "font-set", G_CALLBACK(preferences_dialog_font_set_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "background_color"));
    gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->background_color);
    gtk_color_button_set_alpha(GTK_COLOR_BUTTON(w), setting->background_alpha);
    g_signal_connect(G_OBJECT(w), "color-set", G_CALLBACK(preferences_dialog_background_color_set_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "foreground_color"));
    gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->foreground_color);
    g_signal_connect(G_OBJECT(w), "color-set", G_CALLBACK(preferences_dialog_foreground_color_set_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "allow_bold"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->disallow_bold);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_allow_bold_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_blink"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_blink);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_cursor_blink_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_block"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->cursor_underline);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_underline"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_underline);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_cursor_underline_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "audible_bell"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->audible_bell);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_audible_bell_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "tab_position"));
    gtk_combo_box_set_active(GTK_COMBO_BOX(w), terminal_tab_get_position_id(setting->tab_position));
    g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(preferences_dialog_tab_position_changed_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "scrollback_lines"));
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), setting->scrollback);
    g_signal_connect(G_OBJECT(w), "value-changed", G_CALLBACK(preferences_dialog_scrollback_value_changed_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_scroll_bar"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_scroll_bar);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_hide_scroll_bar_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_menu_bar"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_menu_bar);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_hide_menu_bar_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_close_button"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_close_button);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_hide_close_button_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "select_by_word"));
    gtk_entry_set_text(GTK_ENTRY(w), setting->word_selection_characters);
    g_signal_connect(G_OBJECT(w), "focus-out-event", G_CALLBACK(preferences_dialog_selection_focus_out_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_f10"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_f10);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_disable_f10_toggled_event), terminal);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_alt"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_alt);
    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_disable_alt_toggled_event), terminal);

    gtk_widget_show_all(dialog);
    g_object_unref(builder);
}
Exemple #10
0
GtkWidget *
do_images (GtkWidget *do_widget)
{
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *image;
  GtkWidget *label;
  GtkWidget *align;
  GtkWidget *button;
  GdkPixbuf *pixbuf;
  GError *error = NULL;
  char *filename;
  
  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_screen (GTK_WINDOW (window),
			     gtk_widget_get_screen (do_widget));
      gtk_window_set_title (GTK_WINDOW (window), "Images");

      g_signal_connect (window, "destroy",
			G_CALLBACK (gtk_widget_destroyed), &window);
      g_signal_connect (window, "destroy",
			G_CALLBACK (cleanup_callback), NULL);

      gtk_container_set_border_width (GTK_CONTAINER (window), 8);

      vbox = gtk_vbox_new (FALSE, 8);
      gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
      gtk_container_add (GTK_CONTAINER (window), vbox);

      label = gtk_label_new (NULL);
      gtk_label_set_markup (GTK_LABEL (label),
			    "<u>Image loaded from a file</u>");
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      
      frame = gtk_frame_new (NULL);
      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      /* The alignment keeps the frame from growing when users resize
       * the window
       */
      align = gtk_alignment_new (0.5, 0.5, 0, 0);
      gtk_container_add (GTK_CONTAINER (align), frame);
      gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0);

      /* demo_find_file() looks in the the current directory first,
       * so you can run gtk-demo without installing GTK, then looks
       * in the location where the file is installed.
       */
      pixbuf = NULL;
      filename = demo_find_file ("gtk-logo-rgb.gif", &error);
      if (filename)
	{
	  pixbuf = gdk_pixbuf_new_from_file (filename, &error);
	  g_free (filename);
	}

      if (error)
	{
	  /* This code shows off error handling. You can just use
	   * gtk_image_new_from_file() instead if you don't want to report
	   * errors to the user. If the file doesn't load when using
	   * gtk_image_new_from_file(), a "missing image" icon will
	   * be displayed instead.
	   */
	  GtkWidget *dialog;
	  
	  dialog = gtk_message_dialog_new (GTK_WINDOW (window),
					   GTK_DIALOG_DESTROY_WITH_PARENT,
					   GTK_MESSAGE_ERROR,
					   GTK_BUTTONS_CLOSE,
					   "Unable to open image file 'gtk-logo-rgb.gif': %s",
					   error->message);
	  g_error_free (error);
	  
	  g_signal_connect (dialog, "response",
			    G_CALLBACK (gtk_widget_destroy), NULL);
	  
	  gtk_widget_show (dialog);
	}
	  
      image = gtk_image_new_from_pixbuf (pixbuf);

      gtk_container_add (GTK_CONTAINER (frame), image);


      /* Animation */

      label = gtk_label_new (NULL);
      gtk_label_set_markup (GTK_LABEL (label),
			    "<u>Animation loaded from a file</u>");
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      
      frame = gtk_frame_new (NULL);
      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      /* The alignment keeps the frame from growing when users resize
       * the window
       */
      align = gtk_alignment_new (0.5, 0.5, 0, 0);
      gtk_container_add (GTK_CONTAINER (align), frame);
      gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0);

      filename = demo_find_file ("floppybuddy.gif", NULL);
      image = gtk_image_new_from_file (filename);
      g_free (filename);

      gtk_container_add (GTK_CONTAINER (frame), image);
      

      /* Progressive */
      
      
      label = gtk_label_new (NULL);
      gtk_label_set_markup (GTK_LABEL (label),
			    "<u>Progressive image loading</u>");
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      
      frame = gtk_frame_new (NULL);
      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      /* The alignment keeps the frame from growing when users resize
       * the window
       */
      align = gtk_alignment_new (0.5, 0.5, 0, 0);
      gtk_container_add (GTK_CONTAINER (align), frame);
      gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0);

      /* Create an empty image for now; the progressive loader
       * will create the pixbuf and fill it in.
       */
      image = gtk_image_new_from_pixbuf (NULL);
      gtk_container_add (GTK_CONTAINER (frame), image);

      start_progressive_loading (image);

      /* Sensitivity control */
      button = gtk_toggle_button_new_with_mnemonic ("_Insensitive");
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

      g_signal_connect (button, "toggled",
                        G_CALLBACK (toggle_sensitivity_callback),
                        vbox);
    }

  if (!GTK_WIDGET_VISIBLE (window))
    {
      gtk_widget_show_all (window);
    }
  else
    {
      gtk_widget_destroy (window);
      window = NULL;
    }

  return window;
}
Exemple #11
0
static void
tree_menu (void)
{
  GtkWidget *window, *widget;
  GtkWidget *menubar, *vbox;
  GtkCellArea *area;
  GtkTreeModel *store;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  gtk_window_set_title (GTK_WINDOW (window), "GtkTreeMenu");

  vbox  = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
  gtk_widget_show (vbox);

  menubar = gtk_menu_bar_new ();
  gtk_widget_show (menubar);

  store = simple_tree_model ();
  area  = create_cell_area ();

#if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_
  menuitem = gtk_menu_item_new_with_label ("Grid");
  menu = create_menu_grid_demo ();
  gtk_widget_show (menu);
  gtk_widget_show (menuitem);
  gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);

  menuitem = gtk_menu_item_new_with_label ("Tree");
  menu = simple_tree_menu ();
  gtk_widget_show (menu);
  gtk_widget_show (menuitem);
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menubar), menuitem);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);

  g_signal_connect (menu, "menu-activate", G_CALLBACK (menu_activated_cb), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
#endif

  /* Add a combo box with the same menu ! */
  widget = gtk_combo_box_new_with_area (area);
  gtk_combo_box_set_model (GTK_COMBO_BOX (widget), store);
  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
  gtk_widget_show (widget);
  gtk_box_pack_end (GTK_BOX (vbox), widget, FALSE, FALSE, 0);

  /* Now add some controls */
  widget = gtk_combo_box_text_new ();
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);

  g_signal_connect (G_OBJECT (widget), "changed",
                    G_CALLBACK (orientation_changed), area);

  widget = gtk_check_button_new_with_label ("Align 2nd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (align_cell_2_toggled), area);

  widget = gtk_check_button_new_with_label ("Align 3rd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (align_cell_3_toggled), area);

  widget = gtk_check_button_new_with_label ("Expand 1st Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (expand_cell_1_toggled), area);

  widget = gtk_check_button_new_with_label ("Expand 2nd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (expand_cell_2_toggled), area);

  widget = gtk_check_button_new_with_label ("Expand 3rd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (expand_cell_3_toggled), area);

#if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_
  widget = gtk_check_button_new_with_label ("Submenu Headers");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (submenu_headers_toggled), menu);

  widget = gtk_check_button_new_with_label ("Tearoff menu");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (tearoff_toggled), menu);
#endif

  gtk_container_add (GTK_CONTAINER (window), vbox);

  gtk_widget_show (window);
}
Exemple #12
0
int main( int argc, char *argv[])
{

  GtkWidget *window;
  GtkWidget *vbox;

  GtkWidget *toolbar;
  GtkToolItem *undo;
  GtkToolItem *redo;
  GtkToolItem *sep;
  GtkToolItem *exit;


  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
  gtk_window_set_title(GTK_WINDOW(window), "undoredo");

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


  toolbar = gtk_toolbar_new();
  gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

  gtk_container_set_border_width(GTK_CONTAINER(toolbar), 2);

  undo = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
  gtk_widget_set_name(GTK_WIDGET(undo), "undo");
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), undo, -1);

  redo = gtk_tool_button_new_from_stock(GTK_STOCK_REDO);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), redo, -1);

  sep = gtk_separator_tool_item_new();
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), sep, -1); 

  exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), exit, -1);

  gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5);


  g_signal_connect(G_OBJECT(undo), "clicked", 
        G_CALLBACK(undo_redo), redo);

  g_signal_connect(G_OBJECT(redo), "clicked", 
        G_CALLBACK(undo_redo), undo);

  g_signal_connect(G_OBJECT(exit), "clicked", 
        G_CALLBACK(gtk_main_quit), NULL);

  g_signal_connect_swapped(G_OBJECT(window), "destroy",
        G_CALLBACK(gtk_main_quit), NULL);

  gtk_widget_show_all(window);

  gtk_main();

  return 0;
}
Exemple #13
0
GtkWidget*
create_main_window (void)
{
  GtkWidget *window;
  GtkWidget *vbox, *hbox;
  GtkWidget *vbox_scenes, *vbox_sequence, *vbox_channels;
  GtkWidget *button;
  GtkWidget *menubar;
  GtkWidget *notebook;
  GtkWidget *status_bar;
  GtkWidget *label;
  GtkWidget *widget;
  
  GtkAccelGroup *accel_group;
  GtkItemFactory *item_factory;
  GtkItemFactoryEntry menu_entries[] = {
    { "/_File",             NULL,      NULL,            0, "<Branch>" },
    //    { "/File/tear1",        NULL,      NULL,         0, "<Tearoff>" },
    { "/File/_New",         NULL,      new_project,     1, "<StockItem>", GTK_STOCK_NEW },
    { "/File/_Open...",     NULL,      open_file_cb,    1, "<StockItem>", GTK_STOCK_OPEN },
    { "/File/_Save",        NULL,      save_file,       1, "<StockItem>", GTK_STOCK_SAVE },
    { "/File/Save as...",   NULL,      save_file_as_cb, 1, "<StockItem>", GTK_STOCK_SAVE_AS },
    { "/File/sep1",         NULL,      NULL,            0, "<Separator>" },
    { "/File/_Quit",        NULL,      (GtkItemFactoryCallback) quit,
                                                        0, "<StockItem>", GTK_STOCK_QUIT} 
  };

  /*** SETUP GTK MAIN WINDOW ***/
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_object_set_data (GTK_OBJECT (window), "main_window", window);
//  gtk_widget_set_usize (window, 800, 600);
  gtk_window_set_title (GTK_WINDOW (window), "GlowControl");
  g_signal_connect (G_OBJECT (window), "delete-event",
                    G_CALLBACK (quit), NULL);

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


  /* The menu */

  accel_group = gtk_accel_group_new ();
  item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
  gtk_item_factory_create_items (item_factory, 
                                 sizeof (menu_entries) / sizeof (menu_entries[0]),
                                 menu_entries, 
                                 NULL);
  menubar = gtk_item_factory_get_widget (item_factory, "<main>");
  gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);

  notebook = gtk_notebook_new ();
  gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);

  status_bar = gtk_statusbar_new ();
  gtk_box_pack_start (GTK_BOX (vbox), status_bar, FALSE, FALSE, 0);
 
  progress_bar = gtk_progress_bar_new ();
  gtk_box_pack_start (GTK_BOX (status_bar), progress_bar, TRUE, TRUE, 0);


  /*** PREPARE NOTEBOOK PAGES ***/

  /* NOTEBOOK PAGE: SCENES */

  vbox_scenes = gtk_vbox_new (FALSE, 0);
  widget = gtk_scrolled_window_new (NULL, NULL);
  scene_view = setup_list_view (scene_store);

  g_signal_connect (G_OBJECT (scene_view), "row-activated",
                    G_CALLBACK (scene_edit_clicked), NULL);

  gtk_tree_view_set_reorderable (scene_view, TRUE);
  gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (scene_view));
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);

  gtk_box_pack_start (GTK_BOX (vbox_scenes), widget, TRUE, TRUE, 0);


  /* button bar */
  hbox = gtk_hbox_new (TRUE, 0);

  button = gtk_button_new_from_stock (GTK_STOCK_NEW);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (scene_new_clicked), NULL);

  button = gtk_button_new_from_stock (GTK_STOCK_COPY);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (scene_copy_clicked), NULL);

  button = gtk_button_new_from_stock (GTK_STOCK_DELETE);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (scene_remove_clicked), NULL);
  gtk_box_pack_start (GTK_BOX (vbox_scenes), hbox, FALSE, FALSE, 0);

  /* NOTEBOOK: SEQUENCE */

  vbox_sequence = gtk_vbox_new (FALSE, 0);
  widget = gtk_scrolled_window_new (NULL, NULL);
  sequence_view = setup_list_view (sequence_store);

  g_signal_connect (G_OBJECT (sequence_view), "row-activated",
                    G_CALLBACK (step_edit_clicked), NULL);

  gtk_tree_view_set_reorderable (sequence_view, TRUE);
  gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (sequence_view));
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);

  gtk_box_pack_start (GTK_BOX (vbox_sequence), widget, TRUE, TRUE, 0);

  hbox = gtk_hbox_new (TRUE, 0);

  button = gtk_button_new_from_stock (GTK_STOCK_NEW);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (step_new_clicked), NULL);

  button = gtk_button_new_from_stock (GTK_STOCK_DELETE);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (step_remove_clicked), NULL);

  gtk_box_pack_start (GTK_BOX (vbox_sequence), hbox, FALSE, FALSE, 0);

  hbox = gtk_hbox_new (TRUE, 0);

  button = button_new ("../pixmaps/first.xpm", _("First"), FALSE);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (sequence_first), NULL);

  button = button_new ("../pixmaps/prev.xpm", _("Previous"), FALSE);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (sequence_prev), NULL);

  play_button = button_new ("../pixmaps/play.xpm", _("Play"), TRUE);
  gtk_box_pack_start (GTK_BOX (hbox), play_button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (play_button), "clicked",
                    G_CALLBACK (sequence_play_clicked), NULL);

  button = button_new ("../pixmaps/next.xpm", _("Next"), FALSE);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (sequence_next_clicked), NULL);

  button = button_new ("../pixmaps/sync.xpm", _("Back to sync"), FALSE);
  gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (sequence_back_to_sync), NULL);


  gtk_box_pack_start (GTK_BOX (vbox_sequence), hbox, FALSE, FALSE, 0);
                

  /* NOTEBOOK: CHANNELS */

  vbox_channels = gtk_vbox_new (FALSE, 2);
  widget = gtk_scrolled_window_new (NULL, NULL);

  gtk_box_pack_start (GTK_BOX (vbox_channels), widget, TRUE, TRUE, 0);

  channel_view = setup_list_view (channel_store);
  gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (channel_view));

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
  

  /*** GATHER STUFF FOR NOTEBOOK ***/
  label = gtk_label_new (_("Channels"));
  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox_channels, label);

  label = gtk_label_new (_("Scenes"));
  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox_scenes, label);

  label = gtk_label_new (_("Sequence"));
  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox_sequence, label);

  gtk_widget_show_all (window);

  main_window = window;

  return window;
}
int main( int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *menubar;
    GtkWidget *filemenu, *item_file, *item_new, *item_open,*item_quit;
    GtkWidget *editmenu, *item_edit, *item_undo, *item_redo, *item_cut, *item_copy, *item_paste;
    GtkWidget *sep;
    GtkAccelGroup *accel_group = NULL;  //定义快捷键组

    gtk_init(&argc, &argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
    gtk_window_set_title(GTK_WINDOW(window), "menu better");

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

    menubar = gtk_menu_bar_new();   //菜单栏构件(menubar),实际上是一个menu shell

    filemenu = gtk_menu_new();      //菜单构件(menu),也是一个menu shell

    accel_group = gtk_accel_group_new();
    gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);


    item_file = gtk_menu_item_new_with_mnemonic("_File");   //替代 gtk_menu_item_new_with_label("File");
    item_new = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);  //替代gtk_menu_item_new_with_label("New");
    item_open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);//替代gtk_menu_item_new_with_label("Open");
    sep = gtk_separator_menu_item_new();    //生成一条分割线
    item_quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,accel_group);//替代gtk_menu_item_new_with_label("Quit");

    gtk_widget_add_accelerator(item_quit, "activate", accel_group, GDK_q,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_file), filemenu);

    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_new);
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_open);
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep);       //加入分割线到file菜单中
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_quit); //把“quit”菜单选项被填加进file菜单中
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_file);  //把“file”菜单选项被填加进菜单中(menubar)

    /*这里构建Edit菜单,同上面的file菜单添加方法一样*/
    editmenu = gtk_menu_new();       //菜单构件(menu),也是一个menu shell
    item_edit = gtk_menu_item_new_with_mnemonic("_Edit");
    item_undo = gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, NULL);
    item_redo = gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, NULL);
    sep = gtk_separator_menu_item_new();
    item_cut = gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT, NULL);
    item_copy = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL);
    item_paste = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL);

    gtk_widget_add_accelerator(item_undo, "activate", accel_group, GDK_z,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_redo, "activate", accel_group, GDK_r,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_cut, "activate", accel_group, GDK_x,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_copy, "activate", accel_group, GDK_c,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_paste, "activate", accel_group, GDK_v,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_edit), editmenu);

    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_undo);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_redo);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), sep);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_cut);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_copy);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_paste);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_edit);      //把“edit”菜单选项被填加进菜单中(menubar)


    /*这里把窗口分为了上中下3个区域,最上面是menubar*/
    gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);

    g_signal_connect(G_OBJECT(item_quit),
                     "activate",G_CALLBACK(gtk_main_quit), NULL);

    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}
Exemple #15
0
int
main(int argc, char **argv)
{
    GtkWidget *widget;
    gchar *glade_xml_file;

    gtk_init(&argc, &argv);
    set_font();
    get_asf_share_dir_with_argv0(argv[0]);

    asfPrintStatus("\nASF MapReady:\n");
    const char *share_dir = get_asf_share_dir();

    if (!share_dir)
      // this actually should never happen with the current implementation
      // of get_asf_share_dir() -- always sets the share dir to something
      // even if it is a bad guess... in which case the next check will fail
      asfPrintError("Could not find the ASF share directory!\n");

    glade_xml_file = (gchar *)find_in_share("mapready.glade");
    if (!glade_xml_file)
      asfPrintError("Could not find the mapready.glade file!\n"
                    "It should be in the share files directory, here:\n"
                    "  %s\n", share_dir);
    glade_xml = glade_xml_new(glade_xml_file, NULL, NULL);
    if (!glade_xml)
      asfPrintError("Could not load the mapready.glade file!\n"
                    "This file may be corrupt. mapready.glade was found in:\n"
                    "  %s\n", share_dir);
    g_free(glade_xml_file);

    asfPrintStatus("Using share files directory: %s\n\n", share_dir);

    /* thumbnails supported in GTK 2.4 or greater */
#ifdef G_THREADS_ENABLED
    use_thumbnails = gtk_major_version >= 2 && gtk_minor_version >= 4;
#else
    use_thumbnails = FALSE;
#endif

#ifdef win32
    // On windows, ensure that our installed sh.exe is the one that is found,
    // by severely restricting the path.
    char pathenv[1024];
    sprintf(pathenv, "PATH=%s", get_asf_bin_dir());
    putenv(pathenv);
#endif

    if (!use_thumbnails)
    {
        printf("GTK Version < 2.4 -- output thumbnails disabled.\n");
    }
    else
    {
        // We will want to load thumbnails in other threads.
        if ( !g_thread_supported () ) {
            g_thread_init (NULL);
        }
    }

    /* allow FOPEN, FREAD, FWRITE to fail without aborting */
    caplib_behavior_on_error = BEHAVIOR_ON_ERROR_CONTINUE;


    /* add version number to window title, request a default size */
    char gtitle [256];
    sprintf (gtitle, "ASF MapReady: Version %s",
             MAPREADY_VERSION_STRING);

    widget = get_widget_checked("asf_convert");
    gtk_window_set_title(GTK_WINDOW(widget), gtitle);
    // commenting this out - now supported within glade
    //gtk_window_resize(GTK_WINDOW(widget), 1000, 700);

    /* select defaults for dropdowns & buttons & labeling */
    widget = get_widget_checked("scaling_method_combobox");
    set_combo_box_item(widget, SCALING_METHOD_SIGMA);

    widget = get_widget_checked("import_checkbutton");
    gtk_widget_set_sensitive(widget, FALSE);

    widget = get_widget_checked("input_data_type_combobox");
    set_combo_box_item(widget, INPUT_TYPE_AMP);

    widget = get_widget_checked("resample_option_menu");
    set_combo_box_item(widget, RESAMPLE_BILINEAR);

    // Populate the colormap drop-downs on both the import tab and in the
    // browse dialog
    populate_polsarpro_classification_optionmenu();
    widget = get_widget_checked("browse_select_colormap_optionmenu");
    gtk_option_menu_set_history(GTK_OPTION_MENU(widget), 0);

    widget = get_widget_checked("output_format_combobox");
    set_combo_box_item(widget, OUTPUT_FORMAT_JPEG);

    widget = get_widget_checked("geocode_checkbutton");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
    geocode_options_changed();
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE);

    widget = get_widget_checked("about_dialog_copyright_label");
    gtk_label_set_text(GTK_LABEL(widget), ASF_COPYRIGHT_STRING);

    // Hide latitude selection stuff until we start supporting
    // swath products (level 0) again
    widget = get_widget_checked("latitude_checkbutton");
    gtk_widget_hide(widget);
    widget = get_widget_checked("latitude_low_label");
    gtk_widget_hide(widget);
    widget = get_widget_checked("latitude_hi_label");
    gtk_widget_hide(widget);
    widget = get_widget_checked("latitude_low_entry");
    gtk_widget_hide(widget);
    widget = get_widget_checked("latitude_hi_entry");
    gtk_widget_hide(widget);

    // This option is deprecated -- we always apply the fix now
    // and don't give the user the option of turning it off.  Probably
    // we can just delete all code associated with it, but for now we
    // just turn it on, and hide it.
    set_checked("apply_metadata_fix_checkbutton", TRUE);
    widget = get_widget_checked("apply_metadata_fix_checkbutton");
    gtk_widget_hide(widget);

    // Muck with the fonts in the About dialog
    widget = get_widget_checked("about_dialog_mapready_label");
    gchar *str = gtitle;
    gchar *text;
    PangoAttrList *attrs;
    sprintf(gtitle,
                "\n<b>ASF MapReady</b>\n"
                "<i>Remote Sensing Toolkit</i>\n"
                "ver. %s",
                MAPREADY_VERSION_STRING);
    if (strlen(SVN_REV)>0)
        sprintf(gtitle, "%s (build %s)", gtitle, SVN_REV);
    else
        strcat(gtitle, " (custom build)");

    pango_parse_markup(str, -1, 0, &attrs, &text, NULL, NULL);
    gtk_label_set_attributes(GTK_LABEL(widget), attrs);
    gtk_label_set_text(GTK_LABEL(widget), text);
    PangoFontDescription *font_desc =
      pango_font_description_from_string("Sans 12");
    gtk_widget_modify_font(widget, font_desc);

    // Muck with the "Select Processing Steps" label
    widget = get_widget_checked("select_processing_steps_label");
    str = gtitle;
    sprintf(gtitle, "<b><i>  Select Processing Steps:</i></b>");
    pango_parse_markup(str, -1, 0, &attrs, &text, NULL, NULL);
    gtk_label_set_attributes(GTK_LABEL(widget), attrs);
    gtk_label_set_text(GTK_LABEL(widget), text);
    font_desc = pango_font_description_from_string("Sans 12");
    gtk_widget_modify_font(widget, font_desc);

    /* fire handlers for hiding/showing stuff */
    output_format_combobox_changed();
    input_data_type_changed();
    geocode_options_changed();
    load_external_commands();
    external_settings_changed();
    set_toolbar_images();
    show_execute_button(TRUE);

    /* build columns in the files section */
    show_full_paths = FALSE; // Set before setup_files_list(), default to FALSE
    widget = get_widget_checked("show_full_path_names_checkbutton");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE);
    setup_files_list();

    /* allow multiple selects */
    widget = get_widget_checked("input_file_selection");
    gtk_file_selection_set_select_multiple(GTK_FILE_SELECTION(widget), TRUE);

    /* drag-n-drop setup */
    setup_dnd();

    /* right-click menu setup */
    setup_popup_menu();

    /* bands dropdown setup*/
    setup_band_comboboxes();

    current_naming_scheme = naming_scheme_default();

    /* set initial vpanel setting */
    //widget = get_widget_checked("vertical_pane");
    //gtk_paned_set_position(GTK_PANED(widget), 240);

    /* Connect signal handlers.  */
    glade_xml_signal_autoconnect (glade_xml);

    /* initial flag settings */
    processing = FALSE;
    settings_on_execute = NULL;

    /* explicit call to the function that refreshes the "summary" */
    /* section when options are changed, so get the settings      */
    /* initially in there                                         */
    input_data_formats_changed();
    input_data_type_combobox_changed();
    default_to_terrcorr_on();
    default_to_keep_temp();
    terrcorr_options_changed();
    init_browse_format_combobox();

    /* For some reason, it did not work to set this via glade        */
    /* So, we have to select our default faraday rotation style here */
    rb_select("rb_fr_global", TRUE);
    polarimetry_settings_changed();

    /* put files on the command-line into the files section */
    populate_files_list(argc, argv);

    /* set up the rgb stuff on the export tab */
    rgb_combo_box_setup();

    /* enters the main GTK loop */
    gtk_main ();

    /* clean up, application has been closed */
    if (settings_on_execute)
        settings_delete(settings_on_execute);

    if (output_directory)
        g_free(output_directory);

    if (current_naming_scheme)
        naming_scheme_delete(current_naming_scheme);

    release_predefined_projections();

    exit (EXIT_SUCCESS);
}
Exemple #16
0
static void
gui (int argc, char *argv[], GMainLoop *main_loop)
{
	GtkWidget *win;
	GtkWidget *main_box, *hbox, *vbox;
	GtkWidget *label, *check;
	GtkWidget *edt;
	PangoAttrList *attrs;
	PangoAttribute *attr;

	gtk_init (&argc, &argv);

	win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (win), _("EggDateTime Test"));
	gtk_container_set_border_width (GTK_CONTAINER (win), 6);
	g_signal_connect_swapped (G_OBJECT (win), "delete_event",
				  G_CALLBACK (g_main_loop_quit), main_loop);

	main_box = gtk_vbox_new (FALSE, 6);
	gtk_widget_show (main_box);
	gtk_container_add (GTK_CONTAINER (win), main_box);

	/* Date/Time widget */

	hbox = gtk_hbox_new (FALSE, 0);
	gtk_widget_show (hbox);
	gtk_box_pack_start (GTK_BOX (main_box), hbox, FALSE, FALSE, 0);

	edt = egg_datetime_new ();
	gtk_widget_show (edt);
	gtk_box_pack_start (GTK_BOX (hbox), edt, FALSE, FALSE, 0);

	/* Options */

	attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
	attr->start_index = 0;
	attr->end_index   = G_MAXUINT;
	attrs = pango_attr_list_new ();
	pango_attr_list_insert (attrs, attr);

	label = gtk_label_new (_("Options"));
	gtk_label_set_attributes (GTK_LABEL (label), attrs);
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_widget_show (label);
	gtk_box_pack_start (GTK_BOX (main_box), label, FALSE, FALSE, 6);

	hbox = gtk_hbox_new (FALSE, 0);
	gtk_widget_show (hbox);
	gtk_box_pack_start (GTK_BOX (main_box), hbox, FALSE, FALSE, 0);

	label = gtk_label_new ("");
	gtk_widget_set_size_request (label, 12, -1);
	gtk_widget_show (label);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

	vbox = gtk_vbox_new (TRUE, 6);
	gtk_widget_show (vbox);
	gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);

	check = gtk_check_button_new_with_mnemonic (_("Show _date"));
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
	gtk_widget_show (check);
	g_signal_connect (G_OBJECT (check), "toggled",
			  G_CALLBACK (show_date_toggled_cb), edt);
	gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0);

	check = gtk_check_button_new_with_mnemonic (_("Show _time"));
	gtk_widget_show (check);
	g_signal_connect (G_OBJECT (check), "toggled",
			  G_CALLBACK (show_time_toggled_cb), edt);
	gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0);

	check = gtk_check_button_new_with_mnemonic (_("_Lazy mode"));
	gtk_widget_show (check);
	g_signal_connect (G_OBJECT (check), "toggled",
			  G_CALLBACK (lazy_mode_toggled_cb), edt);
	gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0);

	gtk_widget_show (win);
}
Exemple #17
0
void i_alter_rtr(const char *imabaz,const char *host,const char *parol,GtkWidget *wpredok)
{
char strsql[300];
iceb_u_str soob;

alter_rtr_data data;
data.imabaz.plus(imabaz);
data.host.plus(host);
data.parol.plus(parol);

data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
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,iceb_u_toutf("Преобразование таблиц"));
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(alter_rtr_key_press),&data);

if(wpredok != NULL)
 {
  //Удерживать окно над породившем его окном всегда
  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);

sprintf(strsql,"%s:%s","Преобразование таблиц базы данных",data.imabaz.ravno());

soob.new_plus(strsql);

GtkWidget *label=gtk_label_new(soob.ravno_toutf());

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),400,300);

gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 10");
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);
gtk_widget_show_all(data.window);

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(alter_rtr_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_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна

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

gtk_idle_add((GtkFunction)alter_rtr1,&data);

gtk_main();


}
Exemple #18
0
int 
main (int argc, char **argv)
{
  static GtkWidget *window = NULL;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *button;
  GtkWidget *optionmenu;
  GtkWidget *separator;

  gtk_init (&argc, &argv);
  
  if (!window)
    {
      GtkWidget *menubar;
      GtkWidget *menu;
      GtkWidget *submenu;
      GtkWidget *menuitem;
      GtkAccelGroup *accel_group;
      
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      
      g_signal_connect (window, "destroy",
			G_CALLBACK(gtk_main_quit), NULL);
      g_signal_connect (window, "delete-event",
			G_CALLBACK (gtk_true), NULL);
      
      accel_group = gtk_accel_group_new ();
      gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);

      gtk_window_set_title (GTK_WINDOW (window), "menus");
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
      
      
      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box1);
      gtk_widget_show (box1);
      
      menubar = gtk_menu_bar_new ();
      gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
      gtk_widget_show (menubar);
      
      menu = create_menu (2, TRUE);
      
      menuitem = gtk_menu_item_new_with_label ("test\nline2");
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);

      
      menuitem = gtk_menu_item_new_with_label ("dynamic");
      submenu = create_menu (3, TRUE);
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);
      
      gdk_threads_add_timeout (250, change_item, submenu);

      menuitem = gtk_menu_item_new_with_label ("bar");
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
      gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);
      
      box2 = gtk_vbox_new (FALSE, 10);
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
      gtk_widget_show (box2);
      
      menu = create_menu (1, FALSE);
      gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
      
      menuitem = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
      gtk_widget_show (menuitem);
      
      menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
      gtk_widget_show (menuitem);
      gtk_widget_add_accelerator (menuitem,
				  "activate",
				  accel_group,
				  GDK_F1,
				  0,
				  GTK_ACCEL_VISIBLE);
      menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
      gtk_widget_show (menuitem);
      gtk_widget_add_accelerator (menuitem,
				  "activate",
				  accel_group,
				  GDK_F2,
				  0,
				  GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
      menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
      gtk_widget_show (menuitem);
      gtk_widget_add_accelerator (menuitem,
				  "activate",
				  accel_group,
				  GDK_F2,
				  0,
				  GTK_ACCEL_VISIBLE);
      gtk_widget_add_accelerator (menuitem,
				  "activate",
				  accel_group,
				  GDK_F3,
				  0,
				  GTK_ACCEL_VISIBLE);
      
      optionmenu = gtk_option_menu_new ();
      gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
      gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
      gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
      gtk_widget_show (optionmenu);

      separator = gtk_hseparator_new ();
      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
      gtk_widget_show (separator);

      box2 = gtk_vbox_new (FALSE, 10);
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
      gtk_widget_show (box2);

      button = gtk_button_new_with_label ("close");
      g_signal_connect_swapped (button, "clicked",
				G_CALLBACK(gtk_widget_destroy), window);
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
      gtk_widget_set_can_default (button, TRUE);
      gtk_widget_grab_default (button);
      gtk_widget_show (button);
    }

  if (!gtk_widget_get_visible (window))
    {
      gtk_widget_show (window);
    }
  else
    {
      gtk_widget_destroy (window);
      window = NULL;
    }

  gtk_main ();

  return 0;
}
GtkWidget*
    create_dialog1 (void)
{
  GtkWidget *dialog1;
  GtkWidget *dialog_vbox1;
  GtkWidget *vbox1;
  GtkWidget *frame1;
  GtkWidget *table1;
  GtkWidget *buttonSelect;
  GtkWidget *labelVobsub;
  GtkWidget *label4;
  GtkWidget *optionmenu1;
  GtkWidget *label2;
  GtkWidget *frame2;
  GtkWidget *table2;
  GtkWidget *label6;
  GtkObject *spinbutton1_adj;
  GtkWidget *spinbutton1;
  GtkWidget *label7;
  GtkWidget *entryShift;
  GtkWidget *label5;
  GtkWidget *dialog_action_area1;
  GtkWidget *cancelbutton1;
  GtkWidget *okbutton1;

  dialog1 = gtk_dialog_new ();
  gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("VobSub Settings"));

  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);

  frame1 = gtk_frame_new (NULL);
  gtk_widget_show (frame1);
  gtk_box_pack_start (GTK_BOX (vbox1), frame1, TRUE, TRUE, 0);

  table1 = gtk_table_new (2, 2, FALSE);
  gtk_widget_show (table1);
  gtk_container_add (GTK_CONTAINER (frame1), table1);

  buttonSelect = gtk_button_new_with_mnemonic (QT_TR_NOOP("Select .idx"));
  gtk_widget_show (buttonSelect);
  gtk_table_attach (GTK_TABLE (table1), buttonSelect, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  labelVobsub = gtk_label_new (QT_TR_NOOP("None"));
  gtk_widget_show (labelVobsub);
  gtk_table_attach (GTK_TABLE (table1), labelVobsub, 0, 1, 0, 1,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (labelVobsub), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (labelVobsub), 0, 0.5);

  label4 = gtk_label_new (QT_TR_NOOP("Select Language :"));
  gtk_widget_show (label4);
  gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);

  optionmenu1 = gtk_option_menu_new ();
  gtk_widget_show (optionmenu1);
  gtk_table_attach (GTK_TABLE (table1), optionmenu1, 1, 2, 1, 2,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  label2 = gtk_label_new (QT_TR_NOOP("Select Sub"));
  gtk_widget_show (label2);
  gtk_frame_set_label_widget (GTK_FRAME (frame1), label2);
  gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);

  frame2 = gtk_frame_new (NULL);
  gtk_widget_show (frame2);
  gtk_box_pack_start (GTK_BOX (vbox1), frame2, TRUE, TRUE, 0);

  table2 = gtk_table_new (2, 2, FALSE);
  gtk_widget_show (table2);
  gtk_container_add (GTK_CONTAINER (frame2), table2);

  label6 = gtk_label_new (QT_TR_NOOP("Extra Shrink Factor :"));
  gtk_widget_show (label6);
  gtk_table_attach (GTK_TABLE (table2), label6, 0, 1, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);

  spinbutton1_adj = gtk_adjustment_new (1, 1, 2, 0.1, 0.2, 0);
  spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0);
  gtk_widget_show (spinbutton1);
  gtk_table_attach (GTK_TABLE (table2), spinbutton1, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  label7 = gtk_label_new (QT_TR_NOOP("Shift (ms) :"));
  gtk_widget_show (label7);
  gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 1, 2,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);

  entryShift = gtk_entry_new ();
  gtk_widget_show (entryShift);
  gtk_table_attach (GTK_TABLE (table2), entryShift, 1, 2, 1, 2,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);

  label5 = gtk_label_new (QT_TR_NOOP("Extra Settings"));
  gtk_widget_show (label5);
  gtk_frame_set_label_widget (GTK_FRAME (frame2), label5);
  gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);

  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);

  cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
  gtk_widget_show (cancelbutton1);
  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
  GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);

  okbutton1 = gtk_button_new_from_stock ("gtk-ok");
  gtk_widget_show (okbutton1);
  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
  GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
  GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
  GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1");
  GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
  GLADE_HOOKUP_OBJECT (dialog1, buttonSelect, "buttonSelect");
  GLADE_HOOKUP_OBJECT (dialog1, labelVobsub, "labelVobsub");
  GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
  GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1");
  GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
  GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2");
  GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
  GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
  GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1");
  GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
  GLADE_HOOKUP_OBJECT (dialog1, entryShift, "entryShift");
  GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
  GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
  GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");

  return dialog1;
}
Exemple #20
0
GtkWidget*
create_shrimp (void)
{
  GtkWidget *shrimp;
  GtkWidget *dialog_vbox1;
  GtkWidget *table2;
  GtkWidget *label13;
  GtkWidget *current_version;
  GtkWidget *label15;
  GtkWidget *label16;
  GtkWidget *label17;
  GtkWidget *drives_combo;
  GtkWidget *target_version;
  GtkWidget *target_partitions;
  GtkWidget *status_label;
  GtkWidget *dialog_action_area1;
  GtkWidget *close_button;
  GtkWidget *install_button;

  shrimp = gtk_dialog_new ();
  gtk_widget_set_name (shrimp, "shrimp");
  gtk_window_set_title (GTK_WINDOW (shrimp), _("Thin Client Imager"));
  gtk_window_set_type_hint (GTK_WINDOW (shrimp), GDK_WINDOW_TYPE_HINT_DIALOG);
  gtk_dialog_set_has_separator (GTK_DIALOG (shrimp), FALSE);

  dialog_vbox1 = GTK_DIALOG (shrimp)->vbox;
  gtk_widget_set_name (dialog_vbox1, "dialog_vbox1");
  gtk_widget_show (dialog_vbox1);

  table2 = gtk_table_new (7, 2, FALSE);
  gtk_widget_set_name (table2, "table2");
  gtk_widget_show (table2);
  gtk_box_pack_start (GTK_BOX (dialog_vbox1), table2, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (table2), 6);
  gtk_table_set_row_spacings (GTK_TABLE (table2), 6);
  gtk_table_set_col_spacings (GTK_TABLE (table2), 12);

  label13 = gtk_label_new (_("Currently Running:"));
  gtk_widget_set_name (label13, "label13");
  gtk_widget_show (label13);
  gtk_table_attach (GTK_TABLE (table2), label13, 0, 1, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label13), 1, 0.5);

  current_version = gtk_label_new (_("--"));
  gtk_widget_set_name (current_version, "current_version");
  gtk_widget_show (current_version);
  gtk_table_attach (GTK_TABLE (table2), current_version, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (current_version), 0, 0.5);

  label15 = gtk_label_new (_("Target:"));
  gtk_widget_set_name (label15, "label15");
  gtk_widget_show (label15);
  gtk_table_attach (GTK_TABLE (table2), label15, 0, 1, 2, 3,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label15), 1, 0.5);

  label16 = gtk_label_new (_("Version:"));
  gtk_widget_set_name (label16, "label16");
  gtk_table_attach (GTK_TABLE (table2), label16, 0, 1, 3, 4,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label16), 1, 0.5);

  label17 = gtk_label_new (_("Partitions:"));
  gtk_widget_set_name (label17, "label17");
  gtk_widget_show (label17);
  gtk_table_attach (GTK_TABLE (table2), label17, 0, 1, 4, 5,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label17), 1, 0.5);

  drives_combo = gtk_combo_box_new_text ();
  gtk_widget_set_name (drives_combo, "drives_combo");
  gtk_widget_show (drives_combo);
  gtk_table_attach (GTK_TABLE (table2), drives_combo, 1, 2, 2, 3,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_FILL), 0, 0);

  target_version = gtk_label_new (_("--"));
  gtk_widget_set_name (target_version, "target_version");
  gtk_table_attach (GTK_TABLE (table2), target_version, 1, 2, 3, 4,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (target_version), 0, 0.5);

  target_partitions = gtk_label_new (_("--"));
  gtk_widget_set_name (target_partitions, "target_partitions");
  gtk_widget_show (target_partitions);
  gtk_table_attach (GTK_TABLE (table2), target_partitions, 1, 2, 4, 5,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_line_wrap (GTK_LABEL (target_partitions), TRUE);
  gtk_misc_set_alignment (GTK_MISC (target_partitions), 0, 0.5);

  status_label = gtk_label_new (_("All data on the target device will be erased"));
  gtk_widget_set_name (status_label, "status_label");
  gtk_widget_show (status_label);
  gtk_table_attach (GTK_TABLE (table2), status_label, 0, 2, 6, 7,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (status_label), 0, 0.5);

  dialog_action_area1 = GTK_DIALOG (shrimp)->action_area;
  gtk_widget_set_name (dialog_action_area1, "dialog_action_area1");
  gtk_widget_show (dialog_action_area1);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);

  close_button = gtk_button_new_from_stock ("gtk-close");
  gtk_widget_set_name (close_button, "close_button");
  gtk_widget_show (close_button);
  gtk_dialog_add_action_widget (GTK_DIALOG (shrimp), close_button, GTK_RESPONSE_CLOSE);
  GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT);

  install_button = gtk_button_new_with_mnemonic (_("Install Image"));
  gtk_widget_set_name (install_button, "install_button");
  gtk_widget_show (install_button);
  gtk_dialog_add_action_widget (GTK_DIALOG (shrimp), install_button, 0);
  GTK_WIDGET_SET_FLAGS (install_button, GTK_CAN_DEFAULT);

  g_signal_connect ((gpointer) drives_combo, "changed",
                    G_CALLBACK (on_drives_combo_changed),
                    NULL);
  g_signal_connect ((gpointer) close_button, "clicked",
                    G_CALLBACK (gtk_main_quit),
                    NULL);
  g_signal_connect ((gpointer) install_button, "clicked",
                    G_CALLBACK (on_install_button_clicked),
                    NULL);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (shrimp, shrimp, "shrimp");
  GLADE_HOOKUP_OBJECT_NO_REF (shrimp, dialog_vbox1, "dialog_vbox1");
  GLADE_HOOKUP_OBJECT (shrimp, table2, "table2");
  GLADE_HOOKUP_OBJECT (shrimp, label13, "label13");
  GLADE_HOOKUP_OBJECT (shrimp, current_version, "current_version");
  GLADE_HOOKUP_OBJECT (shrimp, label15, "label15");
  GLADE_HOOKUP_OBJECT (shrimp, label16, "label16");
  GLADE_HOOKUP_OBJECT (shrimp, label17, "label17");
  GLADE_HOOKUP_OBJECT (shrimp, drives_combo, "drives_combo");
  GLADE_HOOKUP_OBJECT (shrimp, target_version, "target_version");
  GLADE_HOOKUP_OBJECT (shrimp, target_partitions, "target_partitions");
  GLADE_HOOKUP_OBJECT (shrimp, status_label, "status_label");
  GLADE_HOOKUP_OBJECT_NO_REF (shrimp, dialog_action_area1, "dialog_action_area1");
  GLADE_HOOKUP_OBJECT (shrimp, close_button, "close_button");
  GLADE_HOOKUP_OBJECT (shrimp, install_button, "install_button");

  return shrimp;
}
Exemple #21
0
int gui_calls_manager_init(SphoneManager *manager)
{
	g_calls_manager.manager=manager;
	g_calls_manager.main_window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(g_calls_manager.main_window),"Active Calls");
	gtk_window_set_deletable(GTK_WINDOW(g_calls_manager.main_window),FALSE);
	gtk_window_set_default_size(GTK_WINDOW(g_calls_manager.main_window),400,220);
	GtkWidget *v1=gtk_vbox_new(FALSE,0);
	GtkWidget *s = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (s),
		       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

	g_calls_manager.dials_view = gtk_tree_view_new();
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(g_calls_manager.dials_view),FALSE);
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;

	renderer = gtk_cell_renderer_pixbuf_new();
	column = gtk_tree_view_column_new_with_attributes("Photo", renderer, "pixbuf", GUI_CALLS_COLUMN_PHOTO, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);

	renderer = gtk_cell_renderer_text_new();
	g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
	column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", GUI_CALLS_COLUMN_DESC, NULL);
	gtk_tree_view_column_set_expand(column,TRUE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", GUI_CALLS_COLUMN_STATUS, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);

	g_calls_manager.dials_store = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_STRING, SPHONE_TYPE_CALL, G_TYPE_STRING, GDK_TYPE_PIXBUF);

	gtk_tree_view_set_model(GTK_TREE_VIEW(g_calls_manager.dials_view), GTK_TREE_MODEL(g_calls_manager.dials_store));

	GtkWidget *h1=gtk_hbox_new(FALSE, 0);
	GtkWidget *h2=gtk_hbox_new(FALSE, 0);
	
	gtk_container_add(GTK_CONTAINER(s), g_calls_manager.dials_view);
	gtk_container_add(GTK_CONTAINER(v1), s);
	gtk_box_pack_start(GTK_BOX(v1), h1, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(v1), h2, FALSE, FALSE, 0);
	gtk_container_add(GTK_CONTAINER(g_calls_manager.main_window), v1);

	gtk_widget_show_all(v1);

	g_calls_manager.answer_button=gtk_button_new_with_label("\nAnswer\n");
	g_calls_manager.answer_waiting_button=gtk_button_new_with_label("\nAnswer\n");
	g_calls_manager.activate_button=gtk_button_new_with_label("\nActivate\n");
	g_calls_manager.hangup_button=gtk_button_new_with_label("\nHangup\n");
	g_calls_manager.mute_button=gtk_button_new_with_label("\nMute ringing\n");
	g_calls_manager.speaker_button=gtk_button_new_with_label("\nSpeaker\n");
	g_calls_manager.handset_button=gtk_button_new_with_label("\nHandset\n");
	gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.activate_button);
	gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_button);
	gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_waiting_button);
	gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.hangup_button);
	gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.mute_button);
	gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.speaker_button);
	gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.handset_button);

	g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"cursor-changed", G_CALLBACK(gui_calls_select_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"row-activated", G_CALLBACK(gui_calls_double_click_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.activate_button),"clicked", G_CALLBACK(gui_calls_activate_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.answer_button),"clicked", G_CALLBACK(gui_calls_answer_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.answer_waiting_button),"clicked", G_CALLBACK(gui_calls_answer_waiting_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.hangup_button),"clicked", G_CALLBACK(gui_calls_hangup_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.mute_button),"clicked", G_CALLBACK(gui_calls_mute_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.speaker_button),"clicked", G_CALLBACK(gui_calls_speaker_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.handset_button),"clicked", G_CALLBACK(gui_calls_handset_callback),NULL);
	g_signal_connect(G_OBJECT(g_calls_manager.main_window),"delete-event", G_CALLBACK(return_true),NULL);

	g_signal_connect(G_OBJECT(manager),"call_added", G_CALLBACK(gui_calls_new_call_callback),NULL);

	return 0;
}
Exemple #22
0
GtkWidget *
do_menus (GtkWidget *do_widget)
{
  static GtkWidget *window = NULL;
  GtkWidget *box;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *button;
  
  if (!window)
    {
      GtkWidget *menubar;
      GtkWidget *menu;
      GtkWidget *menuitem;
      GtkAccelGroup *accel_group;
      
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_screen (GTK_WINDOW (window),
			     gtk_widget_get_screen (do_widget));
      g_signal_connect (window, "destroy",
			G_CALLBACK(gtk_widget_destroyed), &window);
      g_signal_connect (window, "delete-event",
			G_CALLBACK (gtk_true), NULL);
      
      accel_group = gtk_accel_group_new ();
      gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);

      gtk_window_set_title (GTK_WINDOW (window), "menus");
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
      
            
      box = gtk_hbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box);
      gtk_widget_show (box);

      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (box), box1);
      gtk_widget_show (box1);
      
      menubar = gtk_menu_bar_new ();
      gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
      gtk_widget_show (menubar);
      
      menu = create_menu (2, TRUE);
      
      menuitem = gtk_menu_item_new_with_label ("test\nline2");
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);
      
      menuitem = gtk_menu_item_new_with_label ("foo");
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);

      menuitem = gtk_menu_item_new_with_label ("bar");
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
      gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);
      
      box2 = gtk_vbox_new (FALSE, 10);
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
      gtk_widget_show (box2);

      button = gtk_button_new_with_label ("Flip");
      g_signal_connect (button, "clicked",
			G_CALLBACK (change_orientation), menubar);
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
      gtk_widget_show (button);

      button = gtk_button_new_with_label ("Close");
      g_signal_connect_swapped (button, "clicked",
				G_CALLBACK(gtk_widget_destroy), window);
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
      GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
      gtk_widget_grab_default (button);
      gtk_widget_show (button);
    }

  if (!GTK_WIDGET_VISIBLE (window))
    {
      gtk_widget_show (window);
    }
  else
    {
      gtk_widget_destroy (window);
      window = NULL;
    }

  return window;
}
Exemple #23
0
void  l_poimatdok(const char *nomdok,GtkWidget *wpredok)
{
char strsql[512];
iceb_u_str soob;
class poimatdok_data data;
data.nomdok_p.new_plus(nomdok);

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);

sprintf(strsql,"%s %s",name_system,gettext("Поиск документа по номеру"));

gtk_window_set_title (GTK_WINDOW (data.window),strsql);
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(poimatdok_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);

soob.new_plus("");

data.label_kolstr=gtk_label_new (soob.ravno_toutf());


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

gtk_widget_show(vbox1);
gtk_widget_show(vbox2);

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(strsql,"F2 %s",gettext("Просмотр"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
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(poimatdok_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(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
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(poimatdok_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]);

poimatdok_create_list(&data);

gtk_widget_show(data.window);

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

gtk_main();


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


}
/*-----------------------------------------------------------------------------------*/
void
ctk_gtksim_init(int *argc, char **argv[])
{
  GtkWidget *window;
#if 0
  GtkWidget *vbox;
#endif
  
  gtk_init(argc, argv);
  
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(window, "Contiki GTKsim");

#if 0
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER (window), vbox);
  gtk_widget_show(vbox);
#endif
  gtk_signal_connect(GTK_OBJECT (window), "destroy",
		     GTK_SIGNAL_FUNC (quit), NULL);
  
  /* Create the drawing area */

  drawing_area = gtk_drawing_area_new();
  gtk_drawing_area_size(GTK_DRAWING_AREA (drawing_area),
			SCREEN_WIDTH * FONT_WIDTH,
			SCREEN_HEIGHT * FONT_HEIGHT);
#if 0
  gtk_box_pack_start(GTK_BOX(vbox), drawing_area, TRUE, TRUE, 0);
#else
  gtk_container_add(GTK_CONTAINER(window), drawing_area);
#endif

  gtk_widget_show(drawing_area);

  /* Load a fixed width font. */
  /*  font = gdk_font_load("-*-gamow-medium-r-*-*-*-90-*-*-*-*-*-*");*/
  /*  font = gdk_font_load("-*-courier-*-r-normal-*-14-*-*-*-m-*-iso8859-1");*/
  font = gdk_font_load("-*-courier-medium-r-*-*-12-*-*-*-*-*-iso8859-1");
  if(font != NULL) {
    printf("Font loaded OK\n");
  } else {
    printf("Font loading failed\n");
    exit(1);
  }

  
  /* Signals used to handle backing pixmap */

  gtk_signal_connect(GTK_OBJECT (drawing_area), "expose_event",
		     (GtkSignalFunc) expose_event, NULL);
  gtk_signal_connect(GTK_OBJECT (drawing_area), "configure_event",
		     (GtkSignalFunc) configure_event, NULL);

  /* Event signals */

  gtk_signal_connect(GTK_OBJECT (window), "key_press_event",
		     (GtkSignalFunc) key_press_event, NULL);
  gtk_signal_connect(GTK_OBJECT (window), "key_release_event",
		     (GtkSignalFunc) key_release_event, NULL);

  gtk_signal_connect(GTK_OBJECT (drawing_area), "motion_notify_event",
		     (GtkSignalFunc) motion_notify_event, NULL);

  gtk_signal_connect(GTK_OBJECT (drawing_area), "button_press_event",
		     (GtkSignalFunc) button_press_event, NULL);

  gtk_signal_connect(GTK_OBJECT (drawing_area), "button_release_event",
		     (GtkSignalFunc) button_release_event, NULL);

  gtk_widget_set_events(drawing_area, gtk_widget_get_events (drawing_area) 
			| GDK_KEY_PRESS_MASK
			| GDK_KEY_RELEASE_MASK
			| GDK_POINTER_MOTION_MASK
			| GDK_BUTTON_PRESS_MASK
			| GDK_BUTTON_RELEASE_MASK);

  gtk_widget_show(window);

}
Exemple #25
0
bool wxTopLevelWindowGTK::Create( wxWindow *parent,
                                  wxWindowID id,
                                  const wxString& title,
                                  const wxPoint& pos,
                                  const wxSize& sizeOrig,
                                  long style,
                                  const wxString &name )
{
    // always create a frame of some reasonable, even if arbitrary, size (at
    // least for MSW compatibility)
    wxSize size = sizeOrig;
    size.x = WidthDefault(size.x);
    size.y = HeightDefault(size.y);

    wxTopLevelWindows.Append( this );

    if (!PreCreation( parent, pos, size ) ||
        !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
    {
        wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
        return false;
    }

    m_title = title;

    // NB: m_widget may be !=NULL if it was created by derived class' Create,
    //     e.g. in wxTaskBarIconAreaGTK
    if (m_widget == NULL)
    {
#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
        // we must create HildonWindow and not a normal GtkWindow as the latter
        // doesn't look correctly in Maemo environment and it must also be
        // registered with the main program object
        m_widget = hildon_window_new();
        hildon_program_add_window(wxTheApp->GetHildonProgram(),
                                  HILDON_WINDOW(m_widget));
#else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
        m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
        {
            // Tell WM that this is a dialog window and make it center
            // on parent by default (this is what GtkDialog ctor does):
            gtk_window_set_type_hint(GTK_WINDOW(m_widget),
                                     GDK_WINDOW_TYPE_HINT_DIALOG);
            gtk_window_set_position(GTK_WINDOW(m_widget),
                                    GTK_WIN_POS_CENTER_ON_PARENT);
        }
        else
        {
            if (style & wxFRAME_TOOL_WINDOW)
            {
                gtk_window_set_type_hint(GTK_WINDOW(m_widget),
                                         GDK_WINDOW_TYPE_HINT_UTILITY);

                // On some WMs, like KDE, a TOOL_WINDOW will still show
                // on the taskbar, but on Gnome a TOOL_WINDOW will not.
                // For consistency between WMs and with Windows, we
                // should set the NO_TASKBAR flag which will apply
                // the set_skip_taskbar_hint if it is available,
                // ensuring no taskbar entry will appear.
                style |= wxFRAME_NO_TASKBAR;
            }
        }
#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2

        g_object_ref(m_widget);
    }

    wxWindow *topParent = wxGetTopLevelParent(m_parent);
    if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
                       (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
                       (style & wxFRAME_FLOAT_ON_PARENT)))
    {
        gtk_window_set_transient_for( GTK_WINDOW(m_widget),
                                      GTK_WINDOW(topParent->m_widget) );
    }

    if (style & wxFRAME_NO_TASKBAR)
    {
        gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
    }

    if (style & wxSTAY_ON_TOP)
    {
        gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
    }
    if (style & wxMAXIMIZE)
        gtk_window_maximize(GTK_WINDOW(m_widget));

#if 0
    if (!name.empty())
        gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
#endif

    gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
    gtk_widget_set_can_focus(m_widget, false);

    g_signal_connect (m_widget, "delete_event",
                      G_CALLBACK (gtk_frame_delete_callback), this);

    // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
    m_mainWidget = gtk_vbox_new(false, 0);
    gtk_widget_show( m_mainWidget );
    gtk_widget_set_can_focus(m_mainWidget, false);
    gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );

    // m_wxwindow is the client area
    m_wxwindow = wxPizza::New();
    gtk_widget_show( m_wxwindow );
    gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );

    // we donm't allow the frame to get the focus as otherwise
    // the frame will grab it at arbitrary focus changes
    gtk_widget_set_can_focus(m_wxwindow, false);

    if (m_parent) m_parent->AddChild( this );

    g_signal_connect(m_wxwindow, "size_allocate",
        G_CALLBACK(size_allocate), this);

    g_signal_connect (m_widget, "size_request",
                      G_CALLBACK (wxgtk_tlw_size_request_callback), this);
    PostCreation();

#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
    if ((m_x != -1) || (m_y != -1))
        gtk_widget_set_uposition( m_widget, m_x, m_y );
#endif

    // for some reported size corrections
    g_signal_connect (m_widget, "map_event",
                      G_CALLBACK (gtk_frame_map_callback), this);

    // for iconized state
    g_signal_connect (m_widget, "window_state_event",
                      G_CALLBACK (gtk_frame_window_state_callback), this);


    // for wxMoveEvent
    g_signal_connect (m_widget, "configure_event",
                      G_CALLBACK (gtk_frame_configure_callback), this);

    // activation
    g_signal_connect_after (m_widget, "focus_in_event",
                      G_CALLBACK (gtk_frame_focus_in_callback), this);
    g_signal_connect_after (m_widget, "focus_out_event",
                      G_CALLBACK (gtk_frame_focus_out_callback), this);

    gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
    g_signal_connect(m_widget, "property_notify_event",
        G_CALLBACK(property_notify_event), this);

    // translate wx decorations styles into Motif WM hints (they are recognized
    // by other WMs as well)

    // always enable moving the window as we have no separate flag for enabling
    // it
    m_gdkFunc = GDK_FUNC_MOVE;

    if ( style & wxCLOSE_BOX )
        m_gdkFunc |= GDK_FUNC_CLOSE;

    if ( style & wxMINIMIZE_BOX )
        m_gdkFunc |= GDK_FUNC_MINIMIZE;

    if ( style & wxMAXIMIZE_BOX )
        m_gdkFunc |= GDK_FUNC_MAXIMIZE;

    if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) )
    {
        m_gdkDecor = 0;
    }
    else // have border
    {
        m_gdkDecor = GDK_DECOR_BORDER;

        if ( style & wxCAPTION )
            m_gdkDecor |= GDK_DECOR_TITLE;

        if ( style & wxSYSTEM_MENU )
            m_gdkDecor |= GDK_DECOR_MENU;

        if ( style & wxMINIMIZE_BOX )
            m_gdkDecor |= GDK_DECOR_MINIMIZE;

        if ( style & wxMAXIMIZE_BOX )
            m_gdkDecor |= GDK_DECOR_MAXIMIZE;

        if ( style & wxRESIZE_BORDER )
        {
           m_gdkFunc |= GDK_FUNC_RESIZE;
           m_gdkDecor |= GDK_DECOR_RESIZEH;
        }
    }

    m_decorSize = GetCachedDecorSize();
    int w, h;
    GTKDoGetSize(&w, &h);
    gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);

    return true;
}
Exemple #26
0
static void home_window_construct (GenesisController *controller)
{
  GtkWidget *window;
  GtkWidget *hbox, *vbox;
  GtkWidget *app_treeview, *cat_treeview;
  GtkWidget *scrolledwindow;
  GtkTreeModel *app_model, *cat_model;
  GtkTreeSelection *app_selection, *cat_selection;
  GtkWidget *textview, *button;
  GenesisAppEntry *entry = NULL;
  guint n = 0;
  GList *cat_list;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "Genesis Face");
  g_signal_connect (G_OBJECT (window), "delete-event",  (GCallback) gtk_main_quit, NULL);

  hbox = gtk_hbox_new (FALSE,0);
  gtk_container_add (GTK_CONTAINER (window), hbox);

  vbox = gtk_vbox_new (FALSE,0);
  gtk_box_pack_end (GTK_BOX(hbox), vbox, FALSE, FALSE, 0);

  textview = gtk_text_view_new ();
  gtk_box_pack_start (GTK_BOX(vbox), textview, FALSE, FALSE, 0);

  scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), 
                                  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
  gtk_box_pack_end (GTK_BOX(hbox), scrolledwindow, FALSE, FALSE, 0);

  app_treeview = gtk_tree_view_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (app_treeview),
                                               -1, "Applications",
                                               gtk_cell_renderer_text_new(),
                                               "text", 0, NULL);
  app_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (app_treeview));

  gtk_tree_selection_set_mode (app_selection, GTK_SELECTION_SINGLE);
  g_signal_connect (G_OBJECT (app_selection), "changed",
                    G_CALLBACK (app_selection_changed_callback), textview);
  gtk_container_add (GTK_CONTAINER (scrolledwindow), app_treeview);

  app_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
  gtk_tree_view_set_model (GTK_TREE_VIEW(app_treeview), app_model);

  do
  {
    entry = genesis_controller_get_nth_entry (controller, n++);
    if (entry)
    {
      gchar *entry_name = genesis_app_entry_get_name (entry);

      tree_view_append_entry (app_model, entry_name);
    }
  }while (entry);

  cat_list = genesis_controller_get_categories (controller);

  if (!cat_list)
    g_print ("failed to get categories list.\n");
  else
  {
    GList *tmp;

    scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), 
                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_end (GTK_BOX(hbox), scrolledwindow, FALSE, FALSE, 0);

    cat_treeview = gtk_tree_view_new ();
    gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (cat_treeview),
                                                 -1, "Categories",
                                                 gtk_cell_renderer_text_new(),
                                                 "text", 0, NULL);
    cat_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (cat_treeview));

    gtk_tree_selection_set_mode (cat_selection, GTK_SELECTION_SINGLE);
    g_signal_connect (G_OBJECT (cat_selection), "changed",
                      G_CALLBACK (cat_selection_changed_callback), app_treeview);
    gtk_container_add (GTK_CONTAINER (scrolledwindow), cat_treeview);

    cat_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
    gtk_tree_view_set_model (GTK_TREE_VIEW(cat_treeview), cat_model);

    tmp = cat_list;
    while (tmp) 
    {
      GenesisCategory *category = tmp->data;
      tree_view_append_entry (cat_model, category->name);
      tmp = tmp->next;
    }
    g_list_free(cat_list);
  }

  button = gtk_button_new_with_label ("Start");

  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (start_button_clicked_callback), app_treeview);

  gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);

  gtk_widget_show_all (window);
}
Exemple #27
0
int main( int
	  argc,
	  char *argv[] )
{
/* GtkWidget 是构件的存储类型 */
	GtkWidget *window;
	GtkWidget *button;
	GtkWidget *box1;
	GtkWidget *buttonA;
/* 这个函数在所有的 GTK 程序都要调用。参数由命令行中解析出来并且送
   到该程序中。*/
	gtk_init (&argc, &argv);/* 创建一个新窗口 */
	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* 这是一个新的调用,设置窗口标题为"Hello Buttons!" */
	gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");
/* 在这里我们为 delete_event 设置了一个处理函数来立即退出 GTK。*/
	g_signal_connect (G_OBJECT (window), "delete_event",
			  G_CALLBACK (delete_event), NULL);
/* 设置窗口边框的宽度。 */
	gtk_container_set_border_width (GTK_CONTAINER (window), 10);
	gtk_widget_set_usize((window),300,150);  

/* 我们创建了一个组装盒。详情参见“组装”章节。
 * 我们看不见组装盒,它仅被作为排列构件的工具。*/
	box1 = gtk_vbox_new (FALSE, 0);
/* 把组装盒放入主窗口中。*/
	gtk_container_add (GTK_CONTAINER (window), box1);
/* 创建一个标签为 "Button 1" 的新按钮。*/
	button = gtk_button_new_with_label ("Button 1");
/* 当按钮被按下时,我们调用 "callback" 函数,并将一个指向 "button
   1" 的
   * 指针作为它的参数。*/
	g_signal_connect (G_OBJECT (button), "clicked",
			  G_CALLBACK (callback), "button 1");
/* 代替 gtk_container_add,我们把按钮放入不可见的组装盒,该组合盒
   已经组
   * 装进窗口中了。*/
	gtk_box_pack_start (GTK_BOX(box1), button, TRUE, FALSE , 0);
/* 总是记住这一步,它告诉 GTK 我们为这个按钮做的准备工作已经完成
   了,现
   * 在可以显示它了。*/
	gtk_widget_show (button);
/* 同样创建第二个按钮。*/
	button = gtk_button_new_with_label ("Button 2");
/* 以不同的参数调用相同的回调函数,用指向 "button 2" 的指针代替。*/
	g_signal_connect (G_OBJECT (button), "clicked",
			  G_CALLBACK (callback), "button 2");
	gtk_widget_show (button);

	
	gtk_box_pack_start(GTK_BOX (box1), button, TRUE, FALSE , 0);
	buttonA = gtk_button_new_with_label ("Button A");
	g_signal_connect (G_OBJECT (buttonA), "clicked",
			  G_CALLBACK (callback), "button A");
	gtk_box_pack_start(GTK_BOX (box1), buttonA, TRUE , FALSE , 0);

/* 显示的顺序并不重要,但我建议最后显示窗口。这样它们会同时显示出
   来。*/

	gtk_widget_show (buttonA);
	gtk_widget_show (box1);
	gtk_widget_show (window);
/* 停在这里等待事件发生。*/
	gtk_main ();
	return 0;
}
/*----------导入功能up----------------------------------------------------------------*/
void create_view(GtkWidget *container,gpointer data)//容器管理的主界面
{
	GtkTreeViewColumn *column22;
	GtkTreeViewColumn *column33;
	GtkTreeViewColumn *column44;
	GtkWidget *window;
	//GtkWidget *combox_images;
	GtkBuilder *builder;
	GtkTreeIter iter;
	GtkWidget *button11;
	GtkWidget *button22;
	GtkWidget *button33;
	GtkWidget *button44;
	GtkWidget *button55;
	GtkWidget *button66;
	GtkWidget *button77;
	GtkWidget *button88;
	GtkWidget *button99;
	GtkWidget *button110;
	
	GtkCellRenderer *cell11;
	GtkListStore *list11;
	
	GtkCellRenderer *cell;
	GtkTreeSelection *selection;
	static int j;
	docker_contain();
	builder=gtk_builder_new ();
	gtk_builder_add_from_file (builder,CONTAINER_MANAGE_FILE,NULL);
	window=GTK_WIDGET(gtk_builder_get_object (builder,CONTAINER_MANAGE_WINDOW));
	gtk_window_set_title (window,_("contians manage"));
	gtk_widget_set_name(window, "nfs_container_mange_window");
	button11=GTK_WIDGET(gtk_builder_get_object (builder,"button1"));
	button22=GTK_WIDGET(gtk_builder_get_object (builder,"button2"));
	button33=GTK_WIDGET(gtk_builder_get_object (builder,"button3"));
	button44=GTK_WIDGET(gtk_builder_get_object (builder,"button4"));
	button55=GTK_WIDGET(gtk_builder_get_object (builder,"button5"));
	button66=GTK_WIDGET(gtk_builder_get_object (builder,"button6"));
	button77=GTK_WIDGET(gtk_builder_get_object (builder,"button7"));
	button88=GTK_WIDGET(gtk_builder_get_object (builder,"button8"));
	button99=GTK_WIDGET(gtk_builder_get_object (builder,"button9"));
	button110=GTK_WIDGET(gtk_builder_get_object (builder,"button10"));
	
	column22=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn1"));
	column33=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn2"));
	column44=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn3"));
	gtk_tree_view_column_set_title (column22,_("Mirror image"));
	cell=gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column22, cell,FALSE);
	gtk_tree_view_column_set_attributes(column22,cell,"text",0,NULL);
	
	gtk_tree_view_column_set_title (column33,"ID");
	cell=gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column33,cell,FALSE);
	gtk_tree_view_column_set_attributes(column33,cell,"text",1,NULL);
	
	gtk_tree_view_column_set_title (column44,_("name_colum"));
	cell=gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column44,cell,FALSE);
	gtk_tree_view_column_set_attributes(column44,cell,"text",2,NULL);
	
	gtk_button_set_label (GTK_BUTTON(button11),_("starting contain and enter"));
	
	gtk_button_set_label (GTK_BUTTON(button22),_("stop contian"));
         gtk_button_set_label (GTK_BUTTON(button33),_("create gurd contian"));
         gtk_button_set_label (GTK_BUTTON(button44),_("create contian"));
         gtk_button_set_label (GTK_BUTTON(button55),_("export"));
	
	gtk_button_set_label (GTK_BUTTON(button66),_("ls starting contain"));
	gtk_button_set_label (GTK_BUTTON(button77),_("ls gurd contain"));
	gtk_button_set_label (GTK_BUTTON(button88),_("dele on contian"));
	gtk_button_set_label (GTK_BUTTON(button99),_("dele mul contians"));
	gtk_button_set_label (GTK_BUTTON(button110),_("import"));
	
	tree_view=GTK_WIDGET(gtk_builder_get_object (builder,"treeview1"));
	list11=gtk_list_store_new (4, G_TYPE_STRING,G_TYPE_STRING, G_TYPE_STRING,G_TYPE_STRING);
	gtk_tree_view_set_model (GTK_TREE_VIEW(tree_view),GTK_TREE_MODEL(list11));
	selection=gtk_tree_view_get_selection (GTK_TREE_VIEW(tree_view));

	

	
	//mod=gtk_tree_view_get_model (GTK_TREE_VIEW(tree_view));
	g_signal_connect(G_OBJECT(tree_view),"cursor-changed",G_CALLBACK(clicked_row11),selection);
	//g_signal_connect(G_OBJECT(selection),"changed",G_CALLBACK(clicked_row11),selection);
	g_signal_connect(G_OBJECT(button11),"clicked",G_CALLBACK(button11_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button88),"clicked",G_CALLBACK(button88_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button44),"clicked",G_CALLBACK(button44_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button33),"clicked",G_CALLBACK(button33_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button99),"clicked",G_CALLBACK(button99_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button66),"clicked",G_CALLBACK(button33_fun),"docker ps");
	g_signal_connect(G_OBJECT(button22),"clicked",G_CALLBACK(button22_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button110),"clicked",G_CALLBACK(import_selcet_file),window);
	g_signal_connect(G_OBJECT(button55),"clicked",G_CALLBACK(export_selcet_file),selection);
	g_signal_connect(G_OBJECT(button77),"clicked",G_CALLBACK(button77_lsgurd_fun),window);
	
		for(j=0;j<contains_num;j++){
	gtk_list_store_append (list11,&iter);
	gtk_list_store_set (list11, &iter, 0,&a[j].image,-1);
	gtk_list_store_set (list11, &iter, 1,&a[j].id,-1);
	gtk_list_store_set (list11, &iter, 2,&a[j].name,-1);
		}
	
	g_object_unref (builder);
	
	gtk_widget_show_all (window);
	//return tree_view;

}
Exemple #29
0
void l_uosamort(int innom,int podr,const char *hzt,const char *hna,GtkWidget *wpredok)
{
class l_uosamort_data data;
char bros[512];
char strsql[512];
SQL_str row;
class SQLCURSOR cur;

data.innom=innom;
data.podr=podr;
data.hzt.new_plus(hzt);
data.hna.new_plus(hna);
data.naim.plus("");
iceb_u_poltekdat(&data.dr,&data.mr,&data.gr);
data.dr=1;
sprintf(strsql,"bsiz%d.lst",getpid());
data.imafprot.new_plus(strsql);
sprintf(strsql,"bsizam%d.lst",getpid());
data.imafprot_ao.new_plus(strsql);

/*узнаём наименование*/
sprintf(strsql,"select naim from Uosin where innom=%d",innom);
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
 data.naim.new_plus(row[0]);
  
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);


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_uosamort_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, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 1);
gtk_widget_show(hbox);

class iceb_u_str zagol;
zagol.plus(gettext("Амортизационные отчисления налогового учёта"));
zagol.ps_plus(gettext("Инвентарный номер"));
zagol.plus(":");
zagol.plus(data.innom);
zagol.plus("/");
zagol.plus(data.naim.ravno());

data.label_kolstr=gtk_label_new(zagol.ravno_toutf());


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

gtk_widget_show(vbox1);
gtk_widget_show(vbox2);




data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200);

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, 1);

data.label_bsiz=gtk_label_new("");
gtk_box_pack_start(GTK_BOX (vbox2), data.label_bsiz, FALSE, FALSE, 1);
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.label_bsiz),font_pango);
pango_font_description_free(font_pango);

gtk_widget_show(data.label_bsiz);

//Кнопки
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(l_uosamort_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_uosamort_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_uosamort_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,"F4 %s",gettext("Расчёт"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(l_uosamort_knopka),&data);
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(l_uosamort_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,"F6 %s",gettext("Документы"));
data.knopka[FK6]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK6],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK6]), "clicked",GTK_SIGNAL_FUNC(l_uosamort_knopka),&data);
tooltips[FK6]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK6],data.knopka[FK6],gettext("Получить список документов"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK6]),(gpointer)FK6);
gtk_widget_show(data.knopka[FK6]);

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(l_uosamort_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,"F8 %s",gettext("Смена даты"));
data.knopka[FK8]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK8],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK8]), "clicked",GTK_SIGNAL_FUNC(l_uosamort_knopka),&data);
tooltips[FK8]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK8],data.knopka[FK8],gettext("Сменить дату на которую рассчитать остаточную стоимость"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK8]),(gpointer)FK8);
gtk_widget_show(data.knopka[FK8]);


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_uosamort_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_uosamort_create_list(&data);
gtk_widget_show(data.window);

/*if(metka == 0)*/
  gtk_window_maximize(GTK_WINDOW(data.window));


gtk_main();

unlink(data.imafprot.ravno());
unlink(data.imafprot_ao.ravno());

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


}
Exemple #30
0
/***
 *** Creates the simple application window with one
 *** drawing area that has an OpenGL-capable visual.
 ***/
static GtkWidget *
create_window (GdkGLConfig *glconfig)
{
  GtkWidget *window;
  GtkWidget *vbox;
  GtkWidget *drawing_area;
  GtkWidget *menu;
  GtkWidget *button;

  /*
   * Top-level window.
   */

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), DEFAULT_TITLE);

  /* Get automatically redrawn if any of their children changed allocation. */
  gtk_container_set_reallocate_redraws (GTK_CONTAINER (window), TRUE);

  /* Connect signal handlers to the window */
  g_signal_connect (G_OBJECT (window), "delete_event",
		    G_CALLBACK (gtk_main_quit), NULL);

  /*
   * VBox.
   */

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

  /*
   * Drawing area to draw OpenGL scene.
   */

  drawing_area = gtk_drawing_area_new ();
  gtk_widget_set_size_request (drawing_area, DEFAULT_WIDTH, DEFAULT_HEIGHT);

  /* Set OpenGL-capability to the widget */
  gtk_widget_set_gl_capability (drawing_area,
				glconfig,
				NULL,
				TRUE,
				GDK_GL_RGBA_TYPE);

  gtk_widget_add_events (drawing_area,
			 GDK_BUTTON1_MOTION_MASK    |
			 GDK_BUTTON2_MOTION_MASK    |
			 GDK_BUTTON_PRESS_MASK      |
			 GDK_VISIBILITY_NOTIFY_MASK);

  /* Connect signal handlers to the drawing area */
  g_signal_connect_after (G_OBJECT (drawing_area), "realize",
                          G_CALLBACK (realize), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "configure_event",
		    G_CALLBACK (configure_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "draw",
		    G_CALLBACK (draw), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "unrealize",
		    G_CALLBACK (unrealize), NULL);

  g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event",
		    G_CALLBACK (motion_notify_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "button_press_event",
		    G_CALLBACK (button_press_event), NULL);

  /* key_press_event handler for top-level window */
  g_signal_connect_swapped (G_OBJECT (window), "key_press_event",
			    G_CALLBACK (key_press_event), drawing_area);

  /* For timeout function. */
  g_signal_connect (G_OBJECT (drawing_area), "map_event",
		    G_CALLBACK (map_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
		    G_CALLBACK (unmap_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
		    G_CALLBACK (visibility_notify_event), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);

  gtk_widget_show (drawing_area);

  /*
   * Popup menu.
   */

  menu = create_popup_menu (drawing_area);

  g_signal_connect_swapped (G_OBJECT (drawing_area), "button_press_event",
			    G_CALLBACK (button_press_event_popup_menu), menu);

  /*
   * Simple quit button.
   */

  button = gtk_button_new_with_label ("Quit");

  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (gtk_main_quit), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

  gtk_widget_show (button);

  return window;
}