GtkWidget * gimp_buffer_view_new (GimpViewType view_type, GimpContainer *container, GimpContext *context, gint view_size, gint view_border_width, GimpMenuFactory *menu_factory) { GimpBufferView *buffer_view; GimpContainerEditor *editor; GtkWidget *frame; GtkWidget *hbox; buffer_view = g_object_new (GIMP_TYPE_BUFFER_VIEW, NULL); if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (buffer_view), view_type, container, context, view_size, view_border_width, menu_factory, "<Buffers>", "/buffers-popup")) { g_object_unref (buffer_view); return NULL; } editor = GIMP_CONTAINER_EDITOR (buffer_view); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (editor), frame, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (editor), frame, 0); gtk_widget_show (frame); hbox = gtk_hbox_new (FALSE, 2); gtk_container_set_border_width (GTK_CONTAINER (hbox), 2); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); buffer_view->global_view = gimp_view_new_full_by_types (NULL, GIMP_TYPE_VIEW, GIMP_TYPE_BUFFER, view_size, view_size, view_border_width, FALSE, FALSE, TRUE); gtk_box_pack_start (GTK_BOX (hbox), buffer_view->global_view, FALSE, FALSE, 0); gtk_widget_show (buffer_view->global_view); g_signal_connect_object (editor->view, "notify::view-size", G_CALLBACK (gimp_buffer_view_view_notify), buffer_view, 0); g_signal_connect_object (editor->view, "notify::view-border-width", G_CALLBACK (gimp_buffer_view_view_notify), buffer_view, 0); buffer_view->global_label = gtk_label_new (_("(None)")); gtk_box_pack_start (GTK_BOX (hbox), buffer_view->global_label, FALSE, FALSE, 0); gtk_widget_show (buffer_view->global_label); g_signal_connect_object (context->gimp, "buffer-changed", G_CALLBACK (gimp_buffer_view_buffer_changed), G_OBJECT (buffer_view), 0); gimp_buffer_view_buffer_changed (context->gimp, buffer_view); buffer_view->paste_button = gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", "buffers-paste", NULL); buffer_view->paste_into_button = gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", "buffers-paste-into", NULL); buffer_view->paste_as_new_button = gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", "buffers-paste-as-new", NULL); buffer_view->delete_button = gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers", "buffers-delete", NULL); gimp_container_view_enable_dnd (editor->view, GTK_BUTTON (buffer_view->paste_button), GIMP_TYPE_BUFFER); gimp_container_view_enable_dnd (editor->view, GTK_BUTTON (buffer_view->paste_into_button), GIMP_TYPE_BUFFER); gimp_container_view_enable_dnd (editor->view, GTK_BUTTON (buffer_view->paste_as_new_button), GIMP_TYPE_BUFFER); gimp_container_view_enable_dnd (editor->view, GTK_BUTTON (buffer_view->delete_button), GIMP_TYPE_BUFFER); gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor->view)), editor); return GTK_WIDGET (buffer_view); }
static void fs_rtp_sub_stream_constructed (GObject *object) { FsRtpSubStream *self = FS_RTP_SUB_STREAM (object); GstPad *valve_sink_pad = NULL; GstPadLinkReturn linkret; gchar *tmp; GST_DEBUG ("New substream in session %u for ssrc %x and pt %u", self->priv->session->id, self->ssrc, self->pt); if (!self->priv->conference) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_INVALID_ARGUMENTS, "A Substream needs a conference object"); return; } self->priv->rtpbin_unlinked_sig = g_signal_connect_object ( self->priv->rtpbin_pad, "unlinked", G_CALLBACK (rtpbin_pad_unlinked), self, 0); tmp = g_strdup_printf ("output_recv_valve_%d_%d_%d", self->priv->session->id, self->ssrc, self->pt); self->priv->output_valve = gst_element_factory_make ("valve", tmp); g_free (tmp); if (!self->priv->output_valve) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not create a valve element for" " session substream with ssrc: %u and pt:%d", self->ssrc, self->pt); return; } if (!gst_bin_add (GST_BIN (self->priv->conference), self->priv->output_valve)) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not add the valve element for session" " substream with ssrc: %u and pt:%d to the conference bin", self->ssrc, self->pt); return; } /* We set the valve to dropping, the stream will unblock it when its linked */ g_object_set (self->priv->output_valve, "drop", TRUE, NULL); if (gst_element_set_state (self->priv->output_valve, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not set the valve element for session" " substream with ssrc: %u and pt:%d to the playing state", self->ssrc, self->pt); return; } tmp = g_strdup_printf ("recv_capsfilter_%d_%d_%d", self->priv->session->id, self->ssrc, self->pt); self->priv->capsfilter = gst_element_factory_make ("capsfilter", tmp); g_free (tmp); if (!self->priv->capsfilter) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not create a capsfilter element for" " session substream with ssrc: %u and pt:%d", self->ssrc, self->pt); return; } if (!gst_bin_add (GST_BIN (self->priv->conference), self->priv->capsfilter)) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not add the capsfilter element for session" " substream with ssrc: %u and pt:%d to the conference bin", self->ssrc, self->pt); return; } if (gst_element_set_state (self->priv->capsfilter, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not set the capsfilter element for session" " substream with ssrc: %u and pt:%d to the playing state", self->ssrc, self->pt); return; } tmp = g_strdup_printf ("input_recv_valve_%d_%d_%d", self->priv->session->id, self->ssrc, self->pt); self->priv->input_valve = gst_element_factory_make ("valve", tmp); g_free (tmp); if (!self->priv->input_valve) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not create a valve element for" " session substream with ssrc: %u and pt:%d", self->ssrc, self->pt); return; } if (!gst_bin_add (GST_BIN (self->priv->conference), self->priv->input_valve)) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not add the valve element for session" " substream with ssrc: %u and pt:%d to the conference bin", self->ssrc, self->pt); return; } if (gst_element_set_state (self->priv->input_valve, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not set the valve element for session" " substream with ssrc: %u and pt:%d to the playing state", self->ssrc, self->pt); return; } if (!gst_element_link (self->priv->input_valve, self->priv->capsfilter)) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not link the input valve" " and the capsfilter"); return; } valve_sink_pad = gst_element_get_static_pad (self->priv->input_valve, "sink"); if (!valve_sink_pad) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not get the valve's sink pad"); return; } linkret = gst_pad_link (self->priv->rtpbin_pad, valve_sink_pad); gst_object_unref (valve_sink_pad); if (GST_PAD_LINK_FAILED (linkret)) { self->priv->construction_error = g_error_new (FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not link the rtpbin to the codec bin (%d)", linkret); return; } if (self->no_rtcp_timeout > 0) if (!fs_rtp_sub_stream_start_no_rtcp_timeout_thread (self, &self->priv->construction_error)) return; GST_CALL_PARENT (G_OBJECT_CLASS, constructed, (object)); }
static void impl_constructed (GObject *object) { RBPodcastAddDialog *dialog; GtkBuilder *builder; GtkWidget *widget; GtkWidget *paned; GtkTreeViewColumn *column; GtkCellRenderer *renderer; RBEntryView *episodes; RBShellPlayer *shell_player; RhythmDBQuery *query; RhythmDBQueryModel *query_model; const char *episode_strings[3]; RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object); dialog = RB_PODCAST_ADD_DIALOG (object); g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL); builder = rb_builder_load ("podcast-add-dialog.ui", NULL); dialog->priv->info_bar_message = gtk_label_new (""); dialog->priv->info_bar = gtk_info_bar_new (); g_object_set (dialog->priv->info_bar, "spacing", 0, NULL); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))), dialog->priv->info_bar_message); gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE); gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0); gtk_widget_show (dialog->priv->info_bar_message); dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button")); g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0); gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE); dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view")); g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)), "changed", G_CALLBACK (feed_selection_changed_cb), dialog); dialog->priv->search_entry = rb_search_entry_new (FALSE); gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1); g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL); g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog); g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog); gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")), GTK_WIDGET (dialog->priv->search_entry)); g_signal_connect (gtk_builder_get_object (builder, "close-button"), "clicked", G_CALLBACK (close_clicked_cb), dialog); dialog->priv->feed_model = gtk_list_store_new (7, G_TYPE_STRING, /* name */ G_TYPE_STRING, /* author */ GDK_TYPE_PIXBUF, /* image */ G_TYPE_FILE, /* image file */ G_TYPE_INT, /* episode count */ G_TYPE_POINTER, /* RBPodcastChannel */ G_TYPE_ULONG); /* date */ gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model)); column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL); episode_strings[0] = "0000"; episode_strings[1] = _("Episodes"); episode_strings[2] = NULL; rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog")); gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog->priv->feed_view), TRUE); /* set up episode view */ g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL); episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE); g_object_unref (shell_player); g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog); /* date column */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); { const char *sample_strings[3]; sample_strings[0] = _("Date"); sample_strings[1] = rb_entry_view_get_time_date_column_sample (); sample_strings[2] = NULL; rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings); } gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) podcast_post_date_cell_data_func, dialog, NULL); rb_entry_view_append_column_custom (episodes, column, _("Date"), "Date", (GCompareDataFunc) podcast_post_date_sort_func, 0, NULL); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE); rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING); g_signal_connect (episodes, "notify::sort-order", G_CALLBACK (episodes_sort_changed_cb), dialog); query = rhythmdb_query_parse (dialog->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH, RHYTHMDB_QUERY_END); query_model = rhythmdb_query_model_new_empty (dialog->priv->db); rb_entry_view_set_model (episodes, query_model); rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query); rhythmdb_query_free (query); g_object_unref (query_model); paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned")); g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog); gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET (episodes), TRUE, FALSE); gtk_widget_show_all (GTK_WIDGET (dialog)); g_object_unref (builder); }
static void tpaw_user_info_constructed (GObject *object) { TpawUserInfo *self = (TpawUserInfo *) object; GtkGrid *grid = (GtkGrid *) self; GtkWidget *infobar; GtkWidget *infobar_content; GtkWidget *infobar_label; GtkWidget *title; G_OBJECT_CLASS (tpaw_user_info_parent_class)->constructed (object); gtk_grid_set_column_spacing (grid, 6); gtk_grid_set_row_spacing (grid, 6); infobar = gtk_info_bar_new (); g_object_set (infobar, "margin-bottom", 6, NULL); gtk_info_bar_set_message_type (GTK_INFO_BAR (infobar), GTK_MESSAGE_INFO); infobar_content = gtk_info_bar_get_content_area (GTK_INFO_BAR (infobar)); infobar_label = gtk_label_new ( _("These details will be shared with other users on this " "chat network.")); gtk_container_add (GTK_CONTAINER (infobar_content), infobar_label); gtk_widget_show (infobar_label); gtk_grid_attach_next_to ((GtkGrid *) self, infobar, NULL, GTK_POS_TOP, 3, 1); gtk_widget_show (infobar); /* Setup id label */ title = gtk_label_new (_("Identifier")); self->priv->identifier_label = gtk_label_new ( tp_account_get_normalized_name (self->priv->account)); add_row (grid, title, self->priv->identifier_label, FALSE); g_signal_connect_object (self->priv->account, "notify::normalized-name", G_CALLBACK (identifier_notify_cb), self, 0); /* Setup nickname entry */ title = gtk_label_new (_("Alias")); self->priv->nickname_entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (self->priv->nickname_entry), tp_account_get_nickname (self->priv->account)); add_row (grid, title, self->priv->nickname_entry, FALSE); g_signal_connect_object (self->priv->account, "notify::nickname", G_CALLBACK (nickname_notify_cb), self, 0); /* Set up avatar chooser */ self->priv->avatar_chooser = tpaw_avatar_chooser_new (self->priv->account, -1); gtk_grid_attach (grid, self->priv->avatar_chooser, 2, 0, 1, 3); gtk_widget_show (self->priv->avatar_chooser); /* Details label */ self->priv->details_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (self->priv->details_label), _("<b>Personal Details</b>")); gtk_misc_set_alignment (GTK_MISC (self->priv->details_label), 0, 0.5); gtk_grid_attach_next_to (grid, self->priv->details_label, NULL, GTK_POS_BOTTOM, 3, 1); /* Details spinner */ self->priv->details_spinner = gtk_spinner_new (); gtk_widget_set_hexpand (self->priv->details_spinner, TRUE); gtk_widget_set_vexpand (self->priv->details_spinner, TRUE); gtk_grid_attach_next_to (grid, self->priv->details_spinner, NULL, GTK_POS_BOTTOM, 3, 1); g_signal_connect_swapped (self->priv->account, "notify::connection", G_CALLBACK (connection_notify_cb), self); connection_notify_cb (self); }
EaseSlideButtonPanel* ease_slide_button_panel_construct (GType object_type, EaseDocument* d, EaseEditorWindow* win) { #line 238 "ease-slide-button-panel.c" EaseSlideButtonPanel * self; EaseDocument* _tmp0_; EaseEditorWindow* _tmp1_; GtkTreeView* _tmp2_; GtkCellRendererPixbuf* _tmp3_; GtkViewport* viewport; EaseSlide* s; #line 63 "ease-slide-button-panel.vala" g_return_val_if_fail (d != NULL, NULL); #line 63 "ease-slide-button-panel.vala" g_return_val_if_fail (win != NULL, NULL); #line 250 "ease-slide-button-panel.c" self = g_object_newv (object_type, 0, NULL); #line 65 "ease-slide-button-panel.vala" self->priv->document = (_tmp0_ = _g_object_ref0 (d), _g_object_unref0 (self->priv->document), _tmp0_); #line 66 "ease-slide-button-panel.vala" self->priv->owner = (_tmp1_ = _g_object_ref0 (win), _g_object_unref0 (self->priv->owner), _tmp1_); #line 67 "ease-slide-button-panel.vala" g_object_set ((GtkWidget*) self, "width-request", EASE_SLIDE_BUTTON_PANEL_WIDTH_REQUEST, NULL); #line 70 "ease-slide-button-panel.vala" g_object_set ((GtkScrolledWindow*) self, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL); #line 71 "ease-slide-button-panel.vala" g_object_set ((GtkScrolledWindow*) self, "hscrollbar-policy", GTK_POLICY_NEVER, NULL); #line 72 "ease-slide-button-panel.vala" gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow*) self, GTK_SHADOW_IN); #line 75 "ease-slide-button-panel.vala" self->priv->slides = (_tmp2_ = g_object_ref_sink ((GtkTreeView*) gtk_tree_view_new ()), _g_object_unref0 (self->priv->slides), _tmp2_); #line 76 "ease-slide-button-panel.vala" gtk_tree_view_set_reorderable (self->priv->slides, TRUE); #line 77 "ease-slide-button-panel.vala" gtk_tree_view_set_headers_visible (self->priv->slides, FALSE); #line 78 "ease-slide-button-panel.vala" self->priv->renderer = (_tmp3_ = g_object_ref_sink ((GtkCellRendererPixbuf*) gtk_cell_renderer_pixbuf_new ()), _g_object_unref0 (self->priv->renderer), _tmp3_); #line 79 "ease-slide-button-panel.vala" gtk_cell_renderer_set_padding ((GtkCellRenderer*) self->priv->renderer, EASE_SLIDE_BUTTON_PANEL_PADDING, EASE_SLIDE_BUTTON_PANEL_PADDING); #line 80 "ease-slide-button-panel.vala" gtk_tree_view_insert_column_with_attributes (self->priv->slides, -1, "Slides", (GtkCellRenderer*) self->priv->renderer, "pixbuf", EASE_DOCUMENT_COL_PIXBUF, NULL); #line 82 "ease-slide-button-panel.vala" gtk_tree_view_set_model (self->priv->slides, (GtkTreeModel*) ease_document_get_slides (self->priv->document)); #line 86 "ease-slide-button-panel.vala" viewport = g_object_ref_sink ((GtkViewport*) gtk_viewport_new (NULL, NULL)); #line 87 "ease-slide-button-panel.vala" gtk_viewport_set_shadow_type (viewport, GTK_SHADOW_NONE); #line 88 "ease-slide-button-panel.vala" gtk_container_add ((GtkContainer*) viewport, (GtkWidget*) self->priv->slides); #line 89 "ease-slide-button-panel.vala" gtk_container_add ((GtkContainer*) self, (GtkWidget*) viewport); #line 286 "ease-slide-button-panel.c" s = NULL; { EaseIterableTreeModelIterator* _itr_it; #line 93 "ease-slide-button-panel.vala" _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) ease_document_get_slides (self->priv->document)); #line 93 "ease-slide-button-panel.vala" while (TRUE) { #line 294 "ease-slide-button-panel.c" GtkTreeIter _tmp4_ = {0}; GtkTreeIter itr; #line 93 "ease-slide-button-panel.vala" if (!ease_iterable_tree_model_iterator_next (_itr_it)) { #line 93 "ease-slide-button-panel.vala" break; #line 301 "ease-slide-button-panel.c" } #line 93 "ease-slide-button-panel.vala" itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp4_), _tmp4_); #line 95 "ease-slide-button-panel.vala" ease_slide_button_panel_slide_redraw (self, &itr); #line 96 "ease-slide-button-panel.vala" gtk_tree_model_get ((GtkTreeModel*) ease_document_get_slides (self->priv->document), &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1); #line 97 "ease-slide-button-panel.vala" g_signal_connect_object (s, "changed", (GCallback) _ease_slide_button_panel_on_slide_changed_ease_slide_changed, self, 0); #line 98 "ease-slide-button-panel.vala" g_signal_connect_object (s, "background-changed", (GCallback) _ease_slide_button_panel_on_slide_changed_ease_slide_background_changed, self, 0); #line 313 "ease-slide-button-panel.c" } _ease_iterable_tree_model_iterator_unref0 (_itr_it); } #line 102 "ease-slide-button-panel.vala" g_signal_connect_object (gtk_tree_view_get_selection (self->priv->slides), "changed", (GCallback) __lambda4__gtk_tree_selection_changed, self, 0); #line 110 "ease-slide-button-panel.vala" g_signal_connect_object (self->priv->document, "slide-added", (GCallback) __lambda47__ease_document_slide_added, self, 0); #line 116 "ease-slide-button-panel.vala" g_signal_connect_object (self->priv->document, "slide-deleted", (GCallback) __lambda48__ease_document_slide_deleted, self, 0); #line 323 "ease-slide-button-panel.c" _g_object_unref0 (s); _g_object_unref0 (viewport); return self; }
/* private function of gimp_unit_menu_callback () */ static void gimp_unit_menu_create_selection (GimpUnitMenu *menu) { GtkWidget *parent = gtk_widget_get_toplevel (GTK_WIDGET (menu)); GtkWidget *vbox; GtkWidget *scrolled_win; GtkListStore *list; GtkTreeSelection *sel; GtkTreeIter iter; GtkTreePath *path; GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; GimpUnit unit; gint num_units; if (gtk_window_get_modal (GTK_WINDOW (parent))) flags |= GTK_DIALOG_MODAL; menu->selection = gimp_dialog_new (_("Unit Selection"), "gimp-unit-selection", parent, flags, gimp_standard_help_func, "gimp-unit-dialog", GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (menu->selection), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_add_weak_pointer (G_OBJECT (menu->selection), (gpointer) &menu->selection); g_signal_connect (menu->selection, "response", G_CALLBACK (gimp_unit_menu_selection_response), menu); g_signal_connect_object (menu, "unmap", G_CALLBACK (gtk_widget_destroy), menu->selection, G_CONNECT_SWAPPED); /* the main vbox */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (menu->selection))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* the selection list */ scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_show (scrolled_win); list = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); menu->tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list)); g_object_unref (list); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (menu->tv), -1, _("Unit"), gtk_cell_renderer_text_new (), "text", UNIT_COLUMN, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (menu->tv), -1, _("Factor"), gtk_cell_renderer_text_new (), "text", FACTOR_COLUMN, NULL); /* the unit lines */ num_units = gimp_unit_get_number_of_units (); for (unit = GIMP_UNIT_END; unit < num_units; unit++) { gchar *string; gtk_list_store_append (list, &iter); string = gimp_unit_format_string (menu->format, unit); gtk_list_store_set (list, &iter, UNIT_COLUMN, string, -1); g_free (string); string = gimp_unit_format_string ("(%f)", unit); gtk_list_store_set (list, &iter, FACTOR_COLUMN, string, -1); g_free (string); gtk_list_store_set (list, &iter, DATA_COLUMN, unit, -1); } gtk_widget_set_size_request (menu->tv, -1, 150); gtk_container_add (GTK_CONTAINER (scrolled_win), menu->tv); g_signal_connect (menu->tv, "row-activated", G_CALLBACK (gimp_unit_menu_selection_row_activated_callback), menu); gtk_widget_show (menu->tv); g_signal_connect (menu->tv, "destroy", G_CALLBACK (gtk_widget_destroyed), &menu->tv); gtk_widget_show (vbox); gtk_widget_show (menu->selection); if (menu->unit >= GIMP_UNIT_END) { path = gtk_tree_path_new (); gtk_tree_path_append_index (path, menu->unit - GIMP_UNIT_END); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (menu->tv)); gtk_tree_selection_select_path (sel, path); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (menu->tv), path, NULL, FALSE, 0.0, 0.0); } }
static void gtk_source_map_init (GtkSourceMap *map) { GtkSourceMapPrivate *priv; GtkSourceCompletion *completion; GtkStyleContext *context; priv = gtk_source_map_get_instance_private (map); priv->css_provider = gtk_css_provider_new (); context = gtk_widget_get_style_context (GTK_WIDGET (map)); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (priv->css_provider), CSS_PRIORITY); priv->child_view = g_object_new (GTK_SOURCE_TYPE_VIEW, "auto-indent", FALSE, "can-focus", FALSE, "draw-spaces", 0, "editable", FALSE, "expand", FALSE, "monospace", TRUE, "show-line-numbers", FALSE, "show-line-marks", FALSE, "show-right-margin", FALSE, "visible", TRUE, NULL); context = gtk_widget_get_style_context (GTK_WIDGET (priv->child_view)); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (priv->css_provider), CSS_PRIORITY); g_signal_connect_object (priv->child_view, "button-press-event", G_CALLBACK (child_view_button_press_event), map, G_CONNECT_SWAPPED); gtk_widget_add_events (GTK_WIDGET (priv->child_view), GDK_SCROLL_MASK); g_signal_connect_object (priv->child_view, "scroll-event", G_CALLBACK (child_view_scroll_event), map, G_CONNECT_SWAPPED); g_signal_connect_object (priv->child_view, "state-flags-changed", G_CALLBACK (child_view_state_flags_changed), map, G_CONNECT_SWAPPED | G_CONNECT_AFTER); g_signal_connect_object (priv->child_view, "realize", G_CALLBACK (child_view_realize_after), map, G_CONNECT_SWAPPED | G_CONNECT_AFTER); g_signal_connect_object (priv->child_view, "button-press-event", G_CALLBACK (child_view_button_press_event), map, G_CONNECT_SWAPPED); g_signal_connect_object (priv->child_view, "button-release-event", G_CALLBACK (child_view_button_release_event), map, G_CONNECT_SWAPPED); g_signal_connect_object (priv->child_view, "motion-notify-event", G_CALLBACK (child_view_motion_notify_event), map, G_CONNECT_SWAPPED); gtk_container_add (GTK_CONTAINER (map), GTK_WIDGET (priv->child_view)); completion = gtk_source_view_get_completion (priv->child_view); gtk_source_completion_block_interactive (completion); gtk_source_map_set_font_name (map, "Monospace 1"); }
void view_actions_setup (GimpActionGroup *group) { GtkAction *action; gimp_action_group_add_actions (group, "view-action", view_actions, G_N_ELEMENTS (view_actions)); gimp_action_group_add_toggle_actions (group, "view-action", view_toggle_actions, G_N_ELEMENTS (view_toggle_actions)); gimp_action_group_add_enum_actions (group, "view-zoom-action", view_zoom_actions, G_N_ELEMENTS (view_zoom_actions), G_CALLBACK (view_zoom_cmd_callback)); gimp_action_group_add_radio_actions (group, "view-zoom-action", view_zoom_explicit_actions, G_N_ELEMENTS (view_zoom_explicit_actions), NULL, 10000, G_CALLBACK (view_zoom_explicit_cmd_callback)); gimp_action_group_add_enum_actions (group, "view-padding-color", view_padding_color_actions, G_N_ELEMENTS (view_padding_color_actions), G_CALLBACK (view_padding_color_cmd_callback)); gimp_action_group_add_enum_actions (group, NULL, view_scroll_horizontal_actions, G_N_ELEMENTS (view_scroll_horizontal_actions), G_CALLBACK (view_scroll_horizontal_cmd_callback)); gimp_action_group_add_enum_actions (group, NULL, view_scroll_vertical_actions, G_N_ELEMENTS (view_scroll_vertical_actions), G_CALLBACK (view_scroll_vertical_cmd_callback)); /* connect "activate" of view-zoom-other manually so it can be * selected even if it's the active item of the radio group */ action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), "view-zoom-other"); g_signal_connect (action, "activate", G_CALLBACK (view_zoom_other_cmd_callback), group->user_data); g_signal_connect_object (group->gimp->config, "notify::check-type", G_CALLBACK (view_actions_check_type_notify), group, 0); view_actions_check_type_notify (GIMP_DISPLAY_CONFIG (group->gimp->config), NULL, group); if (GIMP_IS_IMAGE_WINDOW (group->user_data) || GIMP_IS_GIMP (group->user_data)) { /* add window actions only if the context of the group is * the display itself or the global popup (not if the context * is a dock) * (see dock-actions.c) */ window_actions_setup (group, GIMP_HELP_VIEW_CHANGE_SCREEN); } }
static void bt_settings_page_interaction_controller_init_ui (const BtSettingsPageInteractionController * self, GtkWidget * pages) { GtkWidget *label, *widget, *scrolled_window; GtkCellRenderer *renderer; GtkTreeViewColumn *tree_col; GtkTreeSelection *tree_sel; BtIcRegistry *ic_registry; gchar *str; gtk_widget_set_name (GTK_WIDGET (self), "interaction controller settings"); // create the widget already so that we can set the initial text self->priv->message = GTK_LABEL (gtk_label_new (NULL)); g_object_set (GTK_WIDGET (self->priv->message), "hexpand", TRUE, NULL); // add setting widgets label = gtk_label_new (NULL); str = g_strdup_printf ("<big><b>%s</b></big>", _("Interaction Controller")); gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); g_object_set (label, "xalign", 0.0, NULL); gtk_grid_attach (GTK_GRID (self), label, 0, 0, 3, 1); gtk_grid_attach (GTK_GRID (self), gtk_label_new (" "), 0, 1, 1, 3); label = gtk_label_new (_("Device")); g_object_set (label, "xalign", 1.0, NULL); gtk_grid_attach (GTK_GRID (self), label, 1, 1, 1, 1); widget = gtk_combo_box_new (); self->priv->device_menu = GTK_COMBO_BOX (widget); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_fixed_size (renderer, 1, -1); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->device_menu), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->device_menu), renderer, "text", DEVICE_MENU_LABEL, NULL); // get list of devices from libbtic and listen to changes g_object_get (self->priv->app, "ic-registry", &ic_registry, NULL); g_signal_connect_object (ic_registry, "notify::devices", G_CALLBACK (on_ic_registry_devices_changed), (gpointer) self, 0); g_object_unref (ic_registry); g_object_set (widget, "hexpand", TRUE, "margin-left", LABEL_PADDING, NULL); gtk_grid_attach (GTK_GRID (self), widget, 2, 1, 1, 1); g_signal_connect (widget, "changed", G_CALLBACK (on_device_menu_changed), (gpointer) self); // add list of controllers (updated when selecting a device) scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); self->priv->controller_list = GTK_TREE_VIEW (gtk_tree_view_new ()); g_object_set (self->priv->controller_list, "enable-search", FALSE, "rules-hint", TRUE, NULL); // have this first as the last column gets the remaining space (always :/) renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (self->priv->controller_list, -1, _("In use"), renderer, "active", CONTROLLER_LIST_USED, NULL); self->priv->id_renderer = renderer = gtk_cell_renderer_text_new (); //gtk_cell_renderer_set_fixed_size (renderer, 1, -1); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); g_signal_connect (renderer, "edited", G_CALLBACK (on_control_name_edited), (gpointer) self); if ((tree_col = gtk_tree_view_column_new_with_attributes (_("Controller"), renderer, "text", CONTROLLER_LIST_LABEL, NULL)) ) { g_object_set (tree_col, "expand", TRUE, NULL); gtk_tree_view_insert_column (self->priv->controller_list, tree_col, -1); } else GST_WARNING ("can't create treeview column"); tree_sel = gtk_tree_view_get_selection (self->priv->controller_list); gtk_tree_selection_set_mode (tree_sel, GTK_SELECTION_BROWSE); g_signal_connect (tree_sel, "changed", G_CALLBACK (on_control_selected), (gpointer) self); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (self->priv->controller_list)); g_object_set (GTK_WIDGET (scrolled_window), "hexpand", TRUE, "vexpand", TRUE, "margin-left", LABEL_PADDING, NULL); gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (scrolled_window), 1, 2, 2, 1); // add a message pane #if ! defined(USE_GUDEV) && ! defined(USE_ALSA) gtk_label_set_text (self->priv->message, _("This package has been built without GUdev and Alsa support and thus " "supports no interaction controllers.")); #endif gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (self->priv->message), 0, 3, 3, 1); // listen to page changes g_signal_connect ((gpointer) pages, "notify::page", G_CALLBACK (on_page_switched), (gpointer) self); // initial refresh on_ic_registry_devices_changed (ic_registry, NULL, (gpointer) self); }
void e_task_shell_view_private_constructed (ETaskShellView *task_shell_view) { ETaskShellViewPrivate *priv = task_shell_view->priv; EShellBackend *shell_backend; EShellContent *shell_content; EShellSidebar *shell_sidebar; EShellWindow *shell_window; EShellView *shell_view; EShell *shell; gulong handler_id; shell_view = E_SHELL_VIEW (task_shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_content = e_shell_view_get_shell_content (shell_view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); shell_window = e_shell_view_get_shell_window (shell_view); shell = e_shell_window_get_shell (shell_window); e_shell_window_add_action_group (shell_window, "tasks"); e_shell_window_add_action_group (shell_window, "tasks-filter"); /* Cache these to avoid lots of awkward casting. */ priv->task_shell_backend = g_object_ref (shell_backend); priv->task_shell_content = g_object_ref (shell_content); priv->task_shell_sidebar = g_object_ref (shell_sidebar); priv->settings = g_settings_new ("org.gnome.evolution.calendar"); handler_id = g_signal_connect_object ( priv->task_shell_sidebar, "client-added", G_CALLBACK (task_shell_view_selector_client_added_cb), task_shell_view, G_CONNECT_SWAPPED); priv->client_added_handler_id = handler_id; handler_id = g_signal_connect_object ( priv->task_shell_sidebar, "client-removed", G_CALLBACK (task_shell_view_selector_client_removed_cb), task_shell_view, G_CONNECT_SWAPPED); priv->client_removed_handler_id = handler_id; /* Keep our own reference to this so we can * disconnect our signal handlers in dispose(). */ priv->client_cache = e_shell_get_client_cache (shell); g_object_ref (priv->client_cache); handler_id = g_signal_connect ( priv->client_cache, "backend-error", G_CALLBACK (task_shell_view_backend_error_cb), task_shell_view); priv->backend_error_handler_id = handler_id; /* Keep our own reference to this so we can * disconnect our signal handlers in dispose(). */ priv->task_table = e_task_shell_content_get_task_table ( E_TASK_SHELL_CONTENT (shell_content)); g_object_ref (priv->task_table); handler_id = g_signal_connect_swapped ( priv->task_table, "open-component", G_CALLBACK (e_task_shell_view_open_task), task_shell_view); priv->open_component_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->task_table, "popup-event", G_CALLBACK (task_shell_view_table_popup_event_cb), task_shell_view); priv->popup_event_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->task_table, "selection-change", G_CALLBACK (e_task_shell_view_update_sidebar), task_shell_view); priv->selection_change_1_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->task_table, "selection-change", G_CALLBACK (e_shell_view_update_actions), task_shell_view); priv->selection_change_2_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->task_table, "status-message", G_CALLBACK (e_task_shell_view_set_status_message), task_shell_view); priv->status_message_handler_id = handler_id; /* Keep our own reference to this so we can * disconnect our signal handlers in dispose(). */ priv->model = e_task_table_get_model (priv->task_table); g_object_ref (priv->model); handler_id = g_signal_connect_swapped ( priv->model, "model-changed", G_CALLBACK (e_task_shell_view_update_sidebar), task_shell_view); priv->model_changed_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->model, "model-rows-deleted", G_CALLBACK (e_task_shell_view_update_sidebar), task_shell_view); priv->model_rows_deleted_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->model, "model-rows-inserted", G_CALLBACK (e_task_shell_view_update_sidebar), task_shell_view); priv->model_rows_inserted_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->model, "row-appended", G_CALLBACK (task_shell_view_model_row_appended_cb), task_shell_view); priv->rows_appended_handler_id = handler_id; /* Keep our own reference to this so we can * disconnect our signal handlers in dispose(). */ priv->selector = e_task_shell_sidebar_get_selector ( E_TASK_SHELL_SIDEBAR (shell_sidebar)); g_object_ref (priv->selector); handler_id = g_signal_connect_swapped ( priv->selector, "popup-event", G_CALLBACK (task_shell_view_selector_popup_event_cb), task_shell_view); priv->selector_popup_event_handler_id = handler_id; handler_id = g_signal_connect_swapped ( priv->selector, "primary-selection-changed", G_CALLBACK (e_shell_view_update_actions), task_shell_view); priv->primary_selection_changed_handler_id = handler_id; e_categories_add_change_hook ( (GHookFunc) e_task_shell_view_update_search_filter, task_shell_view); /* Listen for configuration changes. */ g_settings_bind ( priv->settings, "confirm-purge", shell_view, "confirm-purge", G_SETTINGS_BIND_DEFAULT); /* Keep the ECalModel in sync with the sidebar. */ g_object_bind_property ( shell_sidebar, "default-client", priv->model, "default-client", G_BINDING_SYNC_CREATE); /* Hide Completed Tasks (enable/units/value) */ handler_id = g_signal_connect ( priv->settings, "changed::hide-completed-tasks", G_CALLBACK (task_shell_view_hide_completed_tasks_changed_cb), task_shell_view); priv->settings_hide_completed_tasks_handler_id = handler_id; handler_id = g_signal_connect ( priv->settings, "changed::hide-completed-tasks-units", G_CALLBACK (task_shell_view_hide_completed_tasks_changed_cb), task_shell_view); priv->settings_hide_completed_tasks_units_handler_id = handler_id; handler_id = g_signal_connect ( priv->settings, "changed::hide-completed-tasks-value", G_CALLBACK (task_shell_view_hide_completed_tasks_changed_cb), task_shell_view); priv->settings_hide_completed_tasks_value_handler_id = handler_id; e_task_shell_view_actions_init (task_shell_view); e_task_shell_view_update_sidebar (task_shell_view); e_task_shell_view_update_search_filter (task_shell_view); /* Call this when everything is ready, like actions in * action groups and such. */ task_shell_view_update_timeout_cb (task_shell_view); priv->update_timeout = e_named_timeout_add_full ( G_PRIORITY_LOW, 60000, task_shell_view_update_timeout_cb, task_shell_view, NULL); }
GtkWidget * gimp_foreground_select_options_gui (GimpToolOptions *tool_options) { GObject *config = G_OBJECT (tool_options); GtkWidget *vbox = gimp_selection_options_gui (tool_options); GtkWidget *hbox; GtkWidget *button; GtkWidget *frame; GtkWidget *scale; GtkWidget *combo; GtkWidget *table; gchar *title; gint row = 0; GimpForegroundSelectOptions *options = GIMP_FOREGROUND_SELECT_OPTIONS (config); frame = gimp_prop_enum_radio_frame_new (config, "draw-mode", title, 0,0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* stroke width */ scale = gimp_prop_spin_scale_new (config, "stroke-width", _("Stroke width"), 1.0, 10.0, 2); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_foreground_select_options_gui_reset_stroke_width), tool_options); gimp_help_set_help_data (button, _("Reset stroke width native size"), NULL); /* mask color */ frame = gimp_frame_new (_("Preview color:")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); combo = gimp_prop_enum_combo_box_new (config, "mask-color", GIMP_RED_CHANNEL, GIMP_GRAY_CHANNEL); gtk_container_add (GTK_CONTAINER (frame), combo); gtk_widget_show (combo); /* engine */ frame = gimp_frame_new (_("Engine:")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); combo = gimp_prop_enum_combo_box_new (config, "engine", 0, 0); gtk_container_add (GTK_CONTAINER (frame), combo); gtk_widget_show (combo); /* parameters */ table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); options->dynamic_widgets.levels = gimp_prop_scale_entry_new (config, "levels", GTK_TABLE (table), 0, row++, "Levels", 1, 1, 0, FALSE, 0, 0); options->dynamic_widgets.active_levels = gimp_prop_scale_entry_new (config, "active-levels", GTK_TABLE (table), 0, row++, "Act. Levels", 1, 1, 0, FALSE, 0, 0); options->dynamic_widgets.iterations = gimp_prop_scale_entry_new (config, "iterations", GTK_TABLE (table), 0, row++, "Iterations", 1, 1, 0, FALSE, 0, 0); g_signal_connect_object (config, "notify::engine", G_CALLBACK (gimp_foreground_select_notify_engine), NULL, 0); gimp_foreground_select_notify_engine(tool_options,NULL,NULL); return vbox; }
static GtkWidget * build_tab_label (NautilusNotebook *nb, NautilusWindowSlot *slot) { GtkWidget *hbox, *label, *close_button, *image, *spinner, *icon; GtkWidget *box; box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_widget_show (box); /* set hbox spacing and label padding (see below) so that there's an * equal amount of space around the label */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_show (hbox); gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (box), hbox, TRUE, TRUE, 0); /* setup load feedback */ spinner = gtk_spinner_new (); gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); /* setup site icon, empty by default */ icon = gtk_image_new (); gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0); /* don't show the icon */ /* setup label */ label = gtk_label_new (NULL); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE); gtk_label_set_xalign (GTK_LABEL (label), 0.5); gtk_label_set_yalign (GTK_LABEL (label), 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); /* setup close button */ close_button = gtk_button_new (); gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE); /* don't allow focus on the close button */ gtk_widget_set_focus_on_click (close_button, FALSE); gtk_widget_set_name (close_button, "nautilus-tab-close-button"); image = gtk_image_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_MENU); gtk_widget_set_tooltip_text (close_button, _("Close tab")); g_signal_connect_object (close_button, "clicked", G_CALLBACK (close_button_clicked_cb), slot, 0); gtk_container_add (GTK_CONTAINER (close_button), image); gtk_widget_show (image); gtk_box_pack_start (GTK_BOX (box), close_button, FALSE, FALSE, 0); gtk_widget_show (close_button); g_object_set_data (G_OBJECT (box), "nautilus-notebook-tab", GINT_TO_POINTER (1)); nautilus_drag_slot_proxy_init (box, NULL, slot); g_object_set_data (G_OBJECT (box), "label", label); g_object_set_data (G_OBJECT (box), "spinner", spinner); g_object_set_data (G_OBJECT (box), "icon", icon); g_object_set_data (G_OBJECT (box), "close-button", close_button); return box; }
static void display_sync_settings_dialog (RBMediaPlayerSource *source) { RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (source); GtkWidget *content; GtkWidget *widget; GtkBuilder *builder; const char *ui_file; char *name; char *title; g_object_get (source, "name", &name, NULL); title = g_strdup_printf (_("%s Sync Settings"), name); priv->sync_dialog = gtk_dialog_new_with_buttons (title, NULL, 0, _("Sync with the device"), GTK_RESPONSE_YES, _("Don't sync"), GTK_RESPONSE_CANCEL, NULL); g_free (title); priv->sync_dialog_update_id = g_signal_connect_object (priv->sync_state, "updated", G_CALLBACK (sync_dialog_state_update), source, 0); g_signal_connect_object (priv->sync_dialog, "response", G_CALLBACK (sync_confirm_dialog_cb), source, 0); /* display the sync settings, the sync state, and some helpful text indicating why * we're not syncing already */ content = gtk_dialog_get_content_area (GTK_DIALOG (priv->sync_dialog)); ui_file = rb_file ("sync-dialog.ui"); if (ui_file == NULL) { g_warning ("Couldn't find sync-state.ui"); gtk_widget_show_all (priv->sync_dialog); return; } builder = rb_builder_load (ui_file, NULL); if (builder == NULL) { g_warning ("Couldn't load sync-state.ui"); gtk_widget_show_all (priv->sync_dialog); return; } priv->sync_dialog_label = GTK_WIDGET (gtk_builder_get_object (builder, "sync-dialog-reason")); priv->sync_dialog_error_box = GTK_WIDGET (gtk_builder_get_object (builder, "sync-dialog-message")); widget = GTK_WIDGET (gtk_builder_get_object (builder, "sync-settings-ui-container")); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (widget), rb_sync_settings_ui_new (source, priv->sync_settings)); widget = GTK_WIDGET (gtk_builder_get_object (builder, "sync-state-ui-container")); gtk_box_pack_start (GTK_BOX (widget), rb_sync_state_ui_new (priv->sync_state), TRUE, TRUE, 0); widget = GTK_WIDGET (gtk_builder_get_object (builder, "sync-dialog")); gtk_box_pack_start (GTK_BOX (content), widget, TRUE, TRUE, 0); gtk_widget_show_all (priv->sync_dialog); update_sync_settings_dialog (source); g_object_unref (builder); }
void rb_media_player_source_show_properties (RBMediaPlayerSource *source) { RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (source); RBMediaPlayerSourceClass *klass = RB_MEDIA_PLAYER_SOURCE_GET_CLASS (source); GtkBuilder *builder; GtkContainer *container; const char *ui_file; char *name; char *text; if (priv->properties_dialog != NULL) { gtk_window_present (GTK_WINDOW (priv->properties_dialog)); return; } /* load dialog UI */ ui_file = rb_file ("media-player-properties.ui"); if (ui_file == NULL) { g_warning ("Couldn't find media-player-properties.ui"); return; } builder = rb_builder_load (ui_file, NULL); if (builder == NULL) { g_warning ("Couldn't load media-player-properties.ui"); return; } priv->properties_dialog = GTK_DIALOG (gtk_builder_get_object (builder, "media-player-properties")); g_object_ref (priv->properties_dialog); g_signal_connect_object (priv->properties_dialog, "response", G_CALLBACK (properties_dialog_response_cb), source, 0); g_object_get (source, "name", &name, NULL); text = g_strdup_printf (_("%s Properties"), name); gtk_window_set_title (GTK_WINDOW (priv->properties_dialog), text); g_free (text); g_free (name); /* ensure device usage information is available and up to date */ update_sync (source); /* * fill in some common details: * - volume usage (need to hook up signals etc. to update this live) */ rb_sync_state_ui_create_bar (&priv->volume_usage, rb_media_player_source_get_capacity (source), NULL); rb_sync_state_ui_update_volume_usage (&priv->volume_usage, priv->sync_state); gtk_widget_show_all (priv->volume_usage.widget); container = GTK_CONTAINER (gtk_builder_get_object (builder, "device-usage-container")); gtk_container_add (container, priv->volume_usage.widget); /* let the subclass fill in device type specific details (model names, device names, * .. battery levels?) and add more tabs to the notebook to display 'advanced' stuff. */ if (klass->show_properties) { klass->show_properties (source, GTK_WIDGET (gtk_builder_get_object (builder, "device-info-box")), GTK_WIDGET (gtk_builder_get_object (builder, "media-player-notebook"))); } /* create sync UI */ container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-settings-ui-container")); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (container), rb_sync_settings_ui_new (source, priv->sync_settings)); container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-state-ui-container")); gtk_box_pack_start (GTK_BOX (container), rb_sync_state_ui_new (priv->sync_state), TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (container)); /* create encoding settings UI */ if (priv->encoding_settings) { container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-container")); gtk_container_add (container, rb_encoding_settings_new (priv->encoding_settings, priv->encoding_target, TRUE)); gtk_widget_show_all (GTK_WIDGET (container)); } else { container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-frame")); gtk_widget_hide (GTK_WIDGET (container)); gtk_widget_set_no_show_all (GTK_WIDGET (container), TRUE); } gtk_widget_show (GTK_WIDGET (priv->properties_dialog)); g_object_unref (builder); }
static gboolean gmpc_meta_data_widgets_similar_songs_update_sim_song (GmpcMetaDataWidgetsSimilarSongs* self) { gboolean result = FALSE; g_return_val_if_fail (self != NULL, FALSE); if (self->priv->current == NULL) { GList* _tmp0_ = NULL; GtkProgressBar* _tmp1_ = NULL; _tmp0_ = meta_data_get_text_list (self->priv->copy); self->priv->current = _tmp0_; _tmp1_ = (GtkProgressBar*) gtk_progress_bar_new (); _g_object_unref0 (self->priv->pchild); self->priv->pchild = (GtkWidget*) g_object_ref_sink (_tmp1_); gtk_container_add ((GtkContainer*) self, self->priv->pchild); gtk_widget_show_all ((GtkWidget*) self); } gtk_progress_bar_pulse (GTK_PROGRESS_BAR (self->priv->pchild)); if (self->priv->current != NULL) { gchar* _tmp2_; gchar* entry; _tmp2_ = g_strdup ((const gchar*) self->priv->current->data); entry = _tmp2_; if (entry != NULL) { gchar** _tmp3_; gchar** _tmp4_ = NULL; gchar** split; gint split_length1; gint _split_size_; _tmp4_ = _tmp3_ = g_strsplit (entry, "::", 2); split = _tmp4_; split_length1 = _vala_array_length (_tmp3_); _split_size_ = _vala_array_length (_tmp3_); if (split_length1 == 2) { gchar** _tmp5_; gchar** _tmp6_ = NULL; gchar** art_split; gint art_split_length1; gint _art_split_size_; MpdData* _tmp8_ = NULL; MpdData* data; mpd_database_search_start (connection, FALSE); _tmp6_ = _tmp5_ = g_strsplit (split[0], " ", 0); art_split = _tmp6_; art_split_length1 = _vala_array_length (_tmp5_); _art_split_size_ = _vala_array_length (_tmp5_); { gchar** artist_collection; int artist_collection_length1; int artist_it; artist_collection = art_split; artist_collection_length1 = art_split_length1; for (artist_it = 0; artist_it < art_split_length1; artist_it = artist_it + 1) { gchar* _tmp7_; gchar* artist; _tmp7_ = g_strdup (artist_collection[artist_it]); artist = _tmp7_; { mpd_database_search_add_constraint (connection, MPD_TAG_ITEM_ARTIST, artist); _g_free0 (artist); } } } mpd_database_search_add_constraint (connection, MPD_TAG_ITEM_TITLE, split[1]); _tmp8_ = mpd_database_search_commit (connection); data = _tmp8_; if (data != NULL) { MpdData* _tmp9_; _tmp9_ = data; data = NULL; self->priv->item = mpd_data_concatenate (self->priv->item, _tmp9_); } _mpd_data_free0 (data); art_split = (_vala_array_free (art_split, art_split_length1, (GDestroyNotify) g_free), NULL); } split = (_vala_array_free (split, split_length1, (GDestroyNotify) g_free), NULL); } self->priv->current = self->priv->current->next; if (self->priv->current != NULL) { result = TRUE; _g_free0 (entry); return result; } _g_free0 (entry); } gtk_object_destroy ((GtkObject*) self->priv->pchild); if (self->priv->item != NULL) { GmpcMpdDataModel* _tmp10_ = NULL; GmpcMpdDataModel* model; MpdData* _tmp11_; GmpcMpdDataTreeview* _tmp12_ = NULL; GmpcMpdDataTreeview* tree; GtkWidget* _tmp13_; _tmp10_ = gmpc_mpddata_model_new (); model = _tmp10_; self->priv->item = misc_mpddata_remove_duplicate_songs (self->priv->item); _tmp11_ = self->priv->item; self->priv->item = NULL; gmpc_mpddata_model_set_mpd_data (model, _tmp11_); _tmp12_ = gmpc_mpddata_treeview_new ("similar-song", TRUE, (GtkTreeModel*) model); tree = g_object_ref_sink (_tmp12_); gmpc_mpddata_treeview_enable_click_fix (tree); g_signal_connect_object ((GtkWidget*) tree, "button-release-event", (GCallback) _gmpc_meta_data_widgets_similar_songs_tree_right_menu_gtk_widget_button_release_event, self, 0); g_signal_connect_object ((GtkTreeView*) tree, "row-activated", (GCallback) _gmpc_meta_data_widgets_similar_songs_tree_row_activated_gtk_tree_view_row_activated, self, 0); gtk_container_add ((GtkContainer*) self, (GtkWidget*) tree); _tmp13_ = _g_object_ref0 ((GtkWidget*) tree); _g_object_unref0 (self->priv->pchild); self->priv->pchild = _tmp13_; _g_object_unref0 (tree); _g_object_unref0 (model); } else { const gchar* _tmp14_ = NULL; GtkLabel* _tmp15_ = NULL; GtkLabel* label; GtkWidget* _tmp16_; _tmp14_ = _ ("Unavailable"); _tmp15_ = (GtkLabel*) gtk_label_new (_tmp14_); label = g_object_ref_sink (_tmp15_); gtk_misc_set_alignment ((GtkMisc*) label, 0.0f, 0.0f); gtk_container_add ((GtkContainer*) self, (GtkWidget*) label); _tmp16_ = _g_object_ref0 ((GtkWidget*) label); _g_object_unref0 (self->priv->pchild); self->priv->pchild = _tmp16_; _g_object_unref0 (label); } _meta_data_free0 (self->priv->copy); self->priv->copy = NULL; self->priv->idle_add = (guint) 0; gtk_widget_show_all ((GtkWidget*) self); result = FALSE; return result; }
int main (int argc, char *argv[]) { GTestDBus *bus; GError *error = NULL; GOptionContext *context; guint sig_term; guint sig_int; int i; gchar *guid = NULL; GDBusServer *direct_dbus_server = NULL; GOptionEntry entries[] = { { NULL } }; signal (SIGPIPE, SIG_IGN); /* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */ g_setenv ("GIO_USE_VFS", "local", TRUE); g_setenv ("XDG_DATA_HOME", SRCDIR "/src/bridge/mock-resource/home", TRUE); g_setenv ("XDG_DATA_DIRS", SRCDIR "/src/bridge/mock-resource/system", TRUE); setup_path (argv[0]); g_type_init (); g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR); sig_term = g_unix_signal_add (SIGTERM, on_signal_done, NULL); sig_int = g_unix_signal_add (SIGINT, on_signal_done, NULL); // System cockpit configuration file should not be loaded cockpit_config_file = NULL; context = g_option_context_new ("- test dbus json server"); g_option_context_add_main_entries (context, entries, NULL); g_option_context_set_ignore_unknown_options (context, TRUE); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("test-server: %s\n", error->message); exit (2); } /* This isolates us from affecting other processes during tests */ bus = g_test_dbus_new (G_TEST_DBUS_NONE); g_test_dbus_up (bus); bus_address = g_test_dbus_get_bus_address (bus); guid = g_dbus_generate_guid (); direct_dbus_server = g_dbus_server_new_sync ("unix:tmpdir=/tmp/dbus-tests", G_DBUS_SERVER_FLAGS_NONE, guid, NULL, NULL, &error); if (direct_dbus_server == NULL) { g_printerr ("test-server: %s\n", error->message); exit (3); } /* Skip the program name */ argc--; argv++; /* Null terminate the bridge command line */ bridge_argv = g_new0 (char *, argc + 2); for (i = 0; i < argc; i++) bridge_argv[i] = argv[i]; bridge_argv[i] = "cockpit-bridge"; loop = g_main_loop_new (NULL, FALSE); g_bus_own_name (G_BUS_TYPE_SESSION, "com.redhat.Cockpit.DBusTests.Test", G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE, on_bus_acquired, on_name_acquired, on_name_lost, loop, NULL); g_bus_own_name (G_BUS_TYPE_SESSION, "com.redhat.Cockpit.DBusTests.Second", G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE, NULL, on_second_acquired, on_name_lost, loop, NULL); g_signal_connect_object (direct_dbus_server, "new-connection", G_CALLBACK (on_new_direct_connection), NULL, 0); g_dbus_server_start (direct_dbus_server); direct_address = g_dbus_server_get_client_address (direct_dbus_server); g_main_loop_run (loop); g_source_remove (sig_term); g_source_remove (sig_int); g_clear_object (&bridge); g_clear_object (&exported); g_clear_object (&exported_b); g_clear_object (&direct_dbus_server); g_clear_object (&direct); g_clear_object (&direct_b); g_main_loop_unref (loop); g_test_dbus_down (bus); g_object_unref (bus); g_free (bridge_argv); g_free (guid); return exit_code; }
void gimp_operation_tool_set_operation (GimpOperationTool *tool, const gchar *operation, const gchar *undo_desc, const gchar *icon_name) { GimpImageMapTool *im_tool; g_return_if_fail (GIMP_IS_OPERATION_TOOL (tool)); g_return_if_fail (operation != NULL); im_tool = GIMP_IMAGE_MAP_TOOL (tool); if (tool->operation) g_free (tool->operation); if (tool->undo_desc) g_free (tool->undo_desc); if (tool->icon_name) g_free (tool->icon_name); tool->operation = g_strdup (operation); tool->undo_desc = g_strdup (undo_desc); tool->icon_name = g_strdup (icon_name); if (tool->config) g_object_unref (tool->config); tool->config = gimp_gegl_get_config_proxy (tool->operation, GIMP_TYPE_SETTINGS); if (tool->aux_input) { g_object_unref (tool->aux_input); tool->aux_input = NULL; } gimp_image_map_tool_get_operation (im_tool); if (undo_desc) GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->settings_name = "yes"; /* XXX hack */ else GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->settings_name = NULL; /* XXX hack */ if (tool->aux_input_box) { gtk_widget_destroy (tool->aux_input_box); tool->aux_input_button = NULL; tool->aux_input_box = NULL; } if (tool->options_gui) { gtk_widget_destroy (tool->options_gui); tool->options_gui = NULL; if (im_tool->active_picker) { im_tool->active_picker = NULL; gimp_color_tool_disable (GIMP_COLOR_TOOL (tool)); } } if (gegl_node_has_pad (im_tool->operation, "aux")) { GimpContext *context; GtkWidget *label; tool->aux_input = gegl_node_new_child (NULL, "operation", "gegl:buffer-source", NULL); gegl_node_connect_to (tool->aux_input, "output", im_tool->operation, "aux"); context = GIMP_CONTEXT (GIMP_TOOL_GET_OPTIONS (tool)); tool->aux_input_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); label = gtk_label_new_with_mnemonic (_("_Aux Input")); gtk_box_pack_start (GTK_BOX (tool->aux_input_box), label, FALSE, FALSE, 0); gtk_widget_show (label); tool->aux_input_button = gimp_pickable_button_new (context, GIMP_VIEW_SIZE_LARGE, 1); gtk_box_pack_start (GTK_BOX (tool->aux_input_box), tool->aux_input_button, FALSE, FALSE, 0); gtk_widget_show (tool->aux_input_button); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tool->aux_input_button); if (tool->options_box) { gtk_box_pack_start (GTK_BOX (tool->options_box), tool->aux_input_box, FALSE, FALSE, 0); gtk_widget_show (tool->aux_input_box); } g_signal_connect_object (tool->aux_input_button, "notify::pickable", G_CALLBACK (gimp_operation_tool_aux_notify), tool->aux_input, 0); } if (tool->config) { tool->options_gui = gimp_prop_gui_new (G_OBJECT (tool->config), G_TYPE_FROM_INSTANCE (tool->config), GIMP_CONTEXT (GIMP_TOOL_GET_OPTIONS (tool)), (GimpCreatePickerFunc) gimp_image_map_tool_add_color_picker, tool); if (tool->options_box) { gtk_box_pack_start (GTK_BOX (tool->options_box), tool->options_gui, FALSE, FALSE, 0); gtk_widget_show (tool->options_gui); } } if (im_tool->gui) { if (undo_desc) gimp_tool_gui_set_description (im_tool->gui, undo_desc); if (icon_name) gimp_tool_gui_set_icon_name (im_tool->gui, icon_name); } if (GIMP_TOOL (tool)->drawable) { gimp_operation_tool_sync_op (tool, GIMP_TOOL (tool)->drawable); gimp_image_map_tool_preview (im_tool); } }
static void st_icon_update (StIcon *icon) { StIconPrivate *priv = icon->priv; StThemeNode *theme_node; StTextureCache *cache; gint scale; ClutterActor *stage; StThemeContext *context; if (priv->pending_texture) { clutter_actor_destroy (priv->pending_texture); g_object_unref (priv->pending_texture); priv->pending_texture = NULL; priv->opacity_handler_id = 0; } theme_node = st_widget_peek_theme_node (ST_WIDGET (icon)); if (theme_node == NULL) return; stage = clutter_actor_get_stage (CLUTTER_ACTOR (icon)); context = st_theme_context_get_for_stage (CLUTTER_STAGE (stage)); g_object_get (context, "scale-factor", &scale, NULL); cache = st_texture_cache_get_default (); if (priv->gicon != NULL) priv->pending_texture = st_texture_cache_load_gicon (cache, theme_node, priv->gicon, priv->icon_size, scale); if (priv->pending_texture == NULL && priv->fallback_gicon != NULL) priv->pending_texture = st_texture_cache_load_gicon (cache, theme_node, priv->fallback_gicon, priv->icon_size, scale); if (priv->pending_texture) { g_object_ref_sink (priv->pending_texture); if (clutter_actor_get_opacity (priv->pending_texture) != 0 || priv->icon_texture == NULL) { /* This icon is ready for showing, or nothing else is already showing */ st_icon_finish_update (icon); } else { /* Will be shown when fully loaded */ priv->opacity_handler_id = g_signal_connect_object (priv->pending_texture, "notify::opacity", G_CALLBACK (opacity_changed_cb), icon, 0); } } else if (priv->icon_texture) { clutter_actor_destroy (priv->icon_texture); priv->icon_texture = NULL; } }
static GstStateChangeReturn gst_dtls_enc_change_state (GstElement * element, GstStateChange transition) { GstDtlsEnc *self = GST_DTLS_ENC (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: if (self->connection_id) { self->connection = gst_dtls_dec_fetch_connection (self->connection_id); if (!self->connection) { GST_WARNING_OBJECT (self, "invalid connection id: '%s', connection not found or already in use", self->connection_id); return GST_STATE_CHANGE_FAILURE; } g_signal_connect_object (self->connection, "on-encoder-key", G_CALLBACK (on_key_received), self, 0); gst_dtls_connection_set_send_callback (self->connection, g_cclosure_new (G_CALLBACK (on_send_data), self, NULL)); } else { GST_WARNING_OBJECT (self, "trying to change state to ready without connection id"); return GST_STATE_CHANGE_FAILURE; } break; case GST_STATE_CHANGE_PAUSED_TO_READY: GST_DEBUG_OBJECT (self, "stopping connection %s", self->connection_id); gst_dtls_connection_stop (self->connection); break; case GST_STATE_CHANGE_READY_TO_NULL: GST_DEBUG_OBJECT (self, "closing connection %s", self->connection_id); if (self->connection) { gst_dtls_connection_close (self->connection); gst_dtls_connection_set_send_callback (self->connection, NULL); g_object_unref (self->connection); self->connection = NULL; } break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: GST_DEBUG_OBJECT (self, "starting connection %s", self->connection_id); gst_dtls_connection_start (self->connection, self->is_client); break; default: break; } return ret; }
void plug_in_menus_setup (GimpUIManager *manager, const gchar *ui_path) { GimpPlugInManager *plug_in_manager; GTree *menu_entries; GSList *list; guint merge_id; gint i; g_return_if_fail (GIMP_IS_UI_MANAGER (manager)); g_return_if_fail (ui_path != NULL); plug_in_manager = manager->gimp->plug_in_manager; merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager)); for (i = 0; i < manager->gimp->config->plug_in_history_size; i++) { gchar *action_name; gchar *action_path; action_name = g_strdup_printf ("plug-in-recent-%02d", i + 1); action_path = g_strdup_printf ("%s/Filters/Recently Used/Plug-Ins", ui_path); gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id, action_path, action_name, action_name, GTK_UI_MANAGER_MENUITEM, FALSE); g_free (action_name); g_free (action_path); } menu_entries = g_tree_new_full ((GCompareDataFunc) strcmp, NULL, g_free, (GDestroyNotify) plug_in_menu_entry_free); for (list = plug_in_manager->plug_in_procedures; list; list = g_slist_next (list)) { GimpPlugInProcedure *plug_in_proc = list->data; if (! plug_in_proc->file) continue; g_signal_connect_object (plug_in_proc, "menu-path-added", G_CALLBACK (plug_in_menus_menu_path_added), manager, 0); if (plug_in_proc->menu_paths && ! plug_in_proc->file_proc) { GList *path; for (path = plug_in_proc->menu_paths; path; path = g_list_next (path)) { if (g_str_has_prefix (path->data, manager->name)) { PlugInMenuEntry *entry = g_slice_new0 (PlugInMenuEntry); GFile *file; const gchar *locale_domain; entry->proc = plug_in_proc; entry->menu_path = path->data; file = gimp_plug_in_procedure_get_file (plug_in_proc); locale_domain = gimp_plug_in_manager_get_locale_domain (plug_in_manager, file, NULL); if (plug_in_proc->menu_label) { gchar *menu; menu = g_strconcat (dgettext (locale_domain, path->data), "/", dgettext (locale_domain, plug_in_proc->menu_label), NULL); plug_in_menus_tree_insert (menu_entries, menu, entry); g_free (menu); } else { plug_in_menus_tree_insert (menu_entries, dgettext (locale_domain, path->data), entry); } } } } } g_object_set_data (G_OBJECT (manager), "ui-path", (gpointer) ui_path); g_tree_foreach (menu_entries, (GTraverseFunc) plug_in_menus_tree_traverse, manager); g_object_set_data (G_OBJECT (manager), "ui-path", NULL); g_tree_destroy (menu_entries); g_signal_connect_object (manager->gimp->pdb, "register-procedure", G_CALLBACK (plug_in_menus_register_procedure), manager, 0); g_signal_connect_object (manager->gimp->pdb, "unregister-procedure", G_CALLBACK (plug_in_menus_unregister_procedure), manager, 0); }
static void connect_view (GtkSourceMap *map, GtkSourceView *view) { GtkSourceMapPrivate *priv; GtkAdjustment *vadj; priv = gtk_source_map_get_instance_private (map); priv->view = view; g_object_add_weak_pointer (G_OBJECT (view), (gpointer *)&priv->view); vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (view)); priv->buffer_binding = g_object_bind_property (view, "buffer", priv->child_view, "buffer", G_BINDING_SYNC_CREATE); g_object_add_weak_pointer (G_OBJECT (priv->buffer_binding), (gpointer *)&priv->buffer_binding); priv->indent_width_binding = g_object_bind_property (view, "indent-width", priv->child_view, "indent-width", G_BINDING_SYNC_CREATE); g_object_add_weak_pointer (G_OBJECT (priv->indent_width_binding), (gpointer *)&priv->indent_width_binding); priv->tab_width_binding = g_object_bind_property (view, "tab-width", priv->child_view, "tab-width", G_BINDING_SYNC_CREATE); g_object_add_weak_pointer (G_OBJECT (priv->tab_width_binding), (gpointer *)&priv->tab_width_binding); priv->view_notify_buffer_handler = g_signal_connect_object (view, "notify::buffer", G_CALLBACK (view_notify_buffer), map, G_CONNECT_SWAPPED); view_notify_buffer (map, NULL, view); priv->view_vadj_value_changed_handler = g_signal_connect_object (vadj, "value-changed", G_CALLBACK (view_vadj_value_changed), map, G_CONNECT_SWAPPED); priv->view_vadj_notify_upper_handler = g_signal_connect_object (vadj, "notify::upper", G_CALLBACK (view_vadj_notify_upper), map, G_CONNECT_SWAPPED); if ((gtk_widget_get_events (GTK_WIDGET (priv->view)) & GDK_ENTER_NOTIFY_MASK) == 0) { gtk_widget_add_events (GTK_WIDGET (priv->view), GDK_ENTER_NOTIFY_MASK); } if ((gtk_widget_get_events (GTK_WIDGET (priv->view)) & GDK_LEAVE_NOTIFY_MASK) == 0) { gtk_widget_add_events (GTK_WIDGET (priv->view), GDK_LEAVE_NOTIFY_MASK); } gtk_source_map_rebuild_css (map); }
void gimp_dialog_factory_add_dialog (GimpDialogFactory *factory, GtkWidget *dialog) { GimpDialogFactory *dialog_factory; GimpDialogFactoryEntry *entry; GimpSessionInfo *info; GList *list; gboolean toplevel; g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory)); g_return_if_fail (GTK_IS_WIDGET (dialog)); if (g_list_find (factory->open_dialogs, dialog)) { g_warning ("%s: dialog already registered", G_STRFUNC); return; } dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry); if (! (dialog_factory && (entry || GIMP_IS_DOCK (dialog)))) { g_warning ("%s: dialog was not created by a GimpDialogFactory", G_STRFUNC); return; } if (dialog_factory != factory) { g_warning ("%s: dialog was created by a different GimpDialogFactory", G_STRFUNC); return; } toplevel = GTK_WIDGET_TOPLEVEL (dialog); if (entry) /* dialog is a toplevel (but not a GimpDock) or a GimpDockable */ { D (g_print ("%s: adding %s \"%s\"\n", G_STRFUNC, toplevel ? "toplevel" : "dockable", entry->identifier)); for (list = factory->session_infos; list; list = g_list_next (list)) { info = list->data; if ((info->toplevel_entry == entry) || (info->dockable_entry == entry)) { if (info->widget) { if (entry->singleton) { g_warning ("%s: singleton dialog \"%s\" created twice", G_STRFUNC, entry->identifier); D (g_print ("%s: corrupt session info: %p (widget %p)\n", G_STRFUNC, info, info->widget)); return; } continue; } info->widget = dialog; D (g_print ("%s: updating session info %p (widget %p) for %s \"%s\"\n", G_STRFUNC, info, info->widget, toplevel ? "toplevel" : "dockable", entry->identifier)); if (toplevel && entry->session_managed) gimp_session_info_set_geometry (info); break; } } if (! list) /* didn't find a session info */ { info = gimp_session_info_new (); info->widget = dialog; D (g_print ("%s: creating session info %p (widget %p) for %s \"%s\"\n", G_STRFUNC, info, info->widget, toplevel ? "toplevel" : "dockable", entry->identifier)); if (toplevel) { info->toplevel_entry = entry; /* if we create a new session info, we never call * gimp_session_info_set_geometry(), but still the * dialog needs GDK_HINT_USER_POS so it keeps its * position when hidden/shown within this(!) session. */ if (entry->session_managed) g_signal_connect (dialog, "configure-event", G_CALLBACK (gimp_dialog_factory_set_user_pos), NULL); } else { info->dockable_entry = entry; } factory->session_infos = g_list_append (factory->session_infos, info); } } else /* dialog is a GimpDock */ { D (g_print ("%s: adding dock\n", G_STRFUNC)); for (list = factory->session_infos; list; list = g_list_next (list)) { info = list->data; /* take the first empty slot */ if (! info->toplevel_entry && ! info->dockable_entry && ! info->widget) { info->widget = dialog; D (g_print ("%s: updating session info %p (widget %p) for dock\n", G_STRFUNC, info, info->widget)); gimp_session_info_set_geometry (info); break; } } if (! list) /* didn't find a session info */ { info = gimp_session_info_new (); info->widget = dialog; D (g_print ("%s: creating session info %p (widget %p) for dock\n", G_STRFUNC, info, info->widget)); /* if we create a new session info, we never call * gimp_session_info_set_geometry(), but still the * dialog needs GDK_HINT_USER_POS so it keeps its * position when hidden/shown within this(!) session. */ g_signal_connect (dialog, "configure-event", G_CALLBACK (gimp_dialog_factory_set_user_pos), NULL); factory->session_infos = g_list_append (factory->session_infos, info); } } factory->open_dialogs = g_list_prepend (factory->open_dialogs, dialog); g_signal_connect_object (dialog, "destroy", G_CALLBACK (gimp_dialog_factory_remove_dialog), factory, G_CONNECT_SWAPPED); if (entry && entry->session_managed && toplevel) g_signal_connect_object (dialog, "configure-event", G_CALLBACK (gimp_dialog_factory_dialog_configure), factory, 0); }
void file_actions_setup (GimpActionGroup *group) { GimpEnumActionEntry *entries; gint n_entries; gint i; gimp_action_group_add_actions (group, "file-action", file_actions, G_N_ELEMENTS (file_actions)); gimp_action_group_add_enum_actions (group, "file-action", file_save_actions, G_N_ELEMENTS (file_save_actions), G_CALLBACK (file_save_cmd_callback)); n_entries = GIMP_GUI_CONFIG (group->gimp->config)->last_opened_size; entries = g_new0 (GimpEnumActionEntry, n_entries); for (i = 0; i < n_entries; i++) { entries[i].name = g_strdup_printf ("file-open-recent-%02d", i + 1); entries[i].icon_name = "document-open"; entries[i].label = entries[i].name; entries[i].tooltip = NULL; entries[i].value = i; entries[i].value_variable = FALSE; if (i < 9) entries[i].accelerator = g_strdup_printf ("<primary>%d", i + 1); else if (i == 9) entries[i].accelerator = g_strdup ("<primary>0"); else entries[i].accelerator = NULL; } gimp_action_group_add_enum_actions (group, NULL, entries, n_entries, G_CALLBACK (file_open_recent_cmd_callback)); for (i = 0; i < n_entries; i++) { GtkAction *action; gimp_action_group_set_action_visible (group, entries[i].name, FALSE); gimp_action_group_set_action_always_show_image (group, entries[i].name, TRUE); action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), entries[i].name); g_object_set (action, "context", gimp_get_user_context (group->gimp), NULL); g_free ((gchar *) entries[i].name); if (entries[i].accelerator) g_free ((gchar *) entries[i].accelerator); } g_free (entries); g_signal_connect_object (group->gimp->documents, "add", G_CALLBACK (file_actions_last_opened_update), group, 0); g_signal_connect_object (group->gimp->documents, "remove", G_CALLBACK (file_actions_last_opened_update), group, 0); g_signal_connect_object (group->gimp->documents, "reorder", G_CALLBACK (file_actions_last_opened_reorder), group, 0); file_actions_last_opened_update (group->gimp->documents, NULL, group); /* also listen to image adding/removal so we catch the case where * the last image is closed but its display stays open. */ g_signal_connect_object (group->gimp->images, "add", G_CALLBACK (file_actions_close_all_update), group, 0); g_signal_connect_object (group->gimp->images, "remove", G_CALLBACK (file_actions_close_all_update), group, 0); file_actions_close_all_update (group->gimp->displays, NULL, group); }
static ClutterActor * create_track_info (RBShell *shell) { RBShellPlayer *player; RhythmDB *db; ClutterActor *box; ClutterActor *box2; ClutterActor *widget; ClutterActor *frame; RhythmDBEntry *entry; GValue *value; guint elapsed; g_object_get (shell, "shell-player", &player, "db", &db, NULL); entry = rb_shell_player_get_playing_entry (player); box = mx_box_layout_new (); mx_box_layout_set_orientation (MX_BOX_LAYOUT (box), MX_ORIENTATION_HORIZONTAL); mx_box_layout_set_spacing (MX_BOX_LAYOUT (box), 16); mx_stylable_set_style_class (MX_STYLABLE (box), "TrackInfoBox"); mx_stylable_set_style (MX_STYLABLE (box), style); /* XXX rtl? */ /* image container */ frame = mx_frame_new (); mx_stylable_set_style_class (MX_STYLABLE (frame), "TrackInfoImage"); mx_stylable_set_style (MX_STYLABLE (frame), style); mx_box_layout_add_actor (MX_BOX_LAYOUT (box), frame, 0); clutter_container_child_set (CLUTTER_CONTAINER (box), frame, "expand", FALSE, NULL); set_blank_image (MX_FRAME (frame)); clutter_actor_show_all (CLUTTER_ACTOR (frame)); g_signal_connect_object (player, "playing-song-changed", G_CALLBACK (cover_art_entry_changed_cb), frame, 0); request_cover_art (MX_FRAME (frame), entry); box2 = mx_box_layout_new (); mx_box_layout_set_orientation (MX_BOX_LAYOUT (box2), MX_ORIENTATION_VERTICAL); mx_box_layout_set_spacing (MX_BOX_LAYOUT (box2), 16); mx_stylable_set_style (MX_STYLABLE (box2), style); mx_box_layout_add_actor (MX_BOX_LAYOUT (box), box2, 1); clutter_container_child_set (CLUTTER_CONTAINER (box), box2, "expand", TRUE, "x-fill", TRUE, "y-fill", TRUE, "y-align", MX_ALIGN_MIDDLE, NULL); /* track info */ widget = mx_label_new (); mx_stylable_set_style_class (MX_STYLABLE (widget), "TrackInfoText"); mx_stylable_set_style (MX_STYLABLE (widget), style); mx_box_layout_add_actor (MX_BOX_LAYOUT (box2), widget, 1); clutter_container_child_set (CLUTTER_CONTAINER (box2), widget, "expand", FALSE, "x-fill", TRUE, "y-fill", TRUE, "y-align", MX_ALIGN_MIDDLE, NULL); g_signal_connect_object (player, "playing-song-changed", G_CALLBACK (playing_song_changed_cb), widget, 0); g_signal_connect_object (db, "entry-changed", G_CALLBACK (entry_changed_cb), widget, 0); g_signal_connect_object (db, "entry-extra-metadata-notify::" RHYTHMDB_PROP_STREAM_SONG_TITLE, G_CALLBACK (streaming_title_notify_cb), widget, 0); value = rhythmdb_entry_request_extra_metadata (db, entry, RHYTHMDB_PROP_STREAM_SONG_TITLE); if (value != NULL) { update_track_info (MX_LABEL (widget), db, entry, g_value_get_string (value)); g_value_unset (value); g_free (value); } else { update_track_info (MX_LABEL (widget), db, entry, NULL); } /* elapsed/duration */ widget = mx_label_new (); mx_stylable_set_style_class (MX_STYLABLE (widget), "TrackTimeText"); mx_stylable_set_style (MX_STYLABLE (widget), style); mx_box_layout_add_actor (MX_BOX_LAYOUT (box2), widget, 2); clutter_container_child_set (CLUTTER_CONTAINER (box2), widget, "expand", FALSE, "x-fill", TRUE, "y-fill", TRUE, "y-align", MX_ALIGN_MIDDLE, NULL); g_signal_connect_object (player, "elapsed-changed", G_CALLBACK (elapsed_changed_cb), widget, 0); if (rb_shell_player_get_playing_time (player, &elapsed, NULL)) { update_elapsed (widget, player, elapsed); } rhythmdb_entry_unref (entry); g_object_unref (player); g_object_unref (db); return box; }
static gboolean start_next (RBTrackTransferBatch *batch) { char *media_type = NULL; char *extension = NULL; if (batch->priv->cancelled == TRUE) { return FALSE; } if (batch->priv->entries == NULL) { /* guess we must be done.. */ g_signal_emit (batch, signals[COMPLETE], 0); return FALSE; } batch->priv->current_fraction = 0.0; batch->priv->current_encoder = rb_encoder_new (); g_signal_connect_object (batch->priv->current_encoder, "progress", G_CALLBACK (encoder_progress_cb), batch, 0); g_signal_connect_object (batch->priv->current_encoder, "overwrite", G_CALLBACK (encoder_overwrite_cb), batch, 0); g_signal_connect_object (batch->priv->current_encoder, "completed", G_CALLBACK (encoder_completed_cb), batch, 0); rb_debug ("%d entries remain in the batch", g_list_length (batch->priv->entries)); while ((batch->priv->entries != NULL) && (batch->priv->cancelled == FALSE)) { RhythmDBEntry *entry; guint64 filesize; gulong duration; double fraction; GList *n; n = batch->priv->entries; batch->priv->entries = g_list_remove_link (batch->priv->entries, n); entry = (RhythmDBEntry *)n->data; g_list_free_1 (n); rb_debug ("attempting to transfer %s", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION)); /* calculate the fraction of the transfer that this entry represents */ filesize = rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE); duration = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION); if (batch->priv->total_duration > 0) { g_assert (duration > 0); /* otherwise total_duration would be 0 */ fraction = ((double)duration) / (double) batch->priv->total_duration; } else if (batch->priv->total_size > 0) { g_assert (filesize > 0); /* otherwise total_size would be 0 */ fraction = ((double)filesize) / (double) batch->priv->total_size; } else { int count = g_list_length (batch->priv->entries) + g_list_length (batch->priv->done_entries) + 1; fraction = 1.0 / ((double)count); } g_free (media_type); g_free (extension); media_type = NULL; extension = NULL; if (rb_encoder_get_media_type (batch->priv->current_encoder, entry, batch->priv->media_types, &media_type, &extension) == FALSE) { rb_debug ("skipping entry %s, can't find a destination format", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION)); rhythmdb_entry_unref (entry); batch->priv->total_fraction += fraction; continue; } g_free (batch->priv->current_dest_uri); batch->priv->current_dest_uri = NULL; g_signal_emit (batch, signals[GET_DEST_URI], 0, entry, media_type, extension, &batch->priv->current_dest_uri); if (batch->priv->current_dest_uri == NULL) { rb_debug ("unable to build destination URI for %s, skipping", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION)); rhythmdb_entry_unref (entry); batch->priv->total_fraction += fraction; continue; } batch->priv->current = entry; batch->priv->current_entry_fraction = fraction; break; } if (batch->priv->current == NULL) { g_object_unref (batch->priv->current_encoder); batch->priv->current_encoder = NULL; } else { g_signal_emit (batch, signals[TRACK_STARTED], 0, batch->priv->current, batch->priv->current_dest_uri); rb_encoder_encode (batch->priv->current_encoder, batch->priv->current, batch->priv->current_dest_uri, media_type); } g_free (media_type); g_free (extension); return TRUE; }
void gimp_image_map_tool_get_operation (GimpImageMapTool *im_tool) { GimpImageMapToolClass *klass; GimpToolInfo *tool_info; gchar *operation_name; g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool)); klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool); tool_info = GIMP_TOOL (im_tool)->tool_info; if (im_tool->image_map) { gimp_image_map_abort (im_tool->image_map); g_object_unref (im_tool->image_map); im_tool->image_map = NULL; } if (im_tool->operation) { g_object_unref (im_tool->operation); im_tool->operation = NULL; } if (im_tool->config) { g_signal_handlers_disconnect_by_func (im_tool->config, gimp_image_map_tool_config_notify, im_tool); g_object_unref (im_tool->config); im_tool->config = NULL; } if (im_tool->default_config) { g_object_unref (im_tool->default_config); im_tool->default_config = NULL; } if (im_tool->title) { g_free (im_tool->title); im_tool->title = NULL; } if (im_tool->description) { g_free (im_tool->description); im_tool->description = NULL; } if (im_tool->undo_desc) { g_free (im_tool->undo_desc); im_tool->undo_desc = NULL; } if (im_tool->icon_name) { g_free (im_tool->icon_name); im_tool->icon_name = NULL; } if (im_tool->help_id) { g_free (im_tool->help_id); im_tool->help_id = NULL; } operation_name = klass->get_operation (im_tool, &im_tool->title, &im_tool->description, &im_tool->undo_desc, &im_tool->icon_name, &im_tool->help_id); if (! operation_name) operation_name = g_strdup ("gegl:nop"); if (! im_tool->title) im_tool->title = g_strdup (tool_info->blurb); if (! im_tool->description) im_tool->description = g_strdup (im_tool->title); if (! im_tool->undo_desc) im_tool->undo_desc = g_strdup (tool_info->blurb); if (! im_tool->icon_name) im_tool->icon_name = g_strdup (gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info))); if (! im_tool->help_id) im_tool->help_id = g_strdup (tool_info->help_id); im_tool->operation = gegl_node_new_child (NULL, "operation", operation_name, NULL); im_tool->config = G_OBJECT (gimp_gegl_config_new (operation_name, im_tool->icon_name, GIMP_TYPE_SETTINGS)); gimp_gegl_config_sync_node (GIMP_OBJECT (im_tool->config), im_tool->operation); gimp_gegl_config_connect_node (GIMP_OBJECT (im_tool->config), im_tool->operation); if (im_tool->gui) { gimp_tool_gui_set_title (im_tool->gui, im_tool->title); gimp_tool_gui_set_description (im_tool->gui, im_tool->description); gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name); gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id); } if (gegl_operation_get_key (operation_name, "position-dependent")) { if (im_tool->gui) gtk_widget_show (im_tool->region_combo); } else { if (im_tool->gui) gtk_widget_hide (im_tool->region_combo); g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool), "region", GIMP_IMAGE_MAP_REGION_SELECTION, NULL); } g_free (operation_name); g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool), "preview-split", FALSE, "preview-position", 0.5, NULL); if (im_tool->config) g_signal_connect_object (im_tool->config, "notify", G_CALLBACK (gimp_image_map_tool_config_notify), G_OBJECT (im_tool), 0); if (GIMP_TOOL (im_tool)->drawable) gimp_image_map_tool_create_map (im_tool); }
void documents_clear_cmd_callback (GtkAction *action, gpointer data) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data); GimpContext *context = gimp_container_view_get_context (editor->view); Gimp *gimp = context->gimp; GtkWidget *dialog; dialog = gimp_message_dialog_new (_("Clear Document History"), GTK_STOCK_CLEAR, GTK_WIDGET (editor), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, gimp_standard_help_func, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CLEAR, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect_object (gtk_widget_get_toplevel (GTK_WIDGET (editor)), "unmap", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Clear the Recent Documents list?")); gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Clearing the document history will " "permanently remove all images from " "the recent documents list.")); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { GtkRecentManager *manager = gtk_recent_manager_get_default (); GList *items; GList *list; items = gtk_recent_manager_get_items (manager); for (list = items; list; list = list->next) { GtkRecentInfo *info = list->data; if (gtk_recent_info_has_application (info, "GNU Image Manipulation Program")) { gtk_recent_manager_remove_item (manager, gtk_recent_info_get_uri (info), NULL); } gtk_recent_info_unref (info); } g_list_free (items); gimp_container_clear (gimp->documents); } gtk_widget_destroy (dialog); }
static gboolean gimp_image_map_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool); GimpToolInfo *tool_info = tool->tool_info; GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpDisplayShell *shell = gimp_display_get_shell (display); if (! drawable) return FALSE; if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); return FALSE; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer is not visible.")); return FALSE; } if (im_tool->active_picker) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (im_tool->active_picker), FALSE); /* set display so the dialog can be hidden on display destruction */ tool->display = display; if (im_tool->config) gimp_config_reset (GIMP_CONFIG (im_tool->config)); if (! im_tool->gui) { GimpImageMapToolClass *klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool); GtkWidget *vbox; GtkWidget *hbox; GtkWidget *toggle; gchar *operation_name; /* disabled for at least GIMP 2.8 */ im_tool->overlay = FALSE; im_tool->gui = gimp_tool_gui_new (tool_info, im_tool->title, im_tool->description, im_tool->icon_name, im_tool->help_id, gtk_widget_get_screen (GTK_WIDGET (shell)), gimp_widget_get_monitor (GTK_WIDGET (shell)), im_tool->overlay, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gimp_tool_gui_set_default_response (im_tool->gui, GTK_RESPONSE_OK); gimp_tool_gui_set_alternative_button_order (im_tool->gui, RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gimp_tool_gui_get_vbox (im_tool->gui); g_signal_connect_object (im_tool->gui, "response", G_CALLBACK (gimp_image_map_tool_response), G_OBJECT (im_tool), 0); if (im_tool->config && klass->settings_name) { GType type = G_TYPE_FROM_INSTANCE (im_tool->config); GimpContainer *settings; GFile *settings_file; GFile *default_folder; GtkWidget *settings_ui; settings = gimp_gegl_config_get_container (type); if (! gimp_list_get_sort_func (GIMP_LIST (settings))) gimp_list_set_sort_func (GIMP_LIST (settings), (GCompareFunc) gimp_settings_compare); settings_file = gimp_tool_info_get_options_file (tool_info, ".settings"); default_folder = gimp_directory_file (klass->settings_name, NULL); settings_ui = klass->get_settings_ui (im_tool, settings, settings_file, klass->import_dialog_title, klass->export_dialog_title, im_tool->help_id, default_folder, &im_tool->settings_box); g_object_unref (default_folder); g_object_unref (settings_file); gtk_box_pack_start (GTK_BOX (vbox), settings_ui, FALSE, FALSE, 0); gtk_widget_show (settings_ui); } /* The gamma hack toggle */ toggle = gtk_check_button_new_with_label ("Gamma hack (temp hack, please ignore)"); gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gamma_hack), im_tool); /* The preview and split view toggles */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options), "preview", NULL); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_widget_show (toggle); toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options), "preview-split", NULL); gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_object_bind_property (G_OBJECT (tool_info->tool_options), "preview", toggle, "sensitive", G_BINDING_SYNC_CREATE); /* The area combo */ gegl_node_get (im_tool->operation, "operation", &operation_name, NULL); im_tool->region_combo = gimp_prop_enum_combo_box_new (G_OBJECT (tool_info->tool_options), "region", 0, 0); gtk_box_pack_end (GTK_BOX (vbox), im_tool->region_combo, FALSE, FALSE, 0); if (operation_name && gegl_operation_get_key (operation_name, "position-dependent")) { gtk_widget_show (im_tool->region_combo); } g_free (operation_name); /* Fill in subclass widgets */ gimp_image_map_tool_dialog (im_tool); } else { gimp_tool_gui_set_title (im_tool->gui, im_tool->title); gimp_tool_gui_set_description (im_tool->gui, im_tool->description); gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name); gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id); } gimp_tool_gui_set_shell (im_tool->gui, shell); gimp_tool_gui_set_viewable (im_tool->gui, GIMP_VIEWABLE (drawable)); gimp_tool_gui_show (im_tool->gui); im_tool->drawable = drawable; gimp_image_map_tool_create_map (im_tool); gimp_image_map_tool_preview (im_tool); return TRUE; }
RygelGeneralPrefSection* rygel_general_pref_section_construct (GType object_type, GtkBuilder* builder, RygelUserConfig* config, GError** error) { #line 157 "rygel-general-pref-section.c" GError * _inner_error_; RygelGeneralPrefSection * self; GtkCheckButton* _tmp0_; GtkComboBoxEntry* _tmp1_; GtkSpinButton* _tmp2_; GtkCheckButton* _tmp3_; GtkCheckButton* _tmp4_; GtkCheckButton* _tmp5_; GtkCheckButton* _tmp6_; GUPnPContextManager* _tmp7_; #line 47 "rygel-general-pref-section.vala" g_return_val_if_fail (builder != NULL, NULL); #line 47 "rygel-general-pref-section.vala" g_return_val_if_fail (config != NULL, NULL); #line 172 "rygel-general-pref-section.c" _inner_error_ = NULL; #line 49 "rygel-general-pref-section.vala" self = (RygelGeneralPrefSection*) rygel_preferences_section_construct (object_type, config, "general"); #line 51 "rygel-general-pref-section.vala" self->priv->upnp_check = (_tmp0_ = _g_object_ref0 (GTK_CHECK_BUTTON (gtk_builder_get_object (builder, RYGEL_GENERAL_PREF_SECTION_UPNP_CHECKBUTTON))), _g_object_unref0 (self->priv->upnp_check), _tmp0_); #line 52 "rygel-general-pref-section.vala" g_assert (self->priv->upnp_check != NULL); #line 53 "rygel-general-pref-section.vala" self->priv->iface_entry = (_tmp1_ = _g_object_ref0 (GTK_COMBO_BOX_ENTRY (gtk_builder_get_object (builder, RYGEL_GENERAL_PREF_SECTION_IFACE_ENTRY))), _g_object_unref0 (self->priv->iface_entry), _tmp1_); #line 54 "rygel-general-pref-section.vala" g_assert (self->priv->iface_entry != NULL); #line 55 "rygel-general-pref-section.vala" self->priv->port_spin = (_tmp2_ = _g_object_ref0 (GTK_SPIN_BUTTON (gtk_builder_get_object (builder, RYGEL_GENERAL_PREF_SECTION_PORT_SPINBUTTON))), _g_object_unref0 (self->priv->port_spin), _tmp2_); #line 56 "rygel-general-pref-section.vala" g_assert (self->priv->port_spin != NULL); #line 57 "rygel-general-pref-section.vala" self->priv->trans_check = (_tmp3_ = _g_object_ref0 (GTK_CHECK_BUTTON (gtk_builder_get_object (builder, RYGEL_GENERAL_PREF_SECTION_TRANS_CHECKBUTTON))), _g_object_unref0 (self->priv->trans_check), _tmp3_); #line 58 "rygel-general-pref-section.vala" g_assert (self->priv->trans_check != NULL); #line 59 "rygel-general-pref-section.vala" self->priv->mp3_check = (_tmp4_ = _g_object_ref0 (GTK_CHECK_BUTTON (gtk_builder_get_object (builder, RYGEL_GENERAL_PREF_SECTION_MP3_CHECKBUTTON))), _g_object_unref0 (self->priv->mp3_check), _tmp4_); #line 60 "rygel-general-pref-section.vala" g_assert (self->priv->mp3_check != NULL); #line 61 "rygel-general-pref-section.vala" self->priv->mp2ts_check = (_tmp5_ = _g_object_ref0 (GTK_CHECK_BUTTON (gtk_builder_get_object (builder, RYGEL_GENERAL_PREF_SECTION_MP2TS_CHECKBUTTON))), _g_object_unref0 (self->priv->mp2ts_check), _tmp5_); #line 62 "rygel-general-pref-section.vala" g_assert (self->priv->mp2ts_check != NULL); #line 63 "rygel-general-pref-section.vala" self->priv->lpcm_check = (_tmp6_ = _g_object_ref0 (GTK_CHECK_BUTTON (gtk_builder_get_object (builder, RYGEL_GENERAL_PREF_SECTION_LPCM_CHECKBUTTON))), _g_object_unref0 (self->priv->lpcm_check), _tmp6_); #line 64 "rygel-general-pref-section.vala" g_assert (self->priv->lpcm_check != NULL); #line 66 "rygel-general-pref-section.vala" self->priv->context_manager = (_tmp7_ = gupnp_context_manager_new (NULL, (guint) 0), _g_object_unref0 (self->priv->context_manager), _tmp7_); #line 69 "rygel-general-pref-section.vala" gtk_combo_box_entry_set_text_column (self->priv->iface_entry, 0); #line 208 "rygel-general-pref-section.c" { char* _tmp8_; char* _tmp9_; #line 71 "rygel-general-pref-section.vala" _tmp8_ = rygel_configuration_get_interface ((RygelConfiguration*) config, &_inner_error_); #line 214 "rygel-general-pref-section.c" if (_inner_error_ != NULL) { goto __catch1_g_error; } #line 71 "rygel-general-pref-section.vala" gtk_combo_box_append_text ((GtkComboBox*) self->priv->iface_entry, _tmp9_ = _tmp8_); #line 220 "rygel-general-pref-section.c" _g_free0 (_tmp9_); #line 72 "rygel-general-pref-section.vala" gtk_combo_box_set_active ((GtkComboBox*) self->priv->iface_entry, 0); #line 224 "rygel-general-pref-section.c" } goto __finally1; __catch1_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally1: if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); g_object_unref (self); return NULL; } { gint _tmp10_; #line 78 "rygel-general-pref-section.vala" _tmp10_ = rygel_configuration_get_port ((RygelConfiguration*) config, &_inner_error_); #line 246 "rygel-general-pref-section.c" if (_inner_error_ != NULL) { goto __catch2_g_error; } #line 78 "rygel-general-pref-section.vala" gtk_spin_button_set_value (self->priv->port_spin, (double) _tmp10_); #line 252 "rygel-general-pref-section.c" } goto __finally2; __catch2_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally2: if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); g_object_unref (self); return NULL; } { gboolean _tmp11_; #line 81 "rygel-general-pref-section.vala" _tmp11_ = rygel_configuration_get_upnp_enabled ((RygelConfiguration*) ((RygelPreferencesSection*) self)->config, &_inner_error_); #line 274 "rygel-general-pref-section.c" if (_inner_error_ != NULL) { goto __catch3_g_error; } #line 81 "rygel-general-pref-section.vala" gtk_toggle_button_set_active ((GtkToggleButton*) self->priv->upnp_check, _tmp11_); #line 280 "rygel-general-pref-section.c" } goto __finally3; __catch3_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally3: if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); g_object_unref (self); return NULL; } { gboolean _tmp12_; #line 84 "rygel-general-pref-section.vala" _tmp12_ = rygel_configuration_get_transcoding ((RygelConfiguration*) ((RygelPreferencesSection*) self)->config, &_inner_error_); #line 302 "rygel-general-pref-section.c" if (_inner_error_ != NULL) { goto __catch4_g_error; } #line 84 "rygel-general-pref-section.vala" gtk_toggle_button_set_active ((GtkToggleButton*) self->priv->trans_check, _tmp12_); #line 308 "rygel-general-pref-section.c" } goto __finally4; __catch4_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally4: if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); g_object_unref (self); return NULL; } { gboolean _tmp13_; #line 87 "rygel-general-pref-section.vala" _tmp13_ = rygel_configuration_get_mp3_transcoder ((RygelConfiguration*) ((RygelPreferencesSection*) self)->config, &_inner_error_); #line 330 "rygel-general-pref-section.c" if (_inner_error_ != NULL) { goto __catch5_g_error; } #line 87 "rygel-general-pref-section.vala" gtk_toggle_button_set_active ((GtkToggleButton*) self->priv->mp3_check, _tmp13_); #line 336 "rygel-general-pref-section.c" } goto __finally5; __catch5_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally5: if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); g_object_unref (self); return NULL; } { gboolean _tmp14_; #line 90 "rygel-general-pref-section.vala" _tmp14_ = rygel_configuration_get_mp2ts_transcoder ((RygelConfiguration*) ((RygelPreferencesSection*) self)->config, &_inner_error_); #line 358 "rygel-general-pref-section.c" if (_inner_error_ != NULL) { goto __catch6_g_error; } #line 90 "rygel-general-pref-section.vala" gtk_toggle_button_set_active ((GtkToggleButton*) self->priv->mp2ts_check, _tmp14_); #line 364 "rygel-general-pref-section.c" } goto __finally6; __catch6_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally6: if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); g_object_unref (self); return NULL; } { gboolean _tmp15_; #line 93 "rygel-general-pref-section.vala" _tmp15_ = rygel_configuration_get_lpcm_transcoder ((RygelConfiguration*) ((RygelPreferencesSection*) self)->config, &_inner_error_); #line 386 "rygel-general-pref-section.c" if (_inner_error_ != NULL) { goto __catch7_g_error; } #line 93 "rygel-general-pref-section.vala" gtk_toggle_button_set_active ((GtkToggleButton*) self->priv->lpcm_check, _tmp15_); #line 392 "rygel-general-pref-section.c" } goto __finally7; __catch7_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { _g_error_free0 (err); } } __finally7: if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); g_object_unref (self); return NULL; } #line 96 "rygel-general-pref-section.vala" g_signal_connect_object ((GtkToggleButton*) self->priv->trans_check, "toggled", (GCallback) _rygel_general_pref_section_on_trans_check_toggled_gtk_toggle_button_toggled, self, 0); #line 98 "rygel-general-pref-section.vala" g_signal_connect_object (self->priv->context_manager, "context-available", (GCallback) _rygel_general_pref_section_on_context_available_gupnp_context_manager_context_available, self, 0); #line 100 "rygel-general-pref-section.vala" g_signal_connect_object (self->priv->context_manager, "context-unavailable", (GCallback) _rygel_general_pref_section_on_context_unavailable_gupnp_context_manager_context_unavailable, self, 0); #line 104 "rygel-general-pref-section.vala" rygel_general_pref_section_on_trans_check_toggled (self, self->priv->trans_check); #line 418 "rygel-general-pref-section.c" return self; }
void metadata_menuitem_fetch_art (MetadataMenuitem* self, const gchar* uri, const gchar* prop) { const gchar* _tmp0_; GFile* _tmp1_ = NULL; GFile* art_file; GFile* _tmp2_; gboolean _tmp3_ = FALSE; const gchar* _tmp19_; const gchar* _tmp20_; const gchar* _tmp21_; const gchar* _tmp22_; FetchFile* _tmp23_; FetchFile* _tmp24_; FetchFile* _tmp25_; FetchFile* _tmp26_; GError * _inner_error_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (uri != NULL); g_return_if_fail (prop != NULL); _tmp0_ = uri; _tmp1_ = g_file_new_for_uri (_tmp0_); art_file = _tmp1_; _tmp2_ = art_file; _tmp3_ = g_file_is_native (_tmp2_); if (_tmp3_ == TRUE) { GFile* _tmp4_; gboolean _tmp5_ = FALSE; gchar* path = NULL; _tmp4_ = art_file; _tmp5_ = g_file_query_exists (_tmp4_, NULL); if (_tmp5_ == FALSE) { const gchar* _tmp6_; _tmp6_ = prop; dbusmenu_menuitem_property_set_int ((DbusmenuMenuitem*) self, _tmp6_, PLAYER_ITEM_EMPTY); _g_object_unref0 (art_file); return; } { const gchar* _tmp7_; gchar* _tmp8_ = NULL; gchar* _tmp9_; gchar* _tmp10_ = NULL; gchar* _tmp11_; gchar* _tmp12_; const gchar* _tmp13_; gchar* _tmp14_ = NULL; gchar* _tmp15_; const gchar* _tmp16_; const gchar* _tmp17_; _tmp7_ = uri; _tmp8_ = string_strip (_tmp7_); _tmp9_ = _tmp8_; _tmp10_ = g_filename_from_uri (_tmp9_, NULL, &_inner_error_); _tmp11_ = _tmp10_; _g_free0 (_tmp9_); _tmp12_ = _tmp11_; if (_inner_error_ != NULL) { if (_inner_error_->domain == G_CONVERT_ERROR) { goto __catch5_g_convert_error; } _g_free0 (path); _g_object_unref0 (art_file); g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return; } _g_free0 (path); path = _tmp12_; _tmp13_ = uri; _tmp14_ = string_strip (_tmp13_); _tmp15_ = _tmp14_; g_debug ("metadata-menu-item.vala:116: Populating the artwork field with %s", _tmp15_); _g_free0 (_tmp15_); _tmp16_ = prop; _tmp17_ = path; dbusmenu_menuitem_property_set ((DbusmenuMenuitem*) self, _tmp16_, _tmp17_); } goto __finally5; __catch5_g_convert_error: { GError* e = NULL; const gchar* _tmp18_; e = _inner_error_; _inner_error_ = NULL; _tmp18_ = uri; g_warning ("metadata-menu-item.vala:120: Problem converting URI %s to file path", _tmp18_); _g_error_free0 (e); } __finally5: if (_inner_error_ != NULL) { _g_free0 (path); _g_object_unref0 (art_file); g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return; } _g_free0 (path); _g_object_unref0 (art_file); return; } _tmp19_ = metadata_menuitem_album_art_cache_dir; g_debug ("metadata-menu-item.vala:126: fetch_art -remotely %s", _tmp19_); _tmp20_ = metadata_menuitem_album_art_cache_dir; if (_tmp20_ == NULL) { _g_object_unref0 (art_file); return; } _tmp21_ = uri; _tmp22_ = prop; _tmp23_ = fetch_file_new (_tmp21_, _tmp22_); _g_object_unref0 (metadata_menuitem_fetcher); metadata_menuitem_fetcher = _tmp23_; _tmp24_ = metadata_menuitem_fetcher; g_signal_connect_object (_tmp24_, "failed", (GCallback) ___lambda2__fetch_file_failed, self, 0); _tmp25_ = metadata_menuitem_fetcher; g_signal_connect_object (_tmp25_, "completed", (GCallback) _metadata_menuitem_on_fetcher_completed_fetch_file_completed, self, 0); _tmp26_ = metadata_menuitem_fetcher; fetch_file_fetch_data (_tmp26_, NULL, NULL); _g_object_unref0 (art_file); }