static void dlg_extract__common (FrWindow *window, GList *selected_files, char *base_dir_for_selection) { DialogData *data; data = g_new0 (DialogData, 1); data->settings = g_settings_new (FILE_ROLLER_SCHEMA_EXTRACT); data->window = window; data->selected_files = selected_files; data->base_dir_for_selection = base_dir_for_selection; data->extract_clicked = FALSE; data->dialog = gtk_file_chooser_dialog_new (C_("Window title", "Extract"), GTK_WINDOW (data->window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL, _GTK_LABEL_EXTRACT, GTK_RESPONSE_OK, NULL); gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (data->dialog), FALSE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->dialog), FALSE); gtk_file_chooser_set_create_folders (GTK_FILE_CHOOSER (data->dialog), TRUE); gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK); data->builder = _gtk_builder_new_from_resource ("extract-dialog-options.ui"); if (data->builder == NULL) return; gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (data->dialog), GET_WIDGET ("extra_widget")); /* Set widgets data. */ gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (data->dialog), fr_window_get_extract_default_dir (window), NULL); if (data->selected_files != NULL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("selected_files_radiobutton")), TRUE); else { gtk_widget_set_sensitive (GET_WIDGET ("selected_files_radiobutton"), FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("all_files_radiobutton")), TRUE); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_newer_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_structure_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS)); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (file_selector_destroy_cb), data); g_signal_connect (G_OBJECT (data->dialog), "response", G_CALLBACK (file_selector_response_cb), data); g_signal_connect (G_OBJECT (GET_WIDGET ("file_pattern_entry")), "changed", G_CALLBACK (files_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_modal (GTK_WINDOW (data->dialog),TRUE); gtk_widget_show (data->dialog); }
void gtkui_help(void) { GtkWidget *dialog, *scrolled, *treeview, *hbox, *textview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; help_pair *section; DEBUG_MSG("gtkui_help"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Help", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 780, 580); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), TRUE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, FALSE, FALSE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (treeview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK (gtkui_help_selected), liststore); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Contents", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); liststore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); for(section = help_list; section->title; section++) { gtk_list_store_append (liststore, &iter); gtk_list_store_set (liststore, &iter, 0, section->title, 1, section->file, -1); } gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore)); /* text area */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), textview); gtk_widget_show(textview); textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)); gtk_widget_show_all(hbox); gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
/* Object initialization * Create private structure and set up default values */ static void nojs_preferences_init(NoJSPreferences *self) { NoJSPreferencesPrivate *priv; GtkTreeSortable *sortableList; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *widget; gchar *dialogTitle; GtkWidget *scrolled; GtkWidget *vbox; GtkWidget *hbox; gint width, height; GtkListStore *list; GtkTreeIter listIter; priv=self->priv=NOJS_PREFERENCES_GET_PRIVATE(self); /* Set up default values */ priv->manager=NULL; /* Get content area to add gui controls to */ priv->contentArea=gtk_dialog_get_content_area(GTK_DIALOG(self)); #if GTK_CHECK_VERSION (3, 0, 0) vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE); #else vbox=gtk_vbox_new(FALSE, 0); #endif /* Set up dialog */ dialogTitle=_("Configure NoJS"); gtk_window_set_title(GTK_WINDOW(self), dialogTitle); gtk_window_set_icon_name(GTK_WINDOW(self), GTK_STOCK_PROPERTIES); sokoke_widget_get_text_size(GTK_WIDGET(self), "M", &width, &height); gtk_window_set_default_size(GTK_WINDOW(self), width*52, -1); widget=sokoke_xfce_header_new(gtk_window_get_icon_name(GTK_WINDOW(self)), dialogTitle); if(widget) gtk_box_pack_start(GTK_BOX(priv->contentArea), widget, FALSE, FALSE, 0); gtk_dialog_add_button(GTK_DIALOG(self), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); /* Set up description */ widget=gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(widget), _("Below is a list of all web sites and the policy set for them. " "You can delete policies by marking the entries and clicking on <i>Delete</i>.")); gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 4); /* Set up domain list */ priv->listStore=gtk_list_store_new(N_COLUMN, G_TYPE_STRING, /* DOMAIN_COLUMN */ G_TYPE_STRING /* POLICY_COLUMN */); sortableList=GTK_TREE_SORTABLE(priv->listStore); gtk_tree_sortable_set_sort_func(sortableList, DOMAIN_COLUMN, (GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback, GINT_TO_POINTER(DOMAIN_COLUMN), NULL); gtk_tree_sortable_set_sort_func(sortableList, POLICY_COLUMN, (GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback, GINT_TO_POINTER(POLICY_COLUMN), NULL); gtk_tree_sortable_set_sort_column_id(sortableList, DOMAIN_COLUMN, GTK_SORT_ASCENDING); /* Set up domain addition widgets */ #ifdef HAVE_GTK3 hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE); #else hbox=gtk_hbox_new(FALSE, 0); #endif priv->addDomainEntry=gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(priv->addDomainEntry), 64); gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainEntry); g_signal_connect_swapped(priv->addDomainEntry, "changed", G_CALLBACK(_nojs_preferences_on_add_domain_entry_changed), self); list=gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING); gtk_list_store_append(list, &listIter); gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT, 1, _("Accept"), -1); gtk_list_store_append(list, &listIter); gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT_TEMPORARILY, 1, _("Accept for session"), -1); gtk_list_store_append(list, &listIter); gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_BLOCK, 1, _("Block"), -1); priv->addDomainPolicyCombo=gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); gtk_combo_box_set_active(GTK_COMBO_BOX(priv->addDomainPolicyCombo), 0); gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainPolicyCombo); renderer=gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, TRUE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, "text", 1); priv->addDomainButton=gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_widget_set_sensitive(priv->addDomainButton, FALSE); gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainButton); g_signal_connect_swapped(priv->addDomainButton, "clicked", G_CALLBACK(_nojs_preferences_on_add_domain_clicked), self); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); /* Set up domain list view */ priv->list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(priv->listStore)); #if !GTK_CHECK_VERSION (3, 0, 0) gtk_widget_set_size_request(priv->list, -1, 300); #endif priv->listSelection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->list)); gtk_tree_selection_set_mode(priv->listSelection, GTK_SELECTION_MULTIPLE); g_signal_connect_swapped(priv->listSelection, "changed", G_CALLBACK(_nojs_preferences_changed_selection), self); renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(_("Domain"), renderer, "text", DOMAIN_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, DOMAIN_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column); renderer=gtk_cell_renderer_combo_new(); g_object_set(G_OBJECT(renderer), "model", list, "text-column", 1, "has-entry", false, "editable", true, NULL); g_signal_connect_swapped(renderer, "editing-started", G_CALLBACK(_nojs_preferences_on_policy_editing_started), self); g_signal_connect_swapped(renderer, "editing-canceled", G_CALLBACK(_nojs_preferences_on_policy_editing_canceled), self); g_signal_connect_swapped(renderer, "edited", G_CALLBACK(_nojs_preferences_on_policy_edited), self); column=gtk_tree_view_column_new_with_attributes(_("Policy"), renderer, "text", POLICY_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, POLICY_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column); scrolled=gtk_scrolled_window_new(NULL, NULL); #if GTK_CHECK_VERSION (3, 0, 0) gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), height*10); #endif gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled), priv->list); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 5); /* Set up JavaScript domain list management buttons */ #if GTK_CHECK_VERSION (3, 0, 0) hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE); #else hbox=gtk_hbox_new(FALSE, 0); #endif priv->deleteButton=gtk_button_new_from_stock(GTK_STOCK_DELETE); gtk_widget_set_sensitive(priv->deleteButton, FALSE); gtk_container_add(GTK_CONTAINER(hbox), priv->deleteButton); g_signal_connect_swapped(priv->deleteButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_selection), self); priv->deleteAllButton=gtk_button_new_with_mnemonic(_("Delete _all")); gtk_button_set_image(GTK_BUTTON(priv->deleteAllButton), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON)); gtk_widget_set_sensitive(priv->deleteAllButton, FALSE); gtk_container_add(GTK_CONTAINER(hbox), priv->deleteAllButton); g_signal_connect_swapped(priv->deleteAllButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_all), self); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); /* Add "allow-all-sites" checkbox */ priv->allowAllSitesCheckbox=gtk_check_button_new_with_mnemonic(_("A_llow scripts at all sites")); priv->signalAllowAllSitesToggledID=g_signal_connect_swapped(priv->allowAllSitesCheckbox, "toggled", G_CALLBACK(_nojs_preferences_on_allow_all_sites_changed), self); gtk_box_pack_start(GTK_BOX(vbox), priv->allowAllSitesCheckbox, FALSE, TRUE, 5); /* Add "block-unknown-domains" checkbox */ priv->blockUnknownDomainsCheckbox=gtk_check_button_new_with_mnemonic(_("Bloc_k scripts at unknown domains by default")); priv->signalBlockUnknownDomainsToggledID=g_signal_connect_swapped(priv->blockUnknownDomainsCheckbox, "toggled", G_CALLBACK(_nojs_preferences_on_block_unknown_domains_changed), self); gtk_box_pack_start(GTK_BOX(vbox), priv->blockUnknownDomainsCheckbox, FALSE, TRUE, 5); /* Add "check-second-level-only" checkbox */ priv->checkSecondLevelOnlyCheckbox=gtk_check_button_new_with_mnemonic(_("S_et permissions on second-level domain")); priv->signalCheckSecondLevelOnlyToggledID=g_signal_connect_swapped(priv->checkSecondLevelOnlyCheckbox, "toggled", G_CALLBACK(_nojs_preferences_on_check_second_level_only_changed), self); gtk_box_pack_start(GTK_BOX(vbox), priv->checkSecondLevelOnlyCheckbox, FALSE, TRUE, 5); /* Finalize setup of content area */ gtk_box_pack_start(GTK_BOX(priv->contentArea), vbox, TRUE, TRUE, 0); }
gint _vala_main (gchar** args, int args_length1) { gint result = 0; Block1Data* _data1_; GtkHeaderBar* headerbar = NULL; GtkHeaderBar* _tmp0_ = NULL; GtkWindow* window = NULL; GtkWindow* _tmp1_ = NULL; GtkGrid* grid = NULL; GtkGrid* _tmp2_ = NULL; GtkButton* _tmp3_ = NULL; GtkGrid* gridtwo = NULL; GtkGrid* _tmp4_ = NULL; GtkLabel* _tmp5_ = NULL; GtkLabel* _tmp6_ = NULL; GtkLabel* _tmp7_ = NULL; GtkLabel* _tmp8_ = NULL; GtkLabel* _tmp9_ = NULL; GtkLabel* _tmp10_ = NULL; GtkLabel* _tmp11_ = NULL; GtkLabel* _tmp12_ = NULL; GtkGrid* layout = NULL; GtkGrid* _tmp13_ = NULL; GtkButton* _tmp14_ = NULL; GtkLabel* _tmp15_ = NULL; GtkButton* rotate_button = NULL; GtkButton* _tmp16_ = NULL; GtkLabel* _tmp17_ = NULL; #line 20 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _data1_ = g_slice_new0 (Block1Data); #line 20 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _data1_->_ref_count_ = 1; #line 21 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_init (&args_length1, &args); #line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp0_ = (GtkHeaderBar*) gtk_header_bar_new (); #line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp0_); #line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" headerbar = _tmp0_; #line 25 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_header_bar_set_show_close_button (headerbar, TRUE); #line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp1_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL); #line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp1_); #line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" window = _tmp1_; #line 29 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_window_set_titlebar (window, (GtkWidget*) headerbar); #line 30 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_window_set_title (window, "Hello Again Again Again!"); #line 31 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_set_border_width ((GtkContainer*) window, (guint) 12); #line 32 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_window_set_position (window, GTK_WIN_POS_CENTER); #line 33 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_window_set_default_size (window, 350, 350); #line 34 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_signal_connect ((GtkWidget*) window, "destroy", (GCallback) _gtk_main_quit_gtk_widget_destroy, NULL); #line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp2_ = (GtkGrid*) gtk_grid_new (); #line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp2_); #line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" grid = _tmp2_; #line 38 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_orientable_set_orientation ((GtkOrientable*) grid, GTK_ORIENTATION_VERTICAL); #line 39 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_set_row_spacing (grid, 6); #line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp3_ = (GtkButton*) gtk_button_new_with_label ("testing"); #line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp3_); #line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _data1_->button = _tmp3_; #line 43 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_signal_connect_data (_data1_->button, "clicked", (GCallback) ___lambda3__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0); #line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp4_ = (GtkGrid*) gtk_grid_new (); #line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp4_); #line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gridtwo = _tmp4_; #line 53 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_set_column_spacing (gridtwo, 6); #line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp5_ = (GtkLabel*) gtk_label_new ("Label 1"); #line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp5_); #line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp6_ = _tmp5_; #line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _tmp6_); #line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (_tmp6_); #line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp7_ = (GtkLabel*) gtk_label_new ("Label 2"); #line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp7_); #line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp8_ = _tmp7_; #line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _tmp8_); #line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (_tmp8_); #line 57 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _data1_->button); #line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp9_ = (GtkLabel*) gtk_label_new ("Label 3"); #line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp9_); #line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp10_ = _tmp9_; #line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) _tmp10_); #line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (_tmp10_); #line 60 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) grid); #line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp11_ = (GtkLabel*) gtk_label_new ("Label 4"); #line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp11_); #line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp12_ = _tmp11_; #line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) _tmp12_); #line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (_tmp12_); #line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp13_ = (GtkGrid*) gtk_grid_new (); #line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp13_); #line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" layout = _tmp13_; #line 64 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_set_column_spacing (layout, 6); #line 65 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_set_row_spacing (layout, 6); #line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp14_ = (GtkButton*) gtk_button_new_with_label ("Say Hello"); #line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp14_); #line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _data1_->hello_button = _tmp14_; #line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp15_ = (GtkLabel*) gtk_label_new (NULL); #line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp15_); #line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _data1_->hello_label = _tmp15_; #line 70 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_signal_connect_data (_data1_->hello_button, "clicked", (GCallback) ___lambda4__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0); #line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp16_ = (GtkButton*) gtk_button_new_with_label ("Rotate"); #line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp16_); #line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" rotate_button = _tmp16_; #line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _tmp17_ = (GtkLabel*) gtk_label_new ("Horizontal"); #line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_object_ref_sink (_tmp17_); #line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _data1_->rotate_label = _tmp17_; #line 78 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" g_signal_connect_data (rotate_button, "clicked", (GCallback) ___lambda5__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0); #line 82 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_attach (layout, (GtkWidget*) _data1_->hello_button, 0, 0, 1, 1); #line 83 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_attach_next_to (layout, (GtkWidget*) _data1_->hello_label, (GtkWidget*) _data1_->hello_button, GTK_POS_RIGHT, 1, 1); #line 84 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_attach (layout, (GtkWidget*) rotate_button, 0, 1, 1, 1); #line 85 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_attach_next_to (layout, (GtkWidget*) _data1_->rotate_label, (GtkWidget*) rotate_button, GTK_POS_RIGHT, 1, 1); #line 86 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_grid_attach (layout, (GtkWidget*) gridtwo, 0, 2, 2, 2); #line 88 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_container_add ((GtkContainer*) window, (GtkWidget*) layout); #line 89 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_widget_show_all ((GtkWidget*) window); #line 91 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" gtk_main (); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" result = 0; #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (rotate_button); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (layout); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (gridtwo); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (grid); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (window); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _g_object_unref0 (headerbar); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" block1_data_unref (_data1_); #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" _data1_ = NULL; #line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala" return result; #line 529 "gtk-testing.c" }
int l_klient_imp(const char *imaf, GtkWidget *wpredok) { char strsql[500]; iceb_u_spisok repl_s; class l_klient_imp_data data; data.imafz.new_plus(imaf); data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1); sprintf(strsql,"%s %s",name_system,gettext("Импорт карточек из файла")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_klient_imp_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox=gtk_vbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(data.window), vbox); data.label=gtk_label_new(gettext("Ждите !!!")); gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0); GtkWidget *label=NULL; label=gtk_label_new(gettext("Импорт карточек из файла")); gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0); data.view=gtk_text_view_new(); gtk_widget_set_usize(GTK_WIDGET(data.view),450,300); gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста //PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 12"); PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno()); gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango); pango_font_description_free(font_pango); data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view)); GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL); //gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(sw),data.view); data.bar=gtk_progress_bar_new(); gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS); gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT); gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka=gtk_button_new_with_label(strsql); GtkTooltips *tooltops=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(l_klient_imp_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0); gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2); gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна gtk_widget_show_all(data.window); //gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна //gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна gtk_idle_add((GtkFunction)l_klient_imp1,&data); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
int main (int argc, char *argv[]) { GtkWidget *win, *overlay, *grid, *main_child, *child, *label, *sw; GdkRGBA color; gchar *str; gtk_init (&argc, &argv); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (win), 600, 600); grid = gtk_grid_new (); child = gtk_event_box_new (); gdk_rgba_parse (&color, "red"); gtk_widget_override_background_color (child, 0, &color); gtk_widget_set_hexpand (child, TRUE); gtk_widget_set_vexpand (child, TRUE); gtk_container_add (GTK_CONTAINER (grid), child); label = gtk_label_new ("Out of overlay"); gtk_container_add (GTK_CONTAINER (child), label); overlay = gtk_overlay_new (); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (overlay), sw); main_child = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (sw), main_child); gdk_rgba_parse (&color, "green"); gtk_widget_override_background_color (main_child, 0, &color); gtk_widget_set_hexpand (main_child, TRUE); gtk_widget_set_vexpand (main_child, TRUE); label = gtk_label_new ("Main child"); gtk_container_add (GTK_CONTAINER (main_child), label); child = gtk_label_new (NULL); str = g_strdup_printf ("%p", child); gtk_label_set_text (GTK_LABEL (child), str); g_free (str); g_print ("Bottom/Right child: %p\n", child); gtk_widget_set_halign (child, GTK_ALIGN_END); gtk_widget_set_valign (child, GTK_ALIGN_END); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child); g_signal_connect (child, "size-allocate", G_CALLBACK (child_size_allocate), overlay); child = gtk_label_new (NULL); str = g_strdup_printf ("%p", child); gtk_label_set_text (GTK_LABEL (child), str); g_free (str); g_print ("Left/Top child: %p\n", child); gtk_widget_set_halign (child, GTK_ALIGN_START); gtk_widget_set_valign (child, GTK_ALIGN_START); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child); g_signal_connect (child, "size-allocate", G_CALLBACK (child_size_allocate), overlay); child = gtk_label_new (NULL); str = g_strdup_printf ("%p", child); gtk_label_set_text (GTK_LABEL (child), str); g_free (str); g_print ("Right/Center child: %p\n", child); gtk_widget_set_halign (child, GTK_ALIGN_END); gtk_widget_set_valign (child, GTK_ALIGN_CENTER); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child); g_signal_connect (child, "size-allocate", G_CALLBACK (child_size_allocate), overlay); child = gtk_label_new (NULL); str = g_strdup_printf ("%p", child); gtk_label_set_text (GTK_LABEL (child), str); g_free (str); gtk_widget_set_margin_start (child, 55); gtk_widget_set_margin_top (child, 4); g_print ("Left/Top margined child: %p\n", child); gtk_widget_set_halign (child, GTK_ALIGN_START); gtk_widget_set_valign (child, GTK_ALIGN_START); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child); g_signal_connect (child, "size-allocate", G_CALLBACK (child_size_allocate), overlay); child = gtk_label_new (NULL); str = g_strdup_printf ("%p", child); gtk_label_set_text (GTK_LABEL (child), str); g_free (str); g_print ("Custom get-child-position child: %p\n", child); gtk_widget_set_halign (child, GTK_ALIGN_START); gtk_widget_set_valign (child, GTK_ALIGN_START); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child); g_signal_connect (child, "size-allocate", G_CALLBACK (child_size_allocate), overlay); g_signal_connect (overlay, "get-child-position", G_CALLBACK (overlay_get_child_position), child); gtk_grid_attach (GTK_GRID (grid), overlay, 1, 0, 1, 3); gtk_container_add (GTK_CONTAINER (win), grid); g_print ("\n"); gtk_widget_show_all (win); gtk_main (); return 0; }
void pw_col_choose (void) { if (window) { gtk_window_present ((GtkWindow *) window); return; } chosen = index_new (); avail = index_new (); gboolean added[PW_COLS]; memset (added, 0, sizeof added); for (gint i = 0; i < pw_num_cols; i ++) { if (added[pw_cols[i]]) continue; added[pw_cols[i]] = TRUE; Column * column = g_slice_new (Column); column->column = pw_cols[i]; column->selected = 0; index_append (chosen, column); } for (gint i = 0; i < PW_COLS; i ++) { if (added[i]) continue; Column * column = g_slice_new (Column); column->column = i; column->selected = 0; index_append (avail, column); } window = gtk_dialog_new_with_buttons (_("Choose Columns"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_default_size ((GtkWindow *) window, 400, 300); gtk_dialog_set_default_response ((GtkDialog *) window, GTK_RESPONSE_ACCEPT); g_signal_connect (window, "response", (GCallback) response_cb, NULL); g_signal_connect (window, "destroy", (GCallback) destroy_cb, NULL); GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area ((GtkDialog *) window), hbox, TRUE, TRUE, 0); GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); gtk_box_pack_start ((GtkBox *) hbox, vbox, TRUE, TRUE, 0); GtkWidget * label = gtk_label_new (_("Available:")); g_object_set ((GObject *) label, "xalign", (gfloat) 0, NULL); gtk_box_pack_start ((GtkBox *) vbox, label, FALSE, FALSE, 0); GtkWidget * scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scroll, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scroll, GTK_SHADOW_IN); gtk_box_pack_start ((GtkBox *) vbox, scroll, TRUE, TRUE, 0); avail_list = audgui_list_new (& callbacks, avail, index_count (avail)); gtk_tree_view_set_headers_visible ((GtkTreeView *) avail_list, FALSE); audgui_list_add_column (avail_list, NULL, 0, G_TYPE_STRING, -1); gtk_container_add ((GtkContainer *) scroll, avail_list); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start ((GtkBox *) hbox, vbox, FALSE, FALSE, 0); GtkWidget * button = gtk_button_new (); gtk_container_add ((GtkContainer *) button, gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start ((GtkBox *) vbox, button, TRUE, FALSE, 0); g_signal_connect_swapped (button, "clicked", (GCallback) transfer, avail); button = gtk_button_new (); gtk_container_add ((GtkContainer *) button, gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start ((GtkBox *) vbox, button, TRUE, FALSE, 0); g_signal_connect_swapped (button, "clicked", (GCallback) transfer, chosen); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); gtk_box_pack_start ((GtkBox *) hbox, vbox, TRUE, TRUE, 0); label = gtk_label_new (_("Chosen:")); g_object_set ((GObject *) label, "xalign", (gfloat) 0, NULL); gtk_box_pack_start ((GtkBox *) vbox, label, FALSE, FALSE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scroll, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scroll, GTK_SHADOW_IN); gtk_box_pack_start ((GtkBox *) vbox, scroll, TRUE, TRUE, 0); chosen_list = audgui_list_new (& callbacks, chosen, index_count (chosen)); gtk_tree_view_set_headers_visible ((GtkTreeView *) chosen_list, FALSE); audgui_list_add_column (chosen_list, NULL, 0, G_TYPE_STRING, -1); gtk_container_add ((GtkContainer *) scroll, chosen_list); gtk_widget_show_all (window); }
////////////// Main and Init ///////////////// static void FskGtkWindowLoop(void *refcon) { FskWindow fskWindow = (FskWindow)refcon; FskGtkWindow gtkWin = (FskGtkWindow)fskWindow->gtkWin; GtkWidget *win; GdkPixbuf *iconBuf; // Start GTK special initialization XInitThreads(); //fix a xcb issue happened when using multithread gtk, see http://stackoverflow.com/a/18690540/472927 gtk_init(NULL, NULL); gtkWin->owner = fskWindow; gtkWin->window = win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(win, 750, 505); // Set App Icon char *iconPath = FskStrDoCat(FskGetApplicationPath(), "fsk.png"); iconBuf = gdk_pixbuf_new_from_file(iconPath, NULL); if(iconBuf != NULL) { gtk_window_set_icon(GTK_WINDOW(win), iconBuf); g_object_unref(G_OBJECT(iconBuf)); } FskMemPtrDispose(iconPath); gtkWin->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(win), gtkWin->vbox); gtk_widget_show(gtkWin->vbox); gtkWin->menubar = gtk_menu_bar_new(); gtk_widget_show(gtkWin->menubar); gtkWin->da = gtk_drawing_area_new(); gtk_widget_show(gtkWin->da); gtkWin->accelGroup = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(win), gtkWin->accelGroup); FskMutexNew(>kWin->bufMutex, "drawAreaBuffer"); gtkWin->queue = g_async_queue_new(); gtk_widget_add_events(GTK_WIDGET(win), GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK); gtk_widget_add_events(GTK_WIDGET(gtkWin->da), GDK_ALL_EVENTS_MASK); g_signal_connect(win, "destroy", G_CALLBACK(app_quit), gtkWin); g_signal_connect(win, "key-press-event", G_CALLBACK(on_key_press), gtkWin); g_signal_connect(win, "key-release-event", G_CALLBACK(on_key_release), gtkWin); g_signal_connect(win, "configure-event", G_CALLBACK(configure_event_win), gtkWin); // If want to resize draw-area, it will be the event receiver. g_signal_connect(gtkWin->da, "configure-event", G_CALLBACK(configure_event_cb), gtkWin); g_signal_connect(gtkWin->da, "draw", G_CALLBACK(draw_callback), gtkWin); g_signal_connect(gtkWin->da, "button-press-event", G_CALLBACK(on_button_press), gtkWin); g_signal_connect(gtkWin->da, "button-release-event",G_CALLBACK(on_button_release), gtkWin); g_signal_connect(gtkWin->da, "motion-notify-event", G_CALLBACK(motion_notify), gtkWin); gtk_box_pack_start(GTK_BOX(gtkWin->vbox), gtkWin->menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(gtkWin->vbox), gtkWin->da, TRUE, TRUE, 0); // Set all to true! gdk_threads_add_idle(idle_func, gtkWin); //gtk_widget_show_all(win); FskThreadInitializationComplete(FskThreadGetCurrent()); gtk_main(); }
static void _camera_import_dialog_new(_camera_import_dialog_t *data) { data->dialog = gtk_dialog_new_with_buttons(_("import images from camera"), NULL, GTK_DIALOG_MODAL, _("cancel"), GTK_RESPONSE_NONE, C_("camera import", "import"), GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_default_size(GTK_WINDOW(data->dialog), 100, 600); GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(data->dialog)); // List - setup store data->store = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING); // IMPORT PAGE data->import.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(data->import.page), 5); // Top info data->import.info = gtk_label_new(_("please wait while prefetching thumbnails of images from camera...")); gtk_label_set_single_line_mode(GTK_LABEL(data->import.info), FALSE); gtk_widget_set_halign(data->import.info, GTK_ALIGN_START); gtk_box_pack_start(GTK_BOX(data->import.page), data->import.info, FALSE, FALSE, 0); // jobcode data->import.jobname = _camera_import_gconf_widget(data, _("jobcode"), "plugins/capture/camera/import/jobcode"); gtk_box_pack_start(GTK_BOX(data->import.page), GTK_WIDGET(data->import.jobname->widget), FALSE, FALSE, 0); // Create the treview with list model data store data->import.treeview = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new()); GtkTreeView *treeview = GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview))); GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new(); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes(_("thumbnail"), renderer, "pixbuf", 0, (char *)NULL); gtk_tree_view_append_column(treeview, column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("storage file"), renderer, "text", 1, (char *)NULL); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_expand(column, TRUE); GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(data->store)); gtk_tree_view_set_headers_visible(treeview, FALSE); gtk_box_pack_start(GTK_BOX(data->import.page), data->import.treeview, TRUE, TRUE, 0); // SETTINGS PAGE data->settings.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(data->settings.page), 5); // general settings gtk_box_pack_start(GTK_BOX(data->settings.page), gtk_label_new(_("general")), FALSE, FALSE, 0); // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories. data->settings.general.ignore_jpeg = gtk_check_button_new_with_label(_("ignore JPEG files")); g_object_set(data->settings.general.ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are " "raw+JPEG in a directory."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs")); gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(data->settings.general.ignore_jpeg), "clicked", G_CALLBACK(_check_button_callback), data); GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); data->settings.general.date_override = gtk_check_button_new_with_label(_("override today's date")); gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_override, FALSE, FALSE, 0); g_object_set(data->settings.general.date_override, "tooltip-text", _("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), " "$(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"), (char *)NULL); data->settings.general.date_entry = gtk_entry_new(); gtk_widget_set_sensitive(data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( data->settings.general.date_override))); gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_entry, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->settings.general.date_override), "clicked", G_CALLBACK(_check_button_callback), data); gtk_box_pack_start(GTK_BOX(data->settings.page), hbox, FALSE, FALSE, 0); // THE NOTEBOOK data->notebook = gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->import.page, gtk_label_new(_("images"))); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->settings.page, gtk_label_new(_("settings"))); // end gtk_box_pack_start(GTK_BOX(content), data->notebook, TRUE, TRUE, 0); // gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400)); }
static void test_color_plane (void) { g_autoptr (GtkBuilder) builder = NULL; GtkWidget *window; GtkWidget *mode_box; GtkListStore *mode_store; GtkWidget *hue_scale; GtkWidget *saturation_scale; GtkWidget *value_scale; GtkWidget *cielab_l_scale; GtkWidget *cielab_a_scale; GtkWidget *cielab_b_scale; GtkWidget *red_scale; GtkWidget *green_scale; GtkWidget *blue_scale; GtkWidget *box; GstyleColorPlane *plane; GError *error = NULL; gtk_init (NULL, NULL); builder = gtk_builder_new (); gtk_builder_add_from_file (builder, TEST_DATA_DIR"/gstyle-color-editor.ui", &error); g_assert_no_error (error); plane = GSTYLE_COLOR_PLANE (gtk_builder_get_object (builder, "plane")); hue_scale = GTK_WIDGET (gtk_builder_get_object (builder, "hsv_h_scale")); gtk_range_set_adjustment (GTK_RANGE (hue_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_HSV_H)); saturation_scale = GTK_WIDGET (gtk_builder_get_object (builder, "hsv_s_scale")); gtk_range_set_adjustment (GTK_RANGE (saturation_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_HSV_S)); value_scale = GTK_WIDGET (gtk_builder_get_object (builder, "hsv_v_scale")); gtk_range_set_adjustment (GTK_RANGE (value_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_HSV_V)); cielab_l_scale = GTK_WIDGET (gtk_builder_get_object (builder, "cielab_l_scale")); gtk_range_set_adjustment (GTK_RANGE (cielab_l_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_LAB_L)); cielab_a_scale = GTK_WIDGET (gtk_builder_get_object (builder, "cielab_a_scale")); gtk_range_set_adjustment (GTK_RANGE (cielab_a_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_LAB_A)); cielab_b_scale = GTK_WIDGET (gtk_builder_get_object (builder, "cielab_b_scale")); gtk_range_set_adjustment (GTK_RANGE (cielab_b_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_LAB_A)); red_scale = GTK_WIDGET (gtk_builder_get_object (builder, "rgb_red_scale")); gtk_range_set_adjustment (GTK_RANGE (red_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_RGB_RED)); green_scale = GTK_WIDGET (gtk_builder_get_object (builder, "rgb_green_scale")); gtk_range_set_adjustment (GTK_RANGE (green_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_RGB_RED)); blue_scale = GTK_WIDGET (gtk_builder_get_object (builder, "rgb_blue_scale")); gtk_range_set_adjustment (GTK_RANGE (blue_scale), gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_RGB_BLUE)); mode_box = GTK_WIDGET (gtk_builder_get_object (builder, "mode_box")); mode_store = GTK_LIST_STORE (gtk_builder_get_object (builder, "mode_store")); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_HUE, 1, "Hsv Hue", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_SATURATION, 1, "Hsv Saturation", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_BRIGHTNESS, 1, "Hsv Brightness (Value)", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_CIELAB_L, 1, "CieLab L*", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_CIELAB_A, 1, "CieLab a*", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_CIELAB_B, 1, "CieLab b*", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_RED, 1, "rgb red", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_GREEN, 1, "rgb green", -1); gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_BLUE, 1, "rgb blue", -1); gtk_combo_box_set_active (GTK_COMBO_BOX (mode_box), 0); g_signal_connect_swapped (mode_box, "changed", G_CALLBACK (mode_changed), plane); box = GTK_WIDGET (gtk_builder_get_object (builder, "editor_box")); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_add (GTK_CONTAINER (window), box); gtk_window_set_default_size (GTK_WINDOW (window), 400,400); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_show_all (window); gtk_main (); }
Client * newclient(void) { Client *c; WebKitWebSettings *settings; WebKitWebFrame *frame; GdkGeometry hints = { 1, 1 }; char *uri, *ua; if(!(c = calloc(1, sizeof(Client)))) die("Cannot malloc!\n"); /* Window */ if(embed) { c->win = gtk_plug_new(embed); } else { c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* TA: 20091214: Despite what the GNOME docs say, the ICCCM * is always correct, so we should still call this function. * But when doing so, we *must* differentiate between a * WM_CLASS and a resource on the window. By convention, the * window class (WM_CLASS) is capped, while the resource is in * lowercase. Both these values come as a pair. */ gtk_window_set_wmclass(GTK_WINDOW(c->win), "surf", "surf"); /* TA: 20091214: And set the role here as well -- so that * sessions can pick this up. */ gtk_window_set_role(GTK_WINDOW(c->win), "Surf"); } gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600); g_signal_connect(G_OBJECT(c->win), "destroy", G_CALLBACK(destroywin), c); g_signal_connect(G_OBJECT(c->win), "key-press-event", G_CALLBACK(keypress), c); g_signal_connect(G_OBJECT(c->win), "size-allocate", G_CALLBACK(resize), c); /* VBox */ c->vbox = gtk_vbox_new(FALSE, 0); /* Scrolled Window */ c->scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(c->scroll), GTK_POLICY_NEVER, GTK_POLICY_NEVER); /* Webview */ c->view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_signal_connect(G_OBJECT(c->view), "button-press-event", G_CALLBACK(buttonevent), c); g_signal_connect(G_OBJECT(c->view), "title-changed", G_CALLBACK(titlechange), c); g_signal_connect(G_OBJECT(c->view), "hovering-over-link", G_CALLBACK(linkhover), c); g_signal_connect(G_OBJECT(c->view), "create-web-view", G_CALLBACK(createwindow), c); g_signal_connect(G_OBJECT(c->view), "new-window-policy-decision-requested", G_CALLBACK(decidewindow), c); g_signal_connect(G_OBJECT(c->view), "mime-type-policy-decision-requested", G_CALLBACK(decidedownload), c); g_signal_connect(G_OBJECT(c->view), "window-object-cleared", G_CALLBACK(windowobjectcleared), c); g_signal_connect(G_OBJECT(c->view), "notify::load-status", G_CALLBACK(loadstatuschange), c); g_signal_connect(G_OBJECT(c->view), "notify::progress", G_CALLBACK(progresschange), c); g_signal_connect(G_OBJECT(c->view), "download-requested", G_CALLBACK(initdownload), c); /* Indicator */ c->indicator = gtk_drawing_area_new(); gtk_widget_set_size_request(c->indicator, 0, 2); g_signal_connect (G_OBJECT (c->indicator), "expose_event", G_CALLBACK (exposeindicator), c); /* Arranging */ gtk_container_add(GTK_CONTAINER(c->scroll), GTK_WIDGET(c->view)); gtk_container_add(GTK_CONTAINER(c->win), c->vbox); gtk_container_add(GTK_CONTAINER(c->vbox), c->scroll); gtk_container_add(GTK_CONTAINER(c->vbox), c->indicator); /* Setup */ gtk_box_set_child_packing(GTK_BOX(c->vbox), c->indicator, FALSE, FALSE, 0, GTK_PACK_START); gtk_box_set_child_packing(GTK_BOX(c->vbox), c->scroll, TRUE, TRUE, 0, GTK_PACK_START); gtk_widget_grab_focus(GTK_WIDGET(c->view)); gtk_widget_show(c->vbox); gtk_widget_show(c->indicator); gtk_widget_show(c->scroll); gtk_widget_show(GTK_WIDGET(c->view)); gtk_widget_show(c->win); gtk_window_set_geometry_hints(GTK_WINDOW(c->win), NULL, &hints, GDK_HINT_MIN_SIZE); gdk_window_set_events(GTK_WIDGET(c->win)->window, GDK_ALL_EVENTS_MASK); gdk_window_add_filter(GTK_WIDGET(c->win)->window, processx, c); webkit_web_view_set_full_content_zoom(c->view, TRUE); frame = webkit_web_view_get_main_frame(c->view); runscript(frame, webkit_web_frame_get_global_context(frame)); settings = webkit_web_view_get_settings(c->view); if(!(ua = getenv("SURF_USERAGENT"))) ua = useragent; g_object_set(G_OBJECT(settings), "user-agent", ua, NULL); uri = g_strconcat("file://", stylefile, NULL); g_object_set(G_OBJECT(settings), "user-stylesheet-uri", uri, NULL); g_object_set(G_OBJECT(settings), "auto-load-images", loadimage, NULL); g_object_set(G_OBJECT(settings), "enable-plugins", plugin, NULL); g_object_set(G_OBJECT(settings), "enable-scripts", script, NULL); g_object_set(G_OBJECT(settings), "enable-spatial-navigation", true, NULL); g_free(uri); setatom(c, AtomFind, ""); setatom(c, AtomUri, "about:blank"); if(NOBACKGROUND) webkit_web_view_set_transparent(c->view, TRUE); c->title = NULL; c->next = clients; clients = c; if(showxid) { gdk_display_sync(gtk_widget_get_display(c->win)); printf("%u\n", (guint)GDK_WINDOW_XID(GTK_WIDGET(c->win)->window)); fflush(NULL); } return c; }
static int gtkDialogMapMethod(Ihandle* ih) { int decorations = 0; int functions = 0; InativeHandle* parent; GtkWidget* fixed; #ifdef HILDON if (iupAttribGetBoolean(ih, "HILDONWINDOW")) { HildonProgram *program = HILDON_PROGRAM(hildon_program_get_instance()); ih->handle = hildon_window_new(); if (ih->handle) hildon_program_add_window(program, HILDON_WINDOW(ih->handle)); } else { iupAttribSetStr(ih, "DIALOGHINT", "YES"); /* otherwise not displayed correctly */ ih->handle = gtk_window_new(GTK_WINDOW_TOPLEVEL); } #else ih->handle = gtk_window_new(GTK_WINDOW_TOPLEVEL); #endif if (!ih->handle) return IUP_ERROR; parent = iupDialogGetNativeParent(ih); if (parent) { gtk_window_set_transient_for((GtkWindow*)ih->handle, (GtkWindow*)parent); /* manually remove child windows when parent is destroyed */ g_signal_connect(G_OBJECT(parent), "destroy", G_CALLBACK(gtkDialogChildDestroyEvent), ih); } g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); /* The iupgtkKeyPressEvent of the control with the focus will propagate the key up to the dialog. */ /* Inside iupgtkKeyPressEvent we test this to avoid duplicate calls. */ g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "configure-event", G_CALLBACK(gtkDialogConfigureEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "window-state-event", G_CALLBACK(gtkDialogWindowStateEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "delete-event", G_CALLBACK(iupgtkDialogDeleteEvent), ih); gtk_window_set_default_size((GtkWindow*)ih->handle, 100, 100); /* set this to avoid size calculation problems */ if (iupAttribGetBoolean(ih, "DIALOGHINT")) gtk_window_set_type_hint(GTK_WINDOW(ih->handle), GDK_WINDOW_TYPE_HINT_DIALOG); /* the container that will receive the child element. */ fixed = gtk_fixed_new(); gtk_container_add((GtkContainer*)ih->handle, fixed); gtk_widget_show(fixed); /* initialize the widget */ gtk_widget_realize(ih->handle); if (iupAttribGetBoolean(ih, "DIALOGFRAME")) { iupAttribSetStr(ih, "RESIZE", "NO"); } if (!iupAttribGetBoolean(ih, "RESIZE")) { iupAttribSetStr(ih, "MAXBOX", "NO"); /* Must also remove these, so RESIZE=NO can work */ iupAttribSetStr(ih, "MINBOX", "NO"); } if (IupGetAttribute(ih, "TITLE")) { /* must use IupGetAttribute to check from the native implementation */ functions |= GDK_FUNC_MOVE; decorations |= GDK_DECOR_TITLE; } if (iupAttribGetBoolean(ih, "MENUBOX")) { functions |= GDK_FUNC_CLOSE; decorations |= GDK_DECOR_MENU; } if (iupAttribGetBoolean(ih, "MINBOX")) { functions |= GDK_FUNC_MINIMIZE; decorations |= GDK_DECOR_MINIMIZE; } if (iupAttribGetBoolean(ih, "MAXBOX")) { functions |= GDK_FUNC_MAXIMIZE; decorations |= GDK_DECOR_MAXIMIZE; } if (iupAttribGetBoolean(ih, "RESIZE")) { functions |= GDK_FUNC_RESIZE; decorations |= GDK_DECOR_RESIZEH; } if (iupAttribGetBoolean(ih, "BORDER")) decorations |= GDK_DECOR_BORDER; if (decorations == 0) gtk_window_set_decorated((GtkWindow*)ih->handle, FALSE); else { GdkWindow* window = ih->handle->window; if (window) { gdk_window_set_decorations(window, (GdkWMDecoration)decorations); gdk_window_set_functions(window, (GdkWMFunction)functions); } } /* configure for DRAG&DROP */ if (IupGetCallback(ih, "DROPFILES_CB")) iupAttribSetStr(ih, "DRAGDROP", "YES"); { /* Reset the DLGBGCOLOR global attribute if it is the first time a dialog is created. The value returned by gtk_style_new is not accurate. */ GtkStyle* style = gtk_widget_get_style(ih->handle); if (style && IupGetGlobal("_IUP_RESET_GLOBALCOLORS")) { iupgtkUpdateGlobalColors(style); IupSetGlobal("_IUP_RESET_GLOBALCOLORS", NULL); } } /* configure the size range */ gtkDialogSetMinMax(ih, 1, 1, 65535, 65535); /* MINSIZE and MAXSIZE default values */ /* Ignore VISIBLE before mapping */ iupAttribSetStr(ih, "VISIBLE", NULL); return IUP_NOERROR; }
static void mc_preferences_setup_dialog (GtkBuilder *builder, MCData *mc) { MCPrefsDialog *dialog; GtkCellRenderer *renderer; GdkRGBA color; dialog = &mc->prefs_dialog; g_signal_connect (dialog->dialog, "response", G_CALLBACK (preferences_response), mc); gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_CLOSE); gtk_window_set_default_size (GTK_WINDOW (dialog->dialog), 400, -1); dialog->auto_complete_history_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "auto_complete_history_toggle")); dialog->size_spinner = GTK_WIDGET (gtk_builder_get_object (builder, "size_spinner")); dialog->use_default_theme_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "default_theme_toggle")); dialog->fg_color_picker = GTK_WIDGET (gtk_builder_get_object (builder, "fg_color_picker")); dialog->bg_color_picker = GTK_WIDGET (gtk_builder_get_object (builder, "bg_color_picker")); dialog->macros_tree = GTK_WIDGET (gtk_builder_get_object (builder, "macros_tree")); dialog->delete_button = GTK_WIDGET (gtk_builder_get_object (builder, "delete_button")); dialog->add_button = GTK_WIDGET (gtk_builder_get_object (builder, "add_button")); /* History based autocompletion */ g_signal_connect (dialog->auto_complete_history_toggle, "toggled", G_CALLBACK (auto_complete_history_toggled), mc); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->auto_complete_history_toggle), mc->preferences.auto_complete_history); if (!g_settings_is_writable (mc->settings, KEY_AUTOCOMPLETE_HISTORY)) hard_set_sensitive (dialog->auto_complete_history_toggle, FALSE); /* Width */ gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spinner), mc->preferences.normal_size_x); g_signal_connect (dialog->size_spinner, "value_changed", G_CALLBACK (size_value_changed), mc); if (!g_settings_is_writable (mc->settings, KEY_NORMAL_SIZE_X)) { hard_set_sensitive (dialog->size_spinner, FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "size_label")), FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "size_post_label")), FALSE); } /* Use default theme */ g_signal_connect (dialog->use_default_theme_toggle, "toggled", G_CALLBACK (use_default_theme_toggled), mc); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->use_default_theme_toggle), mc->preferences.show_default_theme); if (!g_settings_is_writable (mc->settings, KEY_SHOW_DEFAULT_THEME)) hard_set_sensitive (dialog->use_default_theme_toggle, FALSE); /* Foreground color */ g_signal_connect (dialog->fg_color_picker, "color_set", G_CALLBACK (foreground_color_set), mc); gdk_rgba_parse (&color, mc->preferences.cmd_line_color_fg); gtk_color_button_set_rgba (GTK_COLOR_BUTTON (dialog->fg_color_picker), &color); soft_set_sensitive (dialog->fg_color_picker, !mc->preferences.show_default_theme); if (!g_settings_is_writable (mc->settings, KEY_CMD_LINE_COLOR_FG)) { hard_set_sensitive (dialog->fg_color_picker, FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "fg_color_label")), FALSE); } /* Background color */ g_signal_connect (dialog->bg_color_picker, "color_set", G_CALLBACK (background_color_set), mc); gdk_rgba_parse (&color, mc->preferences.cmd_line_color_bg); gtk_color_button_set_rgba (GTK_COLOR_BUTTON (dialog->bg_color_picker), &color); soft_set_sensitive (dialog->bg_color_picker, !mc->preferences.show_default_theme); if (!g_settings_is_writable (mc->settings, KEY_CMD_LINE_COLOR_BG)) { hard_set_sensitive (dialog->bg_color_picker, FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "bg_color_label")), FALSE); } /* Macros Delete and Add buttons */ g_signal_connect (dialog->delete_button, "clicked", G_CALLBACK (macro_delete), mc); g_signal_connect (dialog->add_button, "clicked", G_CALLBACK (macro_add), mc); if (!g_settings_is_writable (mc->global_settings, KEY_MACRO_PATTERNS) || !g_settings_is_writable (mc->global_settings, KEY_MACRO_COMMANDS)) { hard_set_sensitive (dialog->add_button, FALSE); hard_set_sensitive (dialog->delete_button, FALSE); hard_set_sensitive (dialog->macros_tree, FALSE); } /* Macros tree view */ dialog->macros_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->macros_tree), GTK_TREE_MODEL (dialog->macros_store)); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_PATTERN)); g_signal_connect (renderer, "edited", G_CALLBACK (macro_edited), mc); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->macros_tree), -1, _("Pattern"), renderer, "text", COLUMN_PATTERN, NULL); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_COMMAND)); g_signal_connect (renderer, "edited", G_CALLBACK (macro_edited), mc); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->macros_tree), -1, _("Command"), renderer, "text", COLUMN_COMMAND, NULL); show_macros_list (mc); }
static GtkWidget * create_add_emblems_dialog (CajaEmblemSidebar *emblem_sidebar, GSList *emblems) { GtkWidget *dialog, *label, *table, *image; GtkWidget *first_entry, *entry, *scroller, *hbox; Emblem *emblem; GSList *list; int num_emblems; first_entry = NULL; dialog = gtk_dialog_new_with_buttons (_("Add Emblems..."), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); /* FIXME: make a better message */ if (g_slist_length (emblems) > 1) { label = gtk_label_new (_("Enter a descriptive name next to each emblem. This name will be used in other places to identify the emblem.")); } else { label = gtk_label_new (_("Enter a descriptive name next to the emblem. This name will be used in other places to identify the emblem.")); } gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), label, FALSE, FALSE, 8); gtk_widget_show (label); scroller = eel_scrolled_wrap_table_new (TRUE, GTK_SHADOW_NONE, &table); eel_wrap_table_set_x_spacing (EEL_WRAP_TABLE (table), 8); eel_wrap_table_set_y_spacing (EEL_WRAP_TABLE (table), 8); num_emblems=0; list = emblems; while (list != NULL) { /* walk through the list of emblems, and create an image * and entry for each one */ emblem = (Emblem *)list->data; list = list->next; image = gtk_image_new_from_pixbuf (emblem->pixbuf); hbox = gtk_hbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); g_signal_connect (entry, "changed", G_CALLBACK (emblem_name_entry_changed_cb), emblem); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (table), hbox); if (num_emblems == 0) { first_entry = entry; } num_emblems++; } gtk_container_set_border_width (GTK_CONTAINER (dialog), 8); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scroller, TRUE, TRUE, 8); gtk_widget_show_all (scroller); gtk_widget_grab_focus (first_entry); /* we expand the window to hold up to about 4 emblems, but after that * let the scroller do its thing. Is there a better way to do this? */ gtk_window_set_default_size (GTK_WINDOW (dialog), 400, MIN (120+(60*num_emblems), 350)); g_object_set_data_full (G_OBJECT (dialog), "emblems-to-add", emblems, (GDestroyNotify)destroy_emblem_list); return dialog; }
int main(int argc, char *argv[]) { char qaulUserPath[MAX_PATH_LEN]; char qaulTmpPath[MAX_PATH_LEN]; char qaulTmpPath2[MAX_PATH_LEN]; qaulConfigureCounter = 0; qaulTimerEvents = 0; qaulTimerSockets = 0; qaulTimerTopology = 0; network_interface_found = 0; // initialize glib types g_type_init(); // set paths sprintf(qaulUserPath, "%s/.qaul", (char*)g_get_home_dir()); printf ("qaul.net home directory is %s\n", qaulUserPath); // create qaul user directory if(!g_file_test(qaulUserPath, G_FILE_TEST_EXISTS)) { // create directory // http://www.gnu.org/software/libc/manual/html_node/Permission-Bits.html if(g_mkdir(qaulUserPath, S_IRUSR|S_IWUSR|S_IXUSR)== -1) printf("qaul.net home directory %s creation error.\n", qaulUserPath); } // check if we have to update sprintf(qaulTmpPath, "%s/%s", qaulUserPath, QAUL_VERSION); if(!g_file_test(qaulTmpPath, G_FILE_TEST_EXISTS)) { printf("Update user folder to qaul.net version %s\n", QAUL_VERSION); // copy www folder sprintf(qaulTmpPath, "%s/www", QAUL_ROOT_PATH); sprintf(qaulTmpPath2, "%s/www", qaulUserPath); if(!qaul_copyDirectory(qaulTmpPath, qaulTmpPath2)) printf("qaul copy directory error. source: %s target: %s\n", qaulTmpPath, qaulTmpPath2); // TODO: update data base // remove old data base if it exists sprintf(qaulTmpPath, "%s/qaullib.db", qaulUserPath); if(g_file_test(qaulTmpPath, G_FILE_TEST_EXISTS)) if(g_remove(qaulTmpPath) == -1) printf("qaul.net database %s removal error\n", qaulTmpPath); // create qaul version file sprintf(qaulTmpPath, "%s/%s", qaulUserPath, QAUL_VERSION); if(!g_file_test(qaulTmpPath, G_FILE_TEST_EXISTS)) if(!g_creat(qaulTmpPath, S_IRUSR|S_IWUSR) == -1) printf("qaul.net version file %s creation error\n", qaulTmpPath); } Qaullib_Init(qaulUserPath); // set configuration Qaullib_SetConf(QAUL_CONF_INTERFACE); // enable debug menu qaul_conf_debug = 1; if(!Qaullib_WebserverStart()) printf("Webserver startup failed\n"); // initialize dbus connection qaul_dbus_init(&network_dbus_connection); // start configuration timer qaulConfigureTimer = g_timeout_add(500, qaul_configure, NULL); // open window gtk_init(&argc,&argv); // Create a window that will contain the browser instance qaulMainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(qaulMainWindow), 400, 592); gtk_window_set_title(GTK_WINDOW(qaulMainWindow), "qaul.net - قول"); sprintf(qaulTmpPath, "%s/app_icon.png", QAUL_ROOT_PATH); gtk_window_set_icon(GTK_WINDOW(qaulMainWindow), create_pixbuf(qaulTmpPath)); // Create a browser instance WebKitWebView *webView = WEBKIT_WEB_VIEW(webkit_web_view_new()); // Create a scrollable area, and put the browser instance into it GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolledWindow), GTK_WIDGET(webView)); // Set up callbacks so that if either the main window or the browser instance is // closed, the program will exit g_signal_connect(qaulMainWindow, "destroy", G_CALLBACK(destroyWindowCb), NULL); g_signal_connect(webView, "close-web-view", G_CALLBACK(closeWebViewCb), qaulMainWindow); // Put the scrollable area into the main window gtk_container_add(GTK_CONTAINER(qaulMainWindow), scrolledWindow); // Load a web page into the browser instance webkit_web_view_load_uri(webView, "http://127.0.0.1:8081/qaul.html"); // Make sure that when the browser area becomes visible, it will get mouse // and keyboard events gtk_widget_grab_focus(GTK_WIDGET(webView)); // Make sure the main window and all its contents are visible gtk_widget_show_all(qaulMainWindow); // Run the main GTK+ event loop gtk_main(); return 0; }
void gui_show_search_results(GSList * list, gchar * plugin_name) { GtkWidget *search; GtkWidget *vbox; GtkListStore *search_liststore; GtkWidget *tree_view; GtkWidget *scrolled_window; GtkWidget *hbox; GtkWidget *button_close; GtkWidget *frame; GSList *tmplist = list; GtkTreeIter search_iter; gui_protocol *gp; search = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name(search, "GGSearchResults"); gtk_window_set_title(GTK_WINDOW(search), _("Search results")); gtk_window_set_default_size(GTK_WINDOW(search), 350, 300); search_liststore = gtk_list_store_new(6, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(search_liststore)); /* gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)), GTK_SELECTION_MULTIPLE); */ add_columns(GTK_TREE_VIEW(tree_view)); scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(frame), scrolled_window); vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(search), vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); button_close = gtk_button_new_from_stock("gtk-close"); gtk_box_pack_end(GTK_BOX(hbox), button_close, FALSE, FALSE, 0); g_signal_connect(search, "destroy", G_CALLBACK(on_destroy_search), list); g_signal_connect_swapped(button_close, "clicked", G_CALLBACK(gtk_widget_destroy), search); g_signal_connect(G_OBJECT(tree_view), "button-press-event", G_CALLBACK(search_list_clicked), search_liststore); gtk_widget_show_all(search); gp = gui_find_protocol(plugin_name, protocols); if (gp) { g_object_set_data(G_OBJECT(tree_view), "plugin_name", gp->plugin_name); while (tmplist) { GGaduContact *k = tmplist->data; GGaduStatusPrototype *sp = ggadu_find_status_prototype(gp->p, k->status); print_debug("adding kontakt to results list: %s\n", k->id); if (sp && sp->image != NULL) { gchar *display; gchar *dispcity; gchar *dispage; GdkPixbuf *image = create_pixbuf(sp->image); display = g_strdup_printf("%s %s%s%s", (k->first_name) ? k->first_name : "", (k->nick) ? "(" : "", (k->nick) ? k->nick : "", (k->nick) ? ")" : ""); dispcity = g_strdup_printf("%s", (k->city) ? k->city : ""); dispage = g_strdup_printf("%s", (k->age) ? k->age : ""); gtk_list_store_append(search_liststore, &search_iter); gtk_list_store_set(search_liststore, &search_iter, 0, image, 1, k->id, 2, (gpointer) k, 3, display, 4, dispcity, 5, dispage, -1); gdk_pixbuf_unref(image); } GGaduStatusPrototype_free(sp); tmplist = tmplist->next; } } }
void terminal_edit_keys_dialog_show (GtkWindow *transient_parent) { TerminalApp *app; GtkWidget *dialog, *tree_view, *disable_mnemonics_button, *disable_menu_accel_button; GtkTreeViewColumn *column; GtkCellRenderer *cell_renderer; GtkTreeStore *tree; guint i; if (edit_keys_dialog != NULL) goto done; if (!terminal_util_load_builder_file ("keybinding-editor.ui", "keybindings-dialog", &dialog, "disable-mnemonics-checkbutton", &disable_mnemonics_button, "disable-menu-accel-checkbutton", &disable_menu_accel_button, "accelerators-treeview", &tree_view, NULL)) return; app = terminal_app_get (); terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MNEMONICS, disable_mnemonics_button, 0); terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MENU_BAR_ACCEL, disable_menu_accel_button, 0); /* Column 1 */ cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("_Action"), cell_renderer, "text", ACTION_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); gtk_tree_view_column_set_sort_column_id (column, ACTION_COLUMN); /* Column 2 */ cell_renderer = gtk_cell_renderer_accel_new (); g_object_set (cell_renderer, "editable", TRUE, "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_GTK, NULL); g_signal_connect (cell_renderer, "accel-edited", G_CALLBACK (accel_edited_callback), tree_view); g_signal_connect (cell_renderer, "accel-cleared", G_CALLBACK (accel_cleared_callback), tree_view); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Shortcut _Key")); gtk_tree_view_column_pack_start (column, cell_renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, cell_renderer, accel_set_func, NULL, NULL); gtk_tree_view_column_set_sort_column_id (column, KEYVAL_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); /* Add the data */ tree = edit_keys_store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER); #ifdef MATE_ENABLE_DEBUG _TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ACCELS) g_signal_connect (tree, "row-changed", G_CALLBACK (row_changed), NULL); #endif for (i = 0; i < G_N_ELEMENTS (all_entries); ++i) { GtkTreeIter parent_iter; guint j; gtk_tree_store_append (tree, &parent_iter, NULL); gtk_tree_store_set (tree, &parent_iter, ACTION_COLUMN, _(all_entries[i].user_visible_name), -1); for (j = 0; j < all_entries[i].n_elements; ++j) { KeyEntry *key_entry = &(all_entries[i].key_entry[j]); GtkTreeIter iter; gtk_tree_store_insert_with_values (tree, &iter, &parent_iter, -1, ACTION_COLUMN, _(key_entry->user_visible_name), KEYVAL_COLUMN, key_entry, -1); } } gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (tree), KEYVAL_COLUMN, accel_compare_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (tree), ACTION_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (tree)); g_object_unref (tree); gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view)); g_signal_connect (notification_group, "accel-changed", G_CALLBACK (treeview_accel_changed_cb), tree); edit_keys_dialog = dialog; g_signal_connect (dialog, "destroy", G_CALLBACK (edit_keys_dialog_destroy_cb), tree); g_signal_connect (dialog, "response", G_CALLBACK (edit_keys_dialog_response_cb), NULL); gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 350); done: gtk_window_set_transient_for (GTK_WINDOW (edit_keys_dialog), transient_parent); gtk_window_present (GTK_WINDOW (edit_keys_dialog)); }
void send_raw_file(GtkAction *action, gpointer data) { GtkWidget *file_select; file_select = gtk_file_chooser_dialog_new(_("Send RAW File"), GTK_WINDOW(Fenetre), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); if(fic_defaut != NULL) gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_select), fic_defaut); if(gtk_dialog_run(GTK_DIALOG(file_select)) == GTK_RESPONSE_ACCEPT) { gchar *fileName; gchar *msg; fileName = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_select)); if(!g_file_test(fileName, G_FILE_TEST_IS_REGULAR)) { msg = g_strdup_printf(_("Error opening file\n")); show_message(msg, MSG_ERR); g_free(msg); g_free(fileName); gtk_widget_destroy(file_select); return; } Fichier = open(fileName, O_RDONLY); if(Fichier != -1) { GtkWidget *Bouton_annuler, *Box; fic_defaut = g_strdup(fileName); msg = g_strdup_printf(_("%s : transfer in progress..."), fileName); gtk_statusbar_push(GTK_STATUSBAR(StatusBar), id, msg); car_written = 0; current_buffer_position = 0; bytes_read = 0; nb_car = lseek(Fichier, 0L, SEEK_END); lseek(Fichier, 0L, SEEK_SET); Window = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(Window), msg); g_free(msg); Box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(Window))), Box); ProgressBar = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(Box), ProgressBar, FALSE, FALSE, 5); Bouton_annuler = gtk_button_new_with_label(_("Cancel")); g_signal_connect(GTK_WIDGET(Bouton_annuler), "clicked", G_CALLBACK(close_all), NULL); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_action_area(GTK_DIALOG(Window))), Bouton_annuler); g_signal_connect(GTK_WIDGET(Window), "delete_event", G_CALLBACK(close_all), NULL); gtk_window_set_default_size(GTK_WINDOW(Window), 250, 100); gtk_window_set_modal(GTK_WINDOW(Window), TRUE); gtk_widget_show_all(Window); add_input(); } else { msg = g_strdup_printf(_("Cannot read file %s: %s\n"), fileName, strerror(errno)); show_message(msg, MSG_ERR); g_free(msg); } g_free(fileName); } gtk_widget_destroy(file_select); }
EXPORT void audgui_playlist_manager (void) { GtkWidget * playman_vbox; GtkWidget * playman_pl_lv, * playman_pl_lv_sw; GtkWidget * playman_button_hbox; GtkWidget * new_button, * delete_button, * rename_button, * play_button; GtkWidget * hbox, * check_button; GdkGeometry playman_win_hints; if (playman_win) { gtk_window_present ((GtkWindow *) playman_win); return; } playman_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint ((GtkWindow *) playman_win, GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_title ((GtkWindow *) playman_win, _("Playlist Manager")); gtk_container_set_border_width ((GtkContainer *) playman_win, 6); playman_win_hints.min_width = 400; playman_win_hints.min_height = 250; gtk_window_set_geometry_hints ((GtkWindow *) playman_win, playman_win, &playman_win_hints , GDK_HINT_MIN_SIZE); int x = aud_get_int ("audgui", "playlist_manager_x"); int y = aud_get_int ("audgui", "playlist_manager_y"); int w = aud_get_int ("audgui", "playlist_manager_w"); int h = aud_get_int ("audgui", "playlist_manager_h"); if (w && h) { gtk_window_move ((GtkWindow *) playman_win, x, y); gtk_window_set_default_size ((GtkWindow *) playman_win, w, h); } g_signal_connect (playman_win, "delete-event", (GCallback) hide_cb, NULL); audgui_hide_on_escape (playman_win); playman_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add ((GtkContainer *) playman_win, playman_vbox); /* ListView */ playman_pl_lv = audgui_list_new (& callbacks, NULL, aud_playlist_count ()); audgui_list_add_column (playman_pl_lv, _("Title"), 0, G_TYPE_STRING, -1); audgui_list_add_column (playman_pl_lv, _("Entries"), 1, G_TYPE_INT, 7); audgui_list_set_highlight (playman_pl_lv, aud_playlist_get_playing ()); gtk_tree_view_set_search_equal_func ((GtkTreeView *) playman_pl_lv, search_cb, NULL, NULL); hook_associate ("playlist update", update_hook, playman_pl_lv); hook_associate ("playlist activate", activate_hook, playman_pl_lv); hook_associate ("playlist set playing", position_hook, playman_pl_lv); playman_pl_lv_sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) playman_pl_lv_sw, GTK_SHADOW_IN); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) playman_pl_lv_sw, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add ((GtkContainer *) playman_pl_lv_sw, playman_pl_lv); gtk_box_pack_start ((GtkBox *) playman_vbox, playman_pl_lv_sw, TRUE, TRUE, 0); /* ButtonBox */ playman_button_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); new_button = gtk_button_new_from_stock (GTK_STOCK_NEW); delete_button = gtk_button_new_from_stock (GTK_STOCK_DELETE); rename_button = gtk_button_new_with_mnemonic (_("_Rename")); gtk_button_set_image ((GtkButton *) rename_button, gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON)); play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY); gtk_container_add ((GtkContainer *) playman_button_hbox, new_button); gtk_container_add ((GtkContainer *) playman_button_hbox, delete_button); gtk_box_pack_end ((GtkBox *) playman_button_hbox, play_button, FALSE, FALSE, 0); gtk_box_pack_end ((GtkBox *) playman_button_hbox, rename_button, FALSE, FALSE, 0); gtk_container_add ((GtkContainer *) playman_vbox, playman_button_hbox); g_signal_connect (new_button, "clicked", (GCallback) new_cb, NULL); g_signal_connect (delete_button, "clicked", (GCallback) delete_cb, NULL); g_signal_connect (rename_button, "clicked", (GCallback) rename_cb, NULL); g_signal_connect (play_button, "clicked", (GCallback) play_cb, NULL); /* CheckButton */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start ((GtkBox *) playman_vbox, hbox, FALSE, FALSE, 0); check_button = gtk_check_button_new_with_mnemonic (_("_Close dialog on activating playlist")); gtk_box_pack_start ((GtkBox *) hbox, check_button, FALSE, FALSE, 0); gtk_toggle_button_set_active ((GtkToggleButton *) check_button, aud_get_bool ("audgui", "playlist_manager_close_on_activate")); g_signal_connect (check_button, "toggled", (GCallback) close_on_activate_cb, NULL); gtk_widget_show_all (playman_win); hook_associate ("config save", save_config_cb, playman_win); }
void showMainWindow(int argc, char** argv) { fprintf(stderr, "DEBUG: Running main window\n"); gtk_init(&argc, &argv); GtkWindow *window; // Main window window = GTK_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), 460, 450); gtk_container_set_border_width(GTK_CONTAINER(window), 8); gtk_window_set_title(GTK_WINDOW(window), _("Keyboard configuration tool")); /* TODO Set application icon GtkImage *app_icon = GTK_IMAGE(gtk_image_new_from_icon_name("keyboard", GTK_ICON_SIZE_SMALL_TOOLBAR)); gtk_window_set_icon( window, gtk_image_get_pixbuf(app_icon)); */ g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); GtkWidget *vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(window), vbox); GtkWidget *tabs = gtk_notebook_new(); gtk_container_add(GTK_CONTAINER(vbox), tabs); /* * Adding tabs to the notebook */ Distribution_Tab *tab_distributions = build_tab_distribution(); Others_Tab *tab_others = build_tab_others(); About_Tab *tab_credits = build_tab_credits(); gtk_notebook_append_page(GTK_NOTEBOOK(tabs), tab_distributions->tab_content, tab_distributions->tab_name); gtk_notebook_append_page(GTK_NOTEBOOK(tabs), tab_others->tab_content, tab_others->tab_name); gtk_notebook_append_page(GTK_NOTEBOOK(tabs), tab_credits->tab_content, tab_credits->tab_name); /* * Adding Control Buttons */ GtkWidget *control_box = gtk_hbox_new(FALSE, 4); gtk_container_add(GTK_CONTAINER(vbox), control_box); GtkWidget *span, *button_cancel, *button_accept, * button_aplic; span = gtk_label_new(""); gtk_widget_set_size_request(span, 45, 0); button_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_set_size_request(button_cancel, BUTTON_WIDTH, BUTTON_HIGH); button_accept = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_widget_set_size_request(button_accept, BUTTON_WIDTH, BUTTON_HIGH); button_aplic = gtk_button_new_from_stock(GTK_STOCK_APPLY); gtk_widget_set_size_request(button_aplic, BUTTON_WIDTH, BUTTON_HIGH); gtk_container_add(GTK_CONTAINER(control_box), span); gtk_container_add(GTK_CONTAINER(control_box), button_accept); gtk_container_add(GTK_CONTAINER(control_box), button_aplic); gtk_container_add(GTK_CONTAINER(control_box), button_cancel); g_signal_connect(button_accept, "clicked", G_CALLBACK(button_acept_callback), NULL); g_signal_connect(button_aplic, "clicked", G_CALLBACK(button_aplic_callback), NULL); g_signal_connect(button_cancel, "clicked", G_CALLBACK(button_cancel_callback), NULL); gtk_widget_show_all(GTK_WIDGET(window)); gtk_main(); }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *collection; GtkStyle *style; GError *err; clock_t start, end; GtkWidget *notebook; int i; bindtextdomain (GETTEXT_PACKAGE, MARCO_LOCALEDIR); textdomain(GETTEXT_PACKAGE); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); run_position_expression_tests (); #if 0 run_position_expression_timings (); #endif gtk_init (&argc, &argv); if (g_getenv ("MARCO_DEBUG") != NULL) { meta_set_debugging (TRUE); meta_set_verbose (TRUE); } start = clock (); err = NULL; if (argc == 1) global_theme = meta_theme_load ("ClearlooksRe", &err); else if (argc == 2) global_theme = meta_theme_load (argv[1], &err); else { g_printerr (_("Usage: marco-theme-viewer [THEMENAME]\n")); exit (1); } end = clock (); if (global_theme == NULL) { g_printerr (_("Error loading theme: %s\n"), err->message); g_error_free (err); exit (1); } g_print (_("Loaded theme \"%s\" in %g seconds\n"), global_theme->name, (end - start) / (double) CLOCKS_PER_SEC); run_theme_benchmark (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 350, 350); if (strcmp (global_theme->name, global_theme->readable_name)==0) gtk_window_set_title (GTK_WINDOW (window), global_theme->readable_name); else { /* The theme directory name is different from the name the theme * gives itself within its file. Display both, directory name first. */ gchar *title = g_strconcat (global_theme->name, " - ", global_theme->readable_name, NULL); gtk_window_set_title (GTK_WINDOW (window), title); g_free (title); } g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_realize (window); style = gtk_widget_get_style (window); g_assert (style); g_assert (style->font_desc); notebook = gtk_notebook_new (); gtk_container_add (GTK_CONTAINER (window), notebook); collection = preview_collection (FONT_SIZE_NORMAL, style->font_desc); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Normal Title Font"))); collection = preview_collection (FONT_SIZE_SMALL, style->font_desc); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Small Title Font"))); collection = preview_collection (FONT_SIZE_LARGE, style->font_desc); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Large Title Font"))); collection = previews_of_button_layouts (); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Button Layouts"))); collection = benchmark_summary (); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), collection, gtk_label_new (_("Benchmark"))); i = 0; while (i < (int) G_N_ELEMENTS (previews)) { /* preview widget likes to be realized before its size request. * it's lame that way. */ gtk_widget_realize (previews[i]); ++i; } gtk_widget_show_all (window); gtk_main (); return 0; }
/* {EV_WINDOW_IMP}.make */ void F1123_15409 (EIF_REFERENCE Current) { GTCX EIF_REFERENCE loc1 = (EIF_REFERENCE) 0; EIF_REFERENCE loc2 = (EIF_REFERENCE) 0; EIF_POINTER loc3 = (EIF_POINTER) 0; EIF_POINTER tp1; EIF_REFERENCE tr1 = NULL; EIF_REFERENCE tr2 = NULL; EIF_REFERENCE tr3 = NULL; EIF_REFERENCE tr4 = NULL; EIF_REFERENCE tr5 = NULL; EIF_REFERENCE tr6 = NULL; EIF_INTEGER_32 ti4_1; RTCFDT; RTCDT; RTLD; RTLI(9); RTLR(0,Current); RTLR(1,loc1); RTLR(2,tr1); RTLR(3,loc2); RTLR(4,tr2); RTLR(5,tr3); RTLR(6,tr4); RTLR(7,tr5); RTLR(8,tr6); RTGC; F1029_13080(Current, (EIF_BOOLEAN) 0); loc1 = RTOSCF(14148,F1079_14148,(Current)); tp1 = (FUNCTION_CAST(EIF_POINTER, (EIF_REFERENCE)) R11929[dtype-1122])(Current); F1079_14134(Current, tp1); loc3 = *(EIF_POINTER *)(Current + O10979[dtype-1078]); { static EIF_TYPE_INDEX typarr0[] = {692,934,874,0xFFFF}; EIF_TYPE_INDEX typres0; static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE; typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(dftype, typarr0))); tr1 = RTLNSMART(eif_non_attached_type(typres0)); } F693_6432(RTCV(tr1), ((EIF_INTEGER_32) 10L)); RTAR(Current, tr1); *(EIF_REFERENCE *)(Current + O11864[dtype-1114]) = (EIF_REFERENCE) tr1; tr1 = RTLNSMART(eif_non_attached_type(973)); F930_10736(RTCV(tr1)); RTAR(Current, tr1); *(EIF_REFERENCE *)(Current + O11836[dtype-1114]) = (EIF_REFERENCE) tr1; tr1 = RTLNSMART(eif_non_attached_type(973)); F930_10736(RTCV(tr1)); RTAR(Current, tr1); *(EIF_REFERENCE *)(Current + O11837[dtype-1114]) = (EIF_REFERENCE) tr1; *(EIF_INTEGER_32 *)(Current + O11960[dtype-1122]) = (EIF_INTEGER_32) ((EIF_INTEGER_32) 32000L); *(EIF_INTEGER_32 *)(Current + O11959[dtype-1122]) = (EIF_INTEGER_32) ((EIF_INTEGER_32) 32000L); loc2 = *(EIF_REFERENCE *)(RTCV(loc1) + _REFACS_42_); F1123_15444(Current); tr1 = RTOSCF(2442,F67_2442,(RTCV(loc1))); { static EIF_TYPE_INDEX typarr0[] = {0xFFF9,2,841,792,874,0xFFFF}; EIF_TYPE_INDEX typres0; static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE; typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(dftype, typarr0))); tr2 = RTLNTS(typres0, 3, 0); } ((EIF_TYPED_VALUE *)tr2+1)->it_r = loc2; RTAR(tr2,loc2); ti4_1 = *(EIF_INTEGER_32 *)(Current + O6499[dtype-787]); ((EIF_TYPED_VALUE *)tr2+2)->it_i4 = ti4_1; { static EIF_TYPE_INDEX typarr0[] = {915,792,0xFFF9,1,841,913,0xFFFF}; EIF_TYPE_INDEX typres0; static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE; typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(dftype, typarr0))); tr5 = RTLNRF(typres0, (EIF_POINTER) __A412_327_3, (EIF_POINTER) _A412_327_3, (EIF_POINTER)(F790_8076),tr2, 1, 1); } tr6 = RTOSCF(8401,F793_8401,(RTCV(loc2))); F793_8399(RTCV(loc2), loc3, tr1, tr5, tr6, (EIF_BOOLEAN) 1); gtk_window_set_default_size((GtkWindow*) loc3, (gint) ((EIF_INTEGER_32) 1L), (gint) ((EIF_INTEGER_32) 1L)); F1119_15323(Current); tp1 = (EIF_POINTER) (((GtkWidget *)loc3)->window); ti4_1 = (FUNCTION_CAST(EIF_INTEGER_32, (EIF_REFERENCE)) R11042[dtype-1081])(Current); gdk_window_set_decorations((GdkWindow*) tp1, (GdkWMDecoration) ti4_1); *(EIF_BOOLEAN *)(Current + O11867[dtype-1114]) = (EIF_BOOLEAN) (EIF_BOOLEAN) 1; *(EIF_BOOLEAN *)(Current + O11041[dtype-1081]) = (EIF_BOOLEAN) (EIF_BOOLEAN) 1; *(EIF_BOOLEAN *)(Current + O11843[dtype-1114]) = (EIF_BOOLEAN) (EIF_BOOLEAN) 1; F1029_13080(Current, (EIF_BOOLEAN) 1); RTLE; }
/*! \brief load_status_pf() is called to create the ECU status window, load the settings from the StatusMapFile. */ G_MODULE_EXPORT void load_status_pf(void) { gchar *filename = NULL; gint x = 0; gint y = 0; gint w = 0; gint h = 0; GtkWidget * window; GtkWidget * parent; GladeXML *xml = NULL; gboolean xml_result = FALSE; xmlDoc *doc = NULL; xmlNode *root_element = NULL; GladeXML *main_xml; Firmware_Details *firmware = NULL; CmdLineArgs *args = NULL; args = DATA_GET(global_data,"args"); firmware = DATA_GET(global_data,"firmware"); g_return_if_fail(firmware); g_return_if_fail(args); if (!(DATA_GET(global_data,"interrogated"))) return; if (!firmware->status_map_file) { //dbg_func(CRITICAL,g_strdup_printf(__FILE__": firmware->status_map_file is UNDEFINED,\n\texiting status window creation routine!!!!\n")); return; } gdk_threads_enter(); set_title(g_strdup(_("Loading RT Status..."))); filename = get_file(g_build_path(PSEP,RTSTATUS_DATA_DIR,firmware->status_map_file,NULL),g_strdup("xml")); if (!filename) { dbg_func(CRITICAL,g_strdup_printf(__FILE__": load_runtime_status()\n\t File \"%s.xml\" not found!!, exiting function\n",firmware->status_map_file)); set_title(g_strdup(_("ERROR RT Statusfile DOES NOT EXIST!!!"))); gdk_threads_leave(); return; } main_xml = (GladeXML *)DATA_GET(global_data,"main_xml"); xml = glade_xml_new(main_xml->filename,"status_window",NULL); window = glade_xml_get_widget(xml,"status_window"); register_widget("status_window",window); gtk_window_set_focus_on_map((GtkWindow *)window,FALSE); gtk_window_set_title(GTK_WINDOW(window),_("ECU Status")); x = (GINT)DATA_GET(global_data,"status_x_origin"); y = (GINT)DATA_GET(global_data,"status_y_origin"); gtk_window_move(GTK_WINDOW(window),x,y); w = (GINT)DATA_GET(global_data,"status_width"); h = (GINT)DATA_GET(global_data,"status_height"); gtk_window_set_default_size(GTK_WINDOW(window),w,h); /* if (g_strcasecmp(firmware->actual_signature,DATA_GET(global_data,"last_signature")) == 0) gtk_window_set_default_size(GTK_WINDOW(window),w,h); else gtk_window_set_default_size(GTK_WINDOW(window),-1,-1); */ // gtk_window_resize(GTK_WINDOW(window),w,h); // g_object_set(window, "resizable", FALSE, NULL); parent = glade_xml_get_widget(xml,"status_vbox"); glade_xml_signal_autoconnect(xml); LIBXML_TEST_VERSION doc = xmlReadFile(filename, NULL, 0); g_free(filename); if (doc == NULL) { printf(_("error: could not parse file %s\n"),filename); gdk_threads_leave(); return; } root_element = xmlDocGetRootElement(doc); xml_result = load_status_xml_elements(root_element,parent); xmlFreeDoc(doc); xmlCleanupParser(); if (xml_result == FALSE) gtk_widget_destroy(window); else if ((!args->hide_status) && (xml_result)) gtk_widget_show_all(window); set_title(g_strdup(_("RT Status Loaded..."))); gdk_threads_leave(); return; }
Frame *gui_frame_new(int show) { GtkWidget *window, *vbox, *hbox, *notebook, *statusbar, *vbox2; Frame *frame; frame = g_new0(Frame, 1); /* create the window */ frame->widget = window = gtk_window_new(GTK_WINDOW_TOPLEVEL); frame->window = GTK_WINDOW(window); g_object_set_data(G_OBJECT(window), "Frame", frame); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(event_destroy), frame); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(event_delete), frame); g_signal_connect(G_OBJECT(window), "focus_in_event", G_CALLBACK(event_focus), frame); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(event_key_press), frame); gtk_window_set_default_size(frame->window, 700, 400); gtk_window_set_resizable(frame->window, TRUE); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); /* menu */ frame->menubar = gui_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), frame->menubar, FALSE, FALSE, 0); /* hbox: channel switcher + notebook */ hbox = gtk_hpaned_new(); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 0); gtk_paned_add2(GTK_PANED(hbox), vbox2); notebook = gtk_notebook_new(); g_signal_connect(G_OBJECT(notebook), "switch_page", G_CALLBACK(event_switch_page), frame); frame->notebook = GTK_NOTEBOOK(notebook); gtk_notebook_set_tab_pos(frame->notebook, GTK_POS_LEFT); gtk_notebook_set_scrollable(frame->notebook, TRUE); gtk_notebook_set_show_tabs(frame->notebook, FALSE); gtk_notebook_set_show_border(frame->notebook, FALSE); gtk_container_set_border_width(GTK_CONTAINER(frame->notebook), 0); gtk_box_pack_start(GTK_BOX(vbox2), notebook, TRUE, TRUE, 0); /* now add the windowlist. */ frame->winlist = gui_windowlist_new(frame); gtk_paned_add1(GTK_PANED(hbox), frame->winlist->widget); /* itemlist/entry */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, FALSE, 0); frame->itemlist = gui_itemlist_new(frame); gtk_box_pack_start(GTK_BOX(hbox), frame->itemlist->widget, FALSE, FALSE, 0); frame->entry = gui_entry_new(frame); gtk_box_pack_start(GTK_BOX(hbox), frame->entry->widget, TRUE, TRUE, 0); /* statusbar */ statusbar = gtk_statusbar_new(); frame->statusbar = GTK_STATUSBAR(statusbar); gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0); gtk_widget_grab_focus(frame->entry->widget); gtk_widget_show_all(vbox); gtk_widget_hide(frame->itemlist->widget); if (show) gtk_widget_show(window); frames = g_slist_prepend(frames, frame); signal_emit("gui frame created", 1, frame); return frame; }
int main(int argc, char** argv){ gtk_init(&argc, &argv); GtkWidget *window; GtkWidget *VBox; GtkWidget *table; GtkWidget *MenuBar; GtkWidget *MenuItem; GtkWidget *MenuIgem; GtkWidget *MenuIhem; GtkWidget *Entrer; GtkWidget *Bouton[18]; GtkWidget *label; //*Création de fenêtre principal window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), 255, 200); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_title(GTK_WINDOW(window)," Calculatrice"); gtk_window_set_modal(GTK_WINDOW(window), TRUE); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL ); table = gtk_table_new(4, 4, 1); gtk_container_add(GTK_CONTAINER(window), table); gtk_container_set_border_width(GTK_CONTAINER(table),5); gchar buffer[G_ASCII_DTOSTR_BUF_SIZE]; int i=0,x=5,y=6; for (i = 0; i < 9; i++) { Bouton[i+1] = gtk_button_new_with_label(g_ascii_dtostr (buffer, G_ASCII_DTOSTR_BUF_SIZE, i+1)); if((i%3)==0){ x--;y--; } gtk_table_attach(GTK_TABLE(table), Bouton[i+1], i%3, i%3+1, x, y,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); } Bouton[0] = gtk_button_new_with_label("0"); gtk_table_attach(GTK_TABLE(table), Bouton[0],0, 1, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); Bouton[10] = gtk_button_new_with_label(","); gtk_table_attach(GTK_TABLE(table), Bouton[10],1, 2, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); Bouton[11] = gtk_button_new_with_label("="); gtk_table_attach(GTK_TABLE(table), Bouton[11],2, 3, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); Bouton[12] = gtk_button_new_with_label("x"); gtk_table_attach(GTK_TABLE(table), Bouton[12],3, 4, 5, 6,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); Bouton[13] = gtk_button_new_with_label("/"); gtk_table_attach(GTK_TABLE(table), Bouton[13],3, 4, 4, 5,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); Bouton[14] = gtk_button_new_with_label("+"); gtk_table_attach(GTK_TABLE(table), Bouton[14],3, 4, 3, 4,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); Bouton[15] = gtk_button_new_with_label("-"); gtk_table_attach(GTK_TABLE(table), Bouton[15],3, 4, 2, 3,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); Bouton[16] = gtk_button_new_with_label("clear"); gtk_table_attach(GTK_TABLE(table), Bouton[16],0, 4, 6, 7,GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); MyData data; data.Entrer = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(data.Entrer), "0"); gtk_widget_set_can_focus(GTK_WIDGET(data.Entrer), FALSE); gtk_table_attach(GTK_TABLE(table), data.Entrer, 0, 4, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND,0, 0); for(i=0;i<11;i++){ g_signal_connect(G_OBJECT(Bouton[i]), "clicked", G_CALLBACK(_setText),(GtkWidget*)data.Entrer); } g_signal_connect(G_OBJECT(Bouton[11]), "clicked", G_CALLBACK(result),&data); g_signal_connect(G_OBJECT(Bouton[12]), "clicked", G_CALLBACK(mul),&data); g_signal_connect(G_OBJECT(Bouton[13]), "clicked", G_CALLBACK(divide),&data); g_signal_connect(G_OBJECT(Bouton[14]), "clicked", G_CALLBACK(add),&data); g_signal_connect(G_OBJECT(Bouton[15]), "clicked", G_CALLBACK(sub),&data); g_signal_connect(G_OBJECT(Bouton[16]), "clicked", G_CALLBACK(clear),&data); gtk_widget_show_all(window); gtk_main(); return 0; }
gint main ( gint argc, gchar **argv) { struct info vars; GtkWidget *mainwin; GtkWidget *but; GtkWidget *grid; GtkWidget *label, *r1_label, *c1_label, *c2_label; gtk_init (&argc, &argv); mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position (GTK_WINDOW (mainwin), GTK_WIN_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (mainwin), 300, 250); gtk_window_set_title (GTK_WINDOW (mainwin), "BCard"); gtk_window_set_resizable (GTK_WINDOW (mainwin), FALSE); g_signal_connect (mainwin, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_container_set_border_width (GTK_CONTAINER (mainwin), 10); const gchar *str = "Welcome to BCard"; label = gtk_label_new (str); char *markup; markup = g_markup_printf_escaped ("<span foreground=\"black\" size=\"x-large\"><b>%s</b></span>", str); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); vars.row_entry = gtk_entry_new (); vars.c1_entry = gtk_entry_new (); vars.c2_entry = gtk_entry_new (); gtk_entry_set_visibility (GTK_ENTRY (vars.row_entry), FALSE); gtk_entry_set_max_length (GTK_ENTRY (vars.row_entry), 2); gtk_entry_set_visibility (GTK_ENTRY (vars.c1_entry), FALSE); gtk_entry_set_max_length (GTK_ENTRY (vars.c1_entry), 1); gtk_entry_set_visibility (GTK_ENTRY (vars.c2_entry), FALSE); gtk_entry_set_max_length (GTK_ENTRY (vars.c2_entry), 1); r1_label = gtk_label_new ("Riga"); c1_label = gtk_label_new ("Cifra 1"); c2_label = gtk_label_new ("Cifra 2"); but = gtk_button_new_with_label ("OK"); g_signal_connect (but, "clicked", G_CALLBACK (check_input), &vars); grid = gtk_grid_new(); gtk_container_add (GTK_CONTAINER (mainwin), grid); gtk_grid_set_row_homogeneous (GTK_GRID (grid), TRUE); gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE); gtk_grid_set_row_spacing (GTK_GRID (grid), 5); gtk_grid_set_column_spacing (GTK_GRID (grid), 5); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 3, 1); gtk_grid_attach (GTK_GRID (grid), r1_label, 0, 1, 1, 1); gtk_grid_attach (GTK_GRID (grid), vars.row_entry, 1, 1, 2, 1); gtk_grid_attach (GTK_GRID (grid), c1_label, 0, 2, 1, 1); gtk_grid_attach (GTK_GRID (grid), vars.c1_entry, 1, 2, 2, 1); gtk_grid_attach (GTK_GRID (grid), c2_label, 0, 3, 1, 1); gtk_grid_attach (GTK_GRID (grid), vars.c2_entry, 1, 3, 2, 1); gtk_grid_attach (GTK_GRID (grid), but, 1, 4, 2, 1); gtk_widget_show_all (mainwin); gtk_main(); return 0; }
int main(int argc, char **argv) { GtkWidget *vbox; int options; options = get_options(argc, argv); if(options != 0) return options; gtk_init(&argc, &argv); lightpad = g_slice_new0(Window); lightpad->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size((GtkWindow*)lightpad->window, 800, 400); gtk_window_set_title(GTK_WINDOW(lightpad->window), "Lightpad"); gtk_window_set_default_icon_name("accessories-text-editor"); gtk_container_set_border_width(GTK_CONTAINER(lightpad->window), 0); { lightpad->popup = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_can_focus(lightpad->popup, TRUE); gtk_window_set_decorated(GTK_WINDOW(lightpad->popup), FALSE); gtk_window_set_type_hint(GTK_WINDOW(lightpad->popup), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_window_set_transient_for(GTK_WINDOW(lightpad->popup), lightpad->window); GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); lightpad->popupBox = vbox; gtk_container_add(GTK_CONTAINER(lightpad->popup), vbox); } vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(lightpad->window), vbox); lightpad->tabs = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(lightpad->tabs), TRUE); gtk_box_pack_start(GTK_BOX(vbox), lightpad->tabs, TRUE, TRUE, 0); g_signal_connect(lightpad->window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(lightpad->window, "delete-event", G_CALLBACK(on_delete_window), NULL); g_signal_connect(lightpad->window, "key-press-event", G_CALLBACK(on_keypress_window), NULL); g_signal_connect(lightpad->tabs, "page-added", G_CALLBACK(on_page_added), NULL); if(init_config() < 0) return -1; if(remaining) { for (int i = 0; remaining[i]; i++) new_view(remaining[i]); g_strfreev(remaining); } else new_view(NULL); gtk_widget_show_all(lightpad->window); gtk_main(); /* This will destroy all the children, who in turn * will destroy their own children et cetera. * Thus, there is no need to explicitly destroy * all the GtkScrolledWindow objects */ gtk_widget_destroy(lightpad->window); g_slice_free(Window, lightpad); g_free((gpointer)settings->font); g_free((gpointer)settings->scheme); g_slice_free(Settings, settings); return 0; }
gint tag_edit_dialog(struct tags *otag, struct tags *ntag, gchar *file, struct con_win *cwin) { GtkWidget *dialog; GtkWidget *tag_table; GtkWidget *label_title, *label_artist, *label_album, *label_genre, *label_tno, *label_year, *label_comment, *label_file; GtkWidget *chk_title, *chk_artist, *chk_album, *chk_genre, *chk_tno, *chk_year, *chk_comment; GtkWidget *entry_title, *entry_artist, *entry_album, *entry_genre, *entry_tno, *entry_year, *entry_comment, *entry_file; GtkWidget *hbox_title, *hbox_artist, *hbox_album, *hbox_genre, *hbox_tno, *hbox_year, *hbox_comment; GtkWidget *hbox_spins, *comment_view_scroll, *chk_alignment; GtkTextBuffer *buffer; GtkTextIter start, end; gpointer storage; gint location_id, result, changed = 0; struct musicobject *mobj = NULL; gchar *uri = NULL; /*Create table*/ tag_table = gtk_table_new(8, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(tag_table), 5); gtk_table_set_row_spacings(GTK_TABLE(tag_table), 5); gtk_container_set_border_width(GTK_CONTAINER(tag_table), 5); /* Create labels */ label_title = gtk_label_new(_("Title")); label_artist = gtk_label_new(_("Artist")); label_album = gtk_label_new(_("Album")); label_genre = gtk_label_new(_("Genre")); label_tno = gtk_label_new(_("Track No")); label_year = gtk_label_new(_("Year")); label_comment = gtk_label_new(_("Comment")); label_file = gtk_label_new(_("File")); gtk_misc_set_alignment(GTK_MISC (label_title), 1, 0.5); gtk_misc_set_alignment(GTK_MISC (label_artist), 1, 0.5); gtk_misc_set_alignment(GTK_MISC (label_album), 1, 0.5); gtk_misc_set_alignment(GTK_MISC (label_genre), 1, 0.5); gtk_misc_set_alignment(GTK_MISC (label_tno), 1, 0.5); gtk_misc_set_alignment(GTK_MISC (label_year), 1, 0.5); gtk_misc_set_alignment(GTK_MISC (label_comment), 1, 0); gtk_misc_set_alignment(GTK_MISC (label_file), 1, 0.5); /* Create entry fields */ entry_title = gtk_entry_new(); entry_artist = gtk_entry_new(); entry_album = gtk_entry_new(); entry_genre = gtk_entry_new(); entry_tno = gtk_spin_button_new_with_range (0, 2030, 1); entry_year = gtk_spin_button_new_with_range (0, 2030, 1); entry_comment = gtk_text_view_new(); gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (entry_comment), FALSE); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (entry_comment)); entry_file = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry_title), TAG_MAX_LEN); gtk_entry_set_max_length(GTK_ENTRY(entry_artist), TAG_MAX_LEN); gtk_entry_set_max_length(GTK_ENTRY(entry_album), TAG_MAX_LEN); gtk_entry_set_max_length(GTK_ENTRY(entry_genre), TAG_MAX_LEN); gtk_entry_set_completion(GTK_ENTRY(entry_artist), cwin->completion[0]); gtk_entry_set_completion(GTK_ENTRY(entry_album), cwin->completion[1]); gtk_entry_set_completion(GTK_ENTRY(entry_genre), cwin->completion[2]); gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_title), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_artist), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_album), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_genre), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_file), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_DIRECTORY); gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_file), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_JUMP_TO); gtk_entry_set_editable (GTK_ENTRY(entry_file), FALSE); /* Create checkboxes */ chk_title = gtk_check_button_new(); chk_artist = gtk_check_button_new(); chk_album = gtk_check_button_new(); chk_genre = gtk_check_button_new(); chk_year = gtk_check_button_new(); chk_tno = gtk_check_button_new(); chk_comment = gtk_check_button_new(); hbox_title = gtk_hbox_new(FALSE, 0); hbox_artist = gtk_hbox_new(FALSE, 0); hbox_album = gtk_hbox_new(FALSE, 0); hbox_genre = gtk_hbox_new(FALSE, 0); hbox_year = gtk_hbox_new(FALSE, 0); hbox_tno = gtk_hbox_new(FALSE, 0); hbox_comment = gtk_hbox_new(FALSE, 0); hbox_spins = gtk_hbox_new(FALSE, 5); /* Create hobxs(ENTRY CHECHK) and attach in table */ gtk_box_pack_start(GTK_BOX(hbox_title), entry_title, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_title), chk_title, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE (tag_table), label_title, 0, 1, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), hbox_title, 1, 2, 0, 1, GTK_FILL|GTK_EXPAND, GTK_SHRINK, 0, 0); gtk_box_pack_start(GTK_BOX(hbox_artist), entry_artist, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_artist), chk_artist, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE (tag_table), label_artist, 0, 1, 1, 2, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), hbox_artist, 1, 2, 1, 2, GTK_FILL|GTK_EXPAND, GTK_SHRINK, 0, 0); gtk_box_pack_start(GTK_BOX(hbox_album), entry_album, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_album), chk_album, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE (tag_table), label_album, 0, 1, 2, 3, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), hbox_album, 1, 2, 2, 3, GTK_FILL|GTK_EXPAND, GTK_SHRINK, 0, 0); gtk_box_pack_start(GTK_BOX(hbox_genre), entry_genre, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_genre), chk_genre, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE (tag_table), label_genre, 0, 1, 3, 4, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), hbox_genre, 1, 2, 3, 4, GTK_FILL|GTK_EXPAND, GTK_SHRINK, 0, 0); gtk_box_pack_start(GTK_BOX(hbox_tno), entry_tno, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_tno), chk_tno, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_year), label_year, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox_year), entry_year, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_year), chk_year, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_spins), hbox_tno, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_spins), hbox_year, TRUE, TRUE, 0); gtk_table_attach(GTK_TABLE (tag_table), label_tno, 0, 1, 4, 5, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), hbox_spins, 1, 2, 4, 5, GTK_FILL|GTK_EXPAND, GTK_SHRINK, 0, 0); comment_view_scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comment_view_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(comment_view_scroll), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(comment_view_scroll), entry_comment); chk_alignment = gtk_alignment_new(0.5, 0, 0, 0); gtk_container_add(GTK_CONTAINER(chk_alignment), chk_comment); gtk_box_pack_start(GTK_BOX(hbox_comment), comment_view_scroll, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_comment), chk_alignment, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE (tag_table), label_comment, 0, 1, 5, 7, GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), hbox_comment, 1, 2, 5, 7, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), label_file, 0, 1, 7, 8, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE (tag_table), entry_file, 1, 2, 7, 8, GTK_FILL|GTK_EXPAND, GTK_SHRINK, 0, 0); /* The main edit dialog */ dialog = gtk_dialog_new_with_buttons(_("Edit tags"), GTK_WINDOW(cwin->mainwindow), GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 450, -1); /* Add to the dialog's main vbox */ gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), tag_table); /* Fill in initial entries */ if (otag->title) gtk_entry_set_text(GTK_ENTRY(entry_title), otag->title); if (otag->artist) gtk_entry_set_text(GTK_ENTRY(entry_artist), otag->artist); if (otag->album) gtk_entry_set_text(GTK_ENTRY(entry_album), otag->album); if (otag->genre) gtk_entry_set_text(GTK_ENTRY(entry_genre), otag->genre); if (otag->track_no > 0) gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry_tno), (int)otag->track_no); if (otag->year > 0) gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry_year), (int)otag->year); if (otag->comment) gtk_text_buffer_set_text (buffer, otag->comment, -1); if (file) { gtk_entry_set_text(GTK_ENTRY(entry_file), file); gtk_editable_set_position(GTK_EDITABLE(entry_file), strlen(file)); gtk_dialog_add_button(GTK_DIALOG(dialog), _("Details"), GTK_RESPONSE_HELP); } else gtk_widget_set_sensitive(GTK_WIDGET(entry_file), FALSE); /* Connect to check the save changes when change the entry. */ g_signal_connect(G_OBJECT(entry_title), "changed", G_CALLBACK(check_entry), chk_title); g_signal_connect(G_OBJECT(entry_artist), "changed", G_CALLBACK(check_entry), chk_artist); g_signal_connect(G_OBJECT(entry_album), "changed", G_CALLBACK(check_entry), chk_album); g_signal_connect(G_OBJECT(entry_genre), "changed", G_CALLBACK(check_entry), chk_genre); g_signal_connect(G_OBJECT(entry_tno), "changed", G_CALLBACK(check_entry), chk_tno); g_signal_connect(G_OBJECT(entry_year), "changed", G_CALLBACK(check_entry), chk_year); g_signal_connect(G_OBJECT(buffer), "changed", G_CALLBACK(check_entry), chk_comment); /* Save changes when press enter. */ gtk_entry_set_activates_default (GTK_ENTRY(entry_title), TRUE); gtk_entry_set_activates_default (GTK_ENTRY(entry_artist), TRUE); gtk_entry_set_activates_default (GTK_ENTRY(entry_album), TRUE); gtk_entry_set_activates_default (GTK_ENTRY(entry_genre), TRUE); gtk_entry_set_activates_default (GTK_ENTRY(entry_tno), TRUE); gtk_entry_set_activates_default (GTK_ENTRY(entry_year), TRUE); /* Connect to set clear check when click the icon. */ g_signal_connect (G_OBJECT(entry_title), "icon-press", G_CALLBACK (clear_pressed), NULL); g_signal_connect (G_OBJECT(entry_artist), "icon-press", G_CALLBACK (clear_pressed), NULL); g_signal_connect (G_OBJECT(entry_album), "icon-press", G_CALLBACK (clear_pressed), NULL); g_signal_connect (G_OBJECT(entry_genre), "icon-press", G_CALLBACK (clear_pressed), NULL); g_signal_connect (G_OBJECT(entry_file), "icon-press", G_CALLBACK (directory_pressed), file); /* Genereate storage of gtk_entry and cwin, * and add popup menu to copy selection to tags. */ storage = g_object_new(G_TYPE_OBJECT, NULL); g_object_set_data(storage, "entry_title", entry_title); g_object_set_data(storage, "entry_artist", entry_artist); g_object_set_data(storage, "entry_album", entry_album); g_object_set_data(storage, "entry_genre", entry_genre); g_object_set_data(storage, "entry_comment", entry_comment); g_object_set_data(storage, "entry_file", entry_file); g_object_set_data(storage, "cwin", cwin); g_signal_connect (G_OBJECT(entry_file), "populate-popup", G_CALLBACK (file_entry_populate_popup), storage); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_widget_show_all(dialog); while ((result = gtk_dialog_run (GTK_DIALOG (dialog))) && (result != GTK_RESPONSE_CANCEL) && (result != GTK_RESPONSE_OK) && (result != GTK_RESPONSE_DELETE_EVENT)) { if(result == GTK_RESPONSE_HELP){ if (g_str_has_prefix(file, "cdda://")) mobj = new_musicobject_from_cdda(cwin, otag->track_no); else { uri = sanitize_string_sqlite3(file); if ((location_id = find_location_db(uri, cwin))) mobj = new_musicobject_from_db(location_id, cwin); else mobj = new_musicobject_from_file(file); } track_properties(mobj, cwin); } } switch (result) { case GTK_RESPONSE_OK: if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_tno))) { ntag->track_no = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(entry_tno)); changed |= TAG_TNO_CHANGED; } if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_title))) { ntag->title = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_title))); changed |= TAG_TITLE_CHANGED; } if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_artist))) { ntag->artist = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_artist))); changed |= TAG_ARTIST_CHANGED; } if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_album))) { ntag->album = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_album))); changed |= TAG_ALBUM_CHANGED; } if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_genre))) { ntag->genre = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_genre))); changed |= TAG_GENRE_CHANGED; } if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_year))) { ntag->year = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(entry_year)); changed |= TAG_YEAR_CHANGED; } if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_comment))) { gtk_text_buffer_get_start_iter (buffer, &start); gtk_text_buffer_get_end_iter (buffer, &end); ntag->comment = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE)); changed |= TAG_COMMENT_CHANGED; } break; case GTK_RESPONSE_DELETE_EVENT: break; case GTK_RESPONSE_CANCEL: break; default: break; } gtk_widget_destroy(dialog); if (mobj) delete_musicobject(mobj); g_free(uri); return changed; }
int main (int argc, char* argv[]) { NautilusCustomizationData *customization_data; GtkWidget *window; GtkWidget *emblems_table, *button, *scroller; char *emblem_name, *dot_pos; GdkPixbuf *pixbuf; char *label; test_init (&argc, &argv); window = test_window_new ("Wrap Table Test", 10); gtk_window_set_default_size (GTK_WINDOW (window), 400, 300); /* The emblems wrapped table */ emblems_table = eel_wrap_table_new (TRUE); gtk_widget_show (emblems_table); gtk_container_set_border_width (GTK_CONTAINER (emblems_table), GNOME_PAD); scroller = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); /* Viewport */ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroller), emblems_table); gtk_container_add (GTK_CONTAINER (window), scroller); gtk_widget_show (scroller); #if 0 /* Get rid of default lowered shadow appearance. * This must be done after the widget is realized, due to * an apparent bug in gtk_viewport_set_shadow_type. */ g_signal_connect (GTK_BIN (scroller->child), "realize", remove_default_viewport_shadow, NULL); #endif /* Use nautilus_customization to make the emblem widgets */ customization_data = nautilus_customization_data_new ("emblems", TRUE, NAUTILUS_ICON_SIZE_SMALL, NAUTILUS_ICON_SIZE_SMALL); while (nautilus_customization_data_get_next_element_for_display (customization_data, &emblem_name, &pixbuf, &label) == GNOME_VFS_OK) { /* strip the suffix, if any */ dot_pos = strrchr(emblem_name, '.'); if (dot_pos) { *dot_pos = '\0'; } if (strcmp (emblem_name, "erase") == 0) { g_object_unref (pixbuf); g_free (label); g_free (emblem_name); continue; } button = eel_labeled_image_check_button_new (label, pixbuf); g_free (label); g_object_unref (pixbuf); /* Attach parameters and signal handler. */ g_object_set_data_full (G_OBJECT (button), "nautilus_property_name", emblem_name, (GDestroyNotify) g_free); gtk_container_add (GTK_CONTAINER (emblems_table), button); } gtk_widget_show_all (emblems_table); gtk_widget_show (window); gtk_main (); return 0; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *sw; GtkWidget *tv; GtkWidget *box; GtkWidget *combo_box; GtkTreeModel *model; GdkContentFormats *targets; gint i; gtk_init (); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm); #if 0 models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ()); #endif models[MODEL_LIST] = create_list_model (); models[MODEL_TREE] = create_tree_model (); model = create_list_model (); models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); model = create_tree_model (); models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT)); models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT)); models[MODEL_NULL] = NULL; run_automated_tests (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 430, 400); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), box); tv = gtk_tree_view_new_with_model (models[0]); g_signal_connect (tv, "row-activated", G_CALLBACK (on_row_activated), NULL); targets = gdk_content_formats_new (row_targets, G_N_ELEMENTS (row_targets)); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv), GDK_BUTTON1_MASK, targets, GDK_ACTION_MOVE | GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv), targets, GDK_ACTION_MOVE | GDK_ACTION_COPY); gdk_content_formats_unref (targets); /* Model menu */ combo_box = gtk_combo_box_text_new (); gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER); for (i = 0; i < MODEL_LAST; i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), model_names[i]); gtk_container_add (GTK_CONTAINER (box), combo_box); g_signal_connect (combo_box, "changed", G_CALLBACK (model_selected), tv); /* Columns menu */ combo_box = gtk_combo_box_text_new (); gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER); for (i = 0; i < COLUMNS_LAST; i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), column_type_names[i]); gtk_container_add (GTK_CONTAINER (box), combo_box); set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS); gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), COLUMNS_LOTS); g_signal_connect (combo_box, "changed", G_CALLBACK (columns_selected), tv); sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_hexpand (sw, TRUE); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (box), sw); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show (window); gtk_main (); return 0; }