static void photos_main_window_constructed (GObject *object) { PhotosMainWindow *self = PHOTOS_MAIN_WINDOW (object); PhotosMainWindowPrivate *priv = self->priv; GApplication *app; G_OBJECT_CLASS (photos_main_window_parent_class)->constructed (object); /* HACK: Since GtkWindow:application is a non-construct property it * will be set after constructed has finished. We explicitly add * the window to the application here before creating the rest of * the widget hierarchy. This ensures that we can use * photos_application_get_scale_factor while constructing the * widgets. */ app = g_application_get_default (); gtk_application_add_window (GTK_APPLICATION (app), GTK_WINDOW (self)); priv->embed = photos_embed_new (); gtk_container_add (GTK_CONTAINER (self), priv->embed); }
static void remmina_plugin_spice_file_transfer_finished_cb(SpiceFileTransferTask *task, GError *error, RemminaProtocolWidget *gp) { TRACE_CALL(__func__); gchar *filename, *notification_message; GNotification *notification; RemminaPluginSpiceData *gpdata = GET_PLUGIN_DATA(gp); /* * Send a desktop notification to inform about the outcome of * the file transfer. */ filename = spice_file_transfer_task_get_filename(task); if (error) { notification = g_notification_new(_("Transfer error")); notification_message = g_strdup_printf(_("%s: %s"), filename, error->message); }else { notification = g_notification_new(_("Transfer completed")); notification_message = g_strdup_printf(_("File %s transferred successfully"), filename); } g_notification_set_body(notification, notification_message); g_application_send_notification(g_application_get_default(), "remmina-plugin-spice-file-transfer-finished", notification); g_hash_table_remove(gpdata->file_transfers, task); if (!g_hash_table_size(gpdata->file_transfers)) { gtk_widget_hide(gpdata->file_transfer_dialog); } g_free(filename); g_free(notification_message); g_object_unref(notification); }
/* react to user clicks */ static gint on_clicked (G_GNUC_UNUSED GtkWidget *tree, GdkEventButton *event, gpointer data) { CallHistoryViewGtk *self = CALL_HISTORY_VIEW_GTK (data); // take into account only clicks and Enter keys if (event->type != GDK_BUTTON_PRESS && event->type != GDK_2BUTTON_PRESS && event->type != GDK_KEY_PRESS) return FALSE; if (event->type == GDK_KEY_PRESS && ((GdkEventKey*)event)->keyval != GDK_KEY_Return && ((GdkEventKey*)event)->keyval != GDK_KEY_KP_Enter) return FALSE; if (event->type == GDK_BUTTON_PRESS && event->button == 3 && self->priv->contact_menu) gtk_menu_popup (GTK_MENU (self->priv->contact_menu->get_menu (boost::assign::list_of (self->priv->menu))), NULL, NULL, NULL, NULL, event->button, event->time); if ((event->type == GDK_2BUTTON_PRESS && event->button == 1) || (event->type == GDK_KEY_PRESS)) g_action_group_activate_action (G_ACTION_GROUP (g_application_get_default ()), "call", NULL); return TRUE; }
static void on_drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time, gpointer user_data) { gint length = gtk_selection_data_get_length (data) ; if (length >= 0) { guchar *text = gtk_selection_data_get_text(data); if (text) { BijiManager *manager; BijiNoteObj *ret; BjbMainView *self = BJB_MAIN_VIEW (user_data); BjbSettings *settings; /* FIXME Text is guchar utf 8, conversion to perform */ manager = bjb_window_base_get_manager (self->priv->window); settings = bjb_app_get_settings (g_application_get_default ()); ret = biji_manager_note_new (manager, (gchar*) text, bjb_settings_get_default_location (settings)); switch_to_note_view (self, ret); // maybe AFTER drag finish? g_free (text); } } /* Return false to ensure text is not removed from source * We just want to create a note. */ gtk_drag_finish (context, FALSE, FALSE, time); }
static gboolean ide_terminal_open_link (IdeTerminal *self) { IdeTerminalPrivate *priv = ide_terminal_get_instance_private (self); GtkApplication *app; GtkWindow *focused_window; g_assert (IDE_IS_TERMINAL (self)); g_assert (priv->url != NULL); if (dzl_str_empty0 (priv->url)) return FALSE; if (NULL != (app = GTK_APPLICATION (g_application_get_default ())) && NULL != (focused_window = gtk_application_get_active_window (app))) return gtk_show_uri_on_window (focused_window, priv->url, gtk_get_current_event_time (), NULL); return FALSE; }
static void garu_headerbar_prev_button_clicked (GtkButton *button, GaruHeaderbar *self) { GaruApplication *app; GaruPlayer *player; GaruPlaylist *playlist; gchar *file; app = GARU_APPLICATION (g_application_get_default ()); player = garu_application_get_player (app); playlist = garu_application_get_playlist (app); file = garu_playlist_get_track (playlist, GARU_PLAYLIST_GET_PREV); if (file == NULL) return; garu_player_set_track (player, g_filename_to_uri (file, NULL, NULL)); garu_player_play (player); g_free (file); }
static void photos_selection_toolbar_properties_clicked (GtkButton *button, gpointer user_data) { PhotosSelectionToolbar *self = PHOTOS_SELECTION_TOOLBAR (user_data); PhotosSelectionToolbarPrivate *priv = self->priv; GList *selection; GList *windows; GApplication *app; GtkWidget *dialog; const gchar *urn; app = g_application_get_default (); windows = gtk_application_get_windows (GTK_APPLICATION (app)); selection = photos_selection_controller_get_selection (priv->sel_cntrlr); urn = (gchar *) selection->data; dialog = photos_properties_dialog_new (GTK_WINDOW (windows->data), urn); gtk_widget_show_all (dialog); g_signal_connect (dialog, "response", G_CALLBACK (photos_selection_toolbar_properties_response), self); }
static GSList * get_facesdirs (void) { GSList *facesdirs = NULL; const gchar * const * data_dirs; int i; const char *facesdir_env; GisDriver *driver; facesdir_env = g_getenv ("GIS_ACCOUNT_PAGE_FACESDIR"); if (facesdir_env != NULL && g_strcmp0 (facesdir_env, "") != 0) { facesdirs = g_slist_prepend (facesdirs, g_strdup (facesdir_env)); } /* This code will look for options under the "Account" group, and * supports the following keys: * - Faces: directory to scan for avatar faces. * * This is how this file would look on a vendor image: * * [Account] * Faces=/path/to/faces/dir */ driver = GIS_DRIVER (g_application_get_default ()); char *path = gis_driver_conf_get_string (driver, CONFIG_ACCOUNT_GROUP, CONFIG_ACCOUNT_FACESDIR_KEY); if (path) facesdirs = g_slist_prepend (facesdirs, path); data_dirs = g_get_system_data_dirs (); for (i = 0; data_dirs[i] != NULL; i++) { char *path = g_build_filename (data_dirs[i], "pixmaps", "faces", NULL); facesdirs = g_slist_prepend (facesdirs, path); } return g_slist_reverse (facesdirs); }
void ide_run_manager_add_handler (IdeRunManager *self, const gchar *id, const gchar *title, const gchar *icon_name, const gchar *accel, IdeRunHandler run_handler, gpointer user_data, GDestroyNotify user_data_destroy) { IdeRunHandlerInfo *info; g_autofree gchar *action_name = NULL; const gchar *accels[] = { accel, NULL }; GApplication *app; g_return_if_fail (IDE_IS_RUN_MANAGER (self)); g_return_if_fail (id != NULL); g_return_if_fail (title != NULL); info = g_slice_new (IdeRunHandlerInfo); info->id = g_strdup (id); info->title = g_strdup (title); info->icon_name = g_strdup (icon_name); info->accel = g_strdup (accel); info->handler = run_handler; info->handler_data = user_data; info->handler_data_destroy = user_data_destroy; app = g_application_get_default (); action_name = g_strdup_printf ("run-manager.run-with-handler('%s')", id); if (accel != NULL && app != NULL) gtk_application_set_accels_for_action (GTK_APPLICATION (app), action_name, accels); self->handlers = g_list_append (self->handlers, info); if (self->handler == NULL) self->handler = info; }
static void photos_tool_filter_button_constructed (GObject *object) { PhotosToolFilterButton *self = PHOTOS_TOOL_FILTER_BUTTON (object); GApplication *app; g_autoptr (GdkPixbuf) preview_icon = NULL; GtkWidget *image; PhotosWidgetShader *shader; cairo_surface_t *preview_icon_surface = NULL; /* TODO: use g_autoptr */ gint scale; G_OBJECT_CLASS (photos_tool_filter_button_parent_class)->constructed (object); app = g_application_get_default (); scale = photos_application_get_scale_factor (PHOTOS_APPLICATION (app)); preview_icon = photos_utils_create_placeholder_icon_for_scale ("content-loading-symbolic", 96, scale); if (preview_icon != NULL) preview_icon_surface = gdk_cairo_surface_create_from_pixbuf (preview_icon, scale, NULL); image = gtk_image_new_from_surface (preview_icon_surface); gtk_container_add (GTK_CONTAINER (self->overlay), image); shader = photos_widget_shader_new (image); gtk_widget_show (image); self->button = gtk_radio_button_new_with_label_from_widget (self->group, self->label); gtk_button_set_always_show_image (GTK_BUTTON (self->button), TRUE); gtk_button_set_image (GTK_BUTTON (self->button), self->overlay); gtk_button_set_image_position (GTK_BUTTON (self->button), GTK_POS_TOP); gtk_button_set_relief (GTK_BUTTON (self->button), GTK_RELIEF_NONE); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (self->button), FALSE); gtk_container_add (GTK_CONTAINER (self), self->button); g_object_bind_property (self->button, "active", shader, "active", G_BINDING_SYNC_CREATE); g_signal_connect_swapped (self->button, "toggled", G_CALLBACK (photos_tool_filter_button_toggled), self); photos_tool_filter_button_toggled (self); g_clear_pointer (&preview_icon_surface, (GDestroyNotify) cairo_surface_destroy); self->group = NULL; /* We will not need it any more */ }
static void photos_item_manager_init (PhotosItemManager *self) { PhotosItemManagerPrivate *priv = self->priv; GApplication *app; PhotosSearchContextState *state; self->priv = photos_item_manager_get_instance_private (self); priv = self->priv; app = g_application_get_default (); state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app)); priv->collection_path = g_queue_new (); priv->col_mngr = g_object_ref (state->col_mngr); priv->monitor = photos_tracker_change_monitor_dup_singleton (NULL, NULL); if (G_LIKELY (priv->monitor != NULL)) g_signal_connect_swapped (priv->monitor, "changes-pending", G_CALLBACK (photos_item_manager_changes_pending), self); }
static void rb_media_player_source_constructed (GObject *object) { RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (object); RBShell *shell; GApplication *app; GActionEntry actions[] = { { "media-player-sync", sync_action_cb }, { "media-player-properties", properties_action_cb } }; RB_CHAIN_GOBJECT_METHOD (rb_media_player_source_parent_class, constructed, object); app = g_application_get_default (); g_object_get (object, "shell", &shell, NULL); _rb_add_display_page_actions (G_ACTION_MAP (app), G_OBJECT (shell), actions, G_N_ELEMENTS (actions)); g_object_unref (shell); priv->sync_action = g_action_map_lookup_action (G_ACTION_MAP (app), "media-player-sync"); priv->properties_action = g_action_map_lookup_action (G_ACTION_MAP (app), "media-player-properties"); g_signal_connect (object, "notify::load-status", G_CALLBACK (load_status_changed_cb), NULL); update_actions (RB_MEDIA_PLAYER_SOURCE (object)); }
static void photos_tracker_controller_init (PhotosTrackerController *self) { PhotosTrackerControllerPrivate *priv; GApplication *app; PhotosSearchContextState *state; self->priv = photos_tracker_controller_get_instance_private (self); priv = self->priv; app = g_application_get_default (); state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app)); priv->cancellable = g_cancellable_new (); priv->item_mngr = state->item_mngr; g_object_add_weak_pointer (G_OBJECT (priv->item_mngr), (gpointer *) &priv->item_mngr); priv->src_mngr = g_object_ref (state->src_mngr); g_signal_connect_swapped (priv->src_mngr, "object-added", G_CALLBACK (photos_tracker_controller_source_object_added_removed), self); g_signal_connect_swapped (priv->src_mngr, "object-removed", G_CALLBACK (photos_tracker_controller_source_object_added_removed), self); priv->mode_cntrlr = state->mode_cntrlr; g_object_add_weak_pointer (G_OBJECT (priv->mode_cntrlr), (gpointer *) &priv->mode_cntrlr); g_signal_connect_swapped (priv->mode_cntrlr, "window-mode-changed", G_CALLBACK (photos_tracker_controller_window_mode_changed), self); priv->queue = photos_tracker_queue_dup_singleton (NULL, &priv->queue_error); }
static void disable_plugin (const gchar *name) { GMenuModel *plugin_menu; g_print ("Disabling '%s' plugin\n", name); plugin_menu = find_plugin_menu (); if (plugin_menu) { gint i; for (i = 0; i < g_menu_model_get_n_items (plugin_menu); i++) { gchar *id; if (g_menu_model_get_item_attribute (plugin_menu, i, "id", "s", &id)) { if (g_strcmp0 (id, name) == 0) { g_menu_remove (G_MENU (plugin_menu), i); g_print ("Menus of '%s' plugin removed\n", name); } g_free (id); } } } else g_warning ("Plugin menu not found"); g_action_map_remove_action (G_ACTION_MAP (g_application_get_default ()), name); g_print ("Actions of '%s' plugin removed\n", name); if (g_strcmp0 (name, "red") == 0) is_red_plugin_enabled = FALSE; else is_black_plugin_enabled = FALSE; }
static void photos_zoom_controls_init (PhotosZoomControls *self) { GApplication *app; app = g_application_get_default (); gtk_widget_init_template (GTK_WIDGET (self)); gtk_widget_set_has_window (GTK_WIDGET (self), TRUE); self->zoom_best_fit_action = g_action_map_lookup_action (G_ACTION_MAP (app), "zoom-best-fit"); g_signal_connect_swapped (self->zoom_best_fit_action, "notify::enabled", G_CALLBACK (photos_zoom_controls_notify_enabled), self); self->zoom_out_action = g_action_map_lookup_action (G_ACTION_MAP (app), "zoom-out"); g_signal_connect_swapped (self->zoom_out_action, "notify::enabled", G_CALLBACK (photos_zoom_controls_notify_enabled), self); photos_zoom_controls_update_buttons (self); }
void gd_show_about_dialog (GtkWindow *parent) { GApplication *app; const char *artists[] = { "Jakub Steiner <*****@*****.**>", NULL }; const char *authors[] = { "Cosimo Cecchi <*****@*****.**>", "Florian Müllner <*****@*****.**>", "William Jon McCann <*****@*****.**>", "Bastien Nocera <*****@*****.**>", NULL }; const char *app_id; app = g_application_get_default (); app_id = g_application_get_application_id (app); gtk_show_about_dialog (parent, "artists", artists, "authors", authors, "translator-credits", _("translator-credits"), "comments", _("A document manager application"), "logo-icon-name", app_id, "website", "https://wiki.gnome.org/Apps/Documents", "copyright", "Copyright © 2011-2014 Red Hat, Inc.", "license-type", GTK_LICENSE_GPL_2_0, "version", PACKAGE_VERSION, "wrap-license", TRUE, NULL); }
void nautilus_previewer_call_show_file (const gchar *uri, guint xid, gboolean close_if_already_visible) { GDBusConnection *connection = g_application_get_dbus_connection (g_application_get_default ()); GVariant *variant; variant = g_variant_new ("(sib)", uri, xid, close_if_already_visible); g_dbus_connection_call (connection, PREVIEWER_DBUS_NAME, PREVIEWER_DBUS_PATH, PREVIEWER_DBUS_IFACE, "ShowFile", variant, NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, previewer_show_file_ready_cb, NULL); }
static gboolean photos_search_provider_get_initial_result_set (PhotosSearchProvider *self, GDBusMethodInvocation *invocation, const gchar *const *terms) { GApplication *app; PhotosFetchIdsJob *job; app = g_application_get_default (); g_application_hold (app); g_cancellable_cancel (self->cancellable); g_cancellable_reset (self->cancellable); job = photos_fetch_ids_job_new (terms); photos_fetch_ids_job_run (job, self->state, self->cancellable, photos_search_provider_fetch_ids_executed, g_object_ref (invocation)); g_object_unref (job); return TRUE; }
static void rb_playlist_source_constructed (GObject *object) { GObject *shell_player; RBPlaylistSource *source; RBShell *shell; RhythmDB *db; RhythmDBQueryModel *query_model; GtkBuilder *builder; GSettings *settings; RB_CHAIN_GOBJECT_METHOD (rb_playlist_source_parent_class, constructed, object); source = RB_PLAYLIST_SOURCE (object); g_object_get (source, "shell", &shell, NULL); g_object_get (shell, "db", &db, "shell-player", &shell_player, NULL); rb_playlist_source_set_db (source, db); g_object_unref (db); g_object_unref (shell); /* store playlist settings using the memory backend * this means the settings path doesn't have to be consistent, * it just has to be unique, so the address of the source object works. * for local playlists, we write the settings into the playlist file on disk * to make them persistent. */ g_object_get (source, "settings", &settings, NULL); if (settings == NULL) { char *path; path = g_strdup_printf ("/org/gnome/rhythmbox/playlist/%p/", source); settings = g_settings_new_with_backend_and_path ("org.gnome.rhythmbox.source", playlist_settings_backend, path); g_free (path); g_object_set (source, "settings", settings, NULL); } g_signal_connect (settings, "changed", G_CALLBACK (playlist_settings_changed_cb), source); g_object_unref (settings); builder = rb_builder_load ("playlist-popup.ui", NULL); source->priv->popup = G_MENU (gtk_builder_get_object (builder, "playlist-popup")); rb_application_link_shared_menus (RB_APPLICATION (g_application_get_default ()), source->priv->popup); g_object_ref (source->priv->popup); g_object_unref (builder); source->priv->entries = g_hash_table_new_full (rb_refstring_hash, rb_refstring_equal, (GDestroyNotify)rb_refstring_unref, NULL); source->priv->songs = rb_entry_view_new (source->priv->db, shell_player, TRUE, TRUE); g_object_unref (shell_player); g_signal_connect_object (source->priv->songs, "notify::sort-order", G_CALLBACK (rb_playlist_source_songs_sort_order_changed_cb), source, 0); query_model = rhythmdb_query_model_new_empty (source->priv->db); rb_playlist_source_set_query_model (source, query_model); g_object_unref (query_model); { const char *title = ""; const char *strings[3] = {0}; GtkTreeViewColumn *column = gtk_tree_view_column_new (); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); g_object_set(renderer, "style", PANGO_STYLE_OBLIQUE, "weight", PANGO_WEIGHT_LIGHT, "xalign", 1.0, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); strings[0] = title; strings[1] = "9999"; rb_entry_view_set_fixed_column_width (source->priv->songs, column, renderer, strings); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) rb_playlist_source_track_cell_data_func, source, NULL); rb_entry_view_insert_column_custom (source->priv->songs, column, title, "PlaylistTrack", NULL, 0, NULL, 0); } rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_GENRE, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_ARTIST, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_COMPOSER, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_ALBUM, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_YEAR, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_DURATION, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_QUALITY, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_RATING, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_COMMENT, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_LOCATION, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_LAST_PLAYED, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_FIRST_SEEN, FALSE); rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_BPM, FALSE); rb_entry_view_set_columns_clickable (source->priv->songs, FALSE); rb_playlist_source_setup_entry_view (source, source->priv->songs); gtk_container_add (GTK_CONTAINER (source), GTK_WIDGET (source->priv->songs)); gtk_widget_show_all (GTK_WIDGET (source)); }
static void photos_properties_dialog_constructed (GObject *object) { PhotosPropertiesDialog *self = PHOTOS_PROPERTIES_DIALOG (object); GApplication *app; g_autoptr (GDateTime) date_modified = NULL; GtkStyleContext *context; GtkWidget *author_w = NULL; GtkWidget *content_area; GtkWidget *date_created_w = NULL; GtkWidget *date_modified_data; GtkWidget *date_modified_w; GtkWidget *dimensions_w = NULL; GtkWidget *exposure_time_w = NULL; GtkWidget *flash_w = NULL; GtkWidget *fnumber_w = NULL; GtkWidget *focal_length_w = NULL; GtkWidget *iso_speed_w = NULL; GtkWidget *item_type; GtkWidget *item_type_data; GtkWidget *modified_w = NULL; GtkWidget *source; GtkWidget *source_data; GtkWidget *title; GQuark equipment; GQuark flash; PhotosBaseItem *item; PhotosSearchContextState *state; const gchar *author; const gchar *location; const gchar *name; const gchar *type_description; g_autofree gchar *date_created_str = NULL; g_autofree gchar *date_modified_str = NULL; gdouble exposure_time; gdouble fnumber; gdouble focal_length; gdouble iso_speed; gint64 ctime; gint64 mtime; glong height; glong width; G_OBJECT_CLASS (photos_properties_dialog_parent_class)->constructed (object); app = g_application_get_default (); state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app)); self->item_mngr = g_object_ref (state->item_mngr); { g_autoptr (GError) error = NULL; self->queue = photos_tracker_queue_dup_singleton (NULL, &error); if (G_UNLIKELY (error != NULL)) g_warning ("Unable to create PhotosTrackerQueue: %s", error->message); } item = PHOTOS_BASE_ITEM (photos_base_manager_get_object_by_id (self->item_mngr, self->urn)); mtime = photos_base_item_get_mtime (item); date_modified = g_date_time_new_from_unix_local (mtime); date_modified_str = g_date_time_format (date_modified, "%c"); ctime = photos_base_item_get_date_created (item); if (ctime >= 0) { g_autoptr (GDateTime) date_created = NULL; date_created = g_date_time_new_from_unix_local (ctime); date_created_str = g_date_time_format (date_created, "%c"); } self->grid = gtk_grid_new (); gtk_widget_set_halign (self->grid, GTK_ALIGN_CENTER); gtk_widget_set_margin_start (self->grid, 24); gtk_widget_set_margin_end (self->grid, 24); gtk_widget_set_margin_bottom (self->grid, 12); gtk_widget_set_margin_top (self->grid, 12); gtk_orientable_set_orientation (GTK_ORIENTABLE (self->grid), GTK_ORIENTATION_VERTICAL); gtk_grid_set_column_homogeneous (GTK_GRID (self->grid), TRUE); gtk_grid_set_column_spacing (GTK_GRID (self->grid), 24); gtk_grid_set_row_homogeneous (GTK_GRID (self->grid), TRUE); gtk_grid_set_row_spacing (GTK_GRID (self->grid), 6); content_area = gtk_dialog_get_content_area (GTK_DIALOG (self)); gtk_box_pack_start (GTK_BOX (content_area), self->grid, TRUE, TRUE, 2); /* Translators: this is the label next to the photo title in the * properties dialog */ title = gtk_label_new (C_("Document Title", "Title")); gtk_widget_set_halign (title, GTK_ALIGN_END); context = gtk_widget_get_style_context (title); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), title); author = photos_base_item_get_author (item); if (author != NULL && author[0] != '\0') { /* Translators: this is the label next to the photo author in * the properties dialog */ author_w = gtk_label_new (C_("Document Author", "Author")); gtk_widget_set_halign (author_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (author_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), author_w); } source = gtk_label_new (_("Source")); gtk_widget_set_halign (source, GTK_ALIGN_END); context = gtk_widget_get_style_context (source); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), source); date_modified_w = gtk_label_new (_("Date Modified")); gtk_widget_set_halign (date_modified_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (date_modified_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), date_modified_w); if (date_created_str != NULL) { date_created_w = gtk_label_new (_("Date Created")); gtk_widget_set_halign (date_created_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (date_created_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), date_created_w); } /* Translators: this is the label next to the photo type in the * properties dialog */ item_type = gtk_label_new (C_("Document Type", "Type")); gtk_widget_set_halign (item_type, GTK_ALIGN_END); context = gtk_widget_get_style_context (item_type); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), item_type); height = (glong) photos_base_item_get_height (item); width = (glong) photos_base_item_get_width (item); if (height > 0 && width > 0) { dimensions_w = gtk_label_new (_("Dimensions")); gtk_widget_set_halign (dimensions_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (dimensions_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), dimensions_w); } location = photos_base_item_get_location (item); if (location != NULL && location[0] != '\0' && G_LIKELY (self->queue != NULL)) { g_autoptr (PhotosQuery) query = NULL; self->location_w = gtk_label_new (_("Location")); gtk_widget_set_halign (self->location_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (self->location_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), self->location_w); query = photos_query_builder_location_query (state, location); photos_tracker_queue_select (self->queue, query, NULL, photos_properties_dialog_location_query_executed, g_object_ref (self), g_object_unref); } equipment = photos_base_item_get_equipment (item); if (equipment != 0) { self->camera_w = gtk_label_new (_("Camera")); gtk_widget_set_halign (self->camera_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (self->camera_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), self->camera_w); } exposure_time = photos_base_item_get_exposure_time (item); if (exposure_time > 0.0) { exposure_time_w = gtk_label_new (_("Exposure")); gtk_widget_set_halign (exposure_time_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (exposure_time_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), exposure_time_w); } fnumber = photos_base_item_get_fnumber (item); if (fnumber > 0.0) { fnumber_w = gtk_label_new (_("Aperture")); gtk_widget_set_halign (fnumber_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (fnumber_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), fnumber_w); } focal_length = photos_base_item_get_focal_length (item); if (focal_length > 0.0) { focal_length_w = gtk_label_new (_("Focal Length")); gtk_widget_set_halign (focal_length_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (focal_length_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), focal_length_w); } iso_speed = photos_base_item_get_iso_speed (item); if (iso_speed > 0.0) { iso_speed_w = gtk_label_new (_("ISO Speed")); gtk_widget_set_halign (iso_speed_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (iso_speed_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), iso_speed_w); } flash = photos_base_item_get_flash (item); if (flash != 0) { flash_w = gtk_label_new (_("Flash")); gtk_widget_set_halign (flash_w, GTK_ALIGN_END); context = gtk_widget_get_style_context (flash_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), flash_w); } if (!photos_base_item_is_collection (item)) { modified_w = gtk_label_new (_("Modifications")); gtk_widget_set_halign (modified_w, GTK_ALIGN_END); gtk_widget_set_valign (modified_w, GTK_ALIGN_BASELINE); gtk_widget_set_vexpand (modified_w, TRUE); context = gtk_widget_get_style_context (modified_w); gtk_style_context_add_class (context, "dim-label"); gtk_container_add (GTK_CONTAINER (self->grid), modified_w); } name = photos_base_item_get_name (item); if (PHOTOS_IS_LOCAL_ITEM (item)) { self->title_entry = gtk_entry_new (); gtk_widget_set_halign (self->title_entry, GTK_ALIGN_START); gtk_widget_set_hexpand (self->title_entry, TRUE); gtk_entry_set_activates_default (GTK_ENTRY (self->title_entry), TRUE); gtk_entry_set_text (GTK_ENTRY (self->title_entry), name); gtk_entry_set_width_chars (GTK_ENTRY (self->title_entry), 40); gtk_editable_set_editable (GTK_EDITABLE (self->title_entry), TRUE); g_signal_connect (self->title_entry, "changed", G_CALLBACK (photos_properties_dialog_title_entry_changed), self); } else { self->title_entry = gtk_label_new (name); gtk_widget_set_halign (self->title_entry, GTK_ALIGN_START); gtk_label_set_ellipsize (GTK_LABEL (self->title_entry), PANGO_ELLIPSIZE_END); gtk_label_set_max_width_chars (GTK_LABEL (self->title_entry), 40); } gtk_grid_attach_next_to (GTK_GRID (self->grid), self->title_entry, title, GTK_POS_RIGHT, 2, 1); if (author_w != NULL) { GtkWidget *author_data; author_data = gtk_label_new (author); gtk_widget_set_halign (author_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), author_data, author_w, GTK_POS_RIGHT, 2, 1); } source_data = photos_base_item_get_source_widget (item); gtk_grid_attach_next_to (GTK_GRID (self->grid), source_data, source, GTK_POS_RIGHT, 2, 1); date_modified_data = gtk_label_new (date_modified_str); gtk_widget_set_halign (date_modified_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), date_modified_data, date_modified_w, GTK_POS_RIGHT, 2, 1); if (date_created_w != NULL) { GtkWidget *date_created_data; date_created_data = gtk_label_new (date_created_str); gtk_widget_set_halign (date_created_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), date_created_data, date_created_w, GTK_POS_RIGHT, 2, 1); } type_description = photos_base_item_get_type_description (item); item_type_data = gtk_label_new (type_description); gtk_widget_set_halign (item_type_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), item_type_data, item_type, GTK_POS_RIGHT, 2, 1); if (dimensions_w != NULL) { GtkWidget *dims_data; g_autofree gchar *dims_str = NULL; gulong n = (gulong) height; dims_str = g_strdup_printf (ngettext ("%ld × %ld pixel", "%ld × %ld pixels", n), width, height); dims_data = gtk_label_new (dims_str); gtk_widget_set_halign (dims_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), dims_data, dimensions_w, GTK_POS_RIGHT, 2, 1); } if (self->camera_w != NULL) { photos_camera_cache_get_camera_async (self->camera_cache, equipment, self->cancellable, photos_properties_dialog_get_camera, self); } if (exposure_time_w != NULL) { GtkWidget *exposure_time_data; g_autofree gchar *exposure_time_str = NULL; exposure_time_str = g_strdup_printf ("%.3lf sec", exposure_time); exposure_time_data = gtk_label_new (exposure_time_str); gtk_widget_set_halign (exposure_time_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), exposure_time_data, exposure_time_w, GTK_POS_RIGHT, 2, 1); } if (fnumber_w != NULL) { GtkWidget *fnumber_data; g_autofree gchar *fnumber_str = NULL; fnumber_str = g_strdup_printf ("f/%.1lf", fnumber); fnumber_data = gtk_label_new (fnumber_str); gtk_widget_set_halign (fnumber_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), fnumber_data, fnumber_w, GTK_POS_RIGHT, 2, 1); } if (focal_length_w != NULL) { GtkWidget *focal_length_data; g_autofree gchar *focal_length_str = NULL; focal_length_str = g_strdup_printf ("%.0lf mm", focal_length); focal_length_data = gtk_label_new (focal_length_str); gtk_widget_set_halign (focal_length_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), focal_length_data, focal_length_w, GTK_POS_RIGHT, 2, 1); } if (iso_speed_w != NULL) { GtkWidget *iso_speed_data; g_autofree gchar *iso_speed_str = NULL; iso_speed_str = g_strdup_printf ("%.0lf", iso_speed); iso_speed_data = gtk_label_new (iso_speed_str); gtk_widget_set_halign (iso_speed_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), iso_speed_data, iso_speed_w, GTK_POS_RIGHT, 2, 1); } if (flash_w != NULL) { GtkWidget *flash_data; g_autofree gchar *flash_str = NULL; if (flash == PHOTOS_FLASH_OFF) flash_str = g_strdup (_("Off, did not fire")); else if (flash == PHOTOS_FLASH_ON) flash_str = g_strdup (_("On, fired")); else { const gchar *str; str = g_quark_to_string (flash); g_warning ("Unknown value for nmm:flash: %s", str); } flash_data = gtk_label_new (flash_str); gtk_widget_set_halign (flash_data, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (self->grid), flash_data, flash_w, GTK_POS_RIGHT, 2, 1); } if (modified_w != NULL) { GtkWidget *modified_grid; photos_base_item_pipeline_is_edited_async (item, self->cancellable, photos_properties_dialog_pipeline_is_edited, self); modified_grid = gtk_grid_new (); gtk_widget_set_hexpand (modified_grid, TRUE); gtk_orientable_set_orientation (GTK_ORIENTABLE (modified_grid), GTK_ORIENTATION_HORIZONTAL); self->modified_data = gtk_label_new (NULL); gtk_widget_set_halign (self->modified_data, GTK_ALIGN_START); gtk_widget_set_hexpand (self->modified_data, TRUE); gtk_widget_set_no_show_all (self->modified_data, TRUE); gtk_widget_set_valign (self->modified_data, GTK_ALIGN_BASELINE); gtk_widget_set_vexpand (self->modified_data, TRUE); context = gtk_widget_get_style_context (self->modified_data); gtk_style_context_add_class (context, "photos-fade-out"); gtk_container_add (GTK_CONTAINER (modified_grid), self->modified_data); self->revert_button = gtk_button_new_with_label (_("Discard all Edits")); gtk_widget_set_halign (self->revert_button, GTK_ALIGN_END); gtk_widget_set_hexpand (self->revert_button, TRUE); gtk_widget_set_no_show_all (self->revert_button, TRUE); context = gtk_widget_get_style_context (self->revert_button); gtk_style_context_add_class (context, "destructive-action"); gtk_style_context_add_class (context, "photos-fade-out"); gtk_container_add (GTK_CONTAINER (modified_grid), self->revert_button); g_signal_connect_swapped (self->revert_button, "clicked", G_CALLBACK (photos_properties_dialog_revert_clicked), self); gtk_grid_attach_next_to (GTK_GRID (self->grid), modified_grid, modified_w, GTK_POS_RIGHT, 2, 1); } }
static void cc_background_panel_init (CcBackgroundPanel *self) { CcBackgroundPanelPrivate *priv; gchar *objects[] = {"background-panel", NULL }; GError *err = NULL; GtkWidget *widget; priv = self->priv = BACKGROUND_PANEL_PRIVATE (self); priv->connection = g_application_get_dbus_connection (g_application_get_default ()); g_resources_register (cc_background_get_resource ()); priv->builder = gtk_builder_new (); gtk_builder_add_objects_from_resource (priv->builder, "/org/gnome/control-center/background/background.ui", objects, &err); if (err) { g_warning ("Could not load ui: %s", err->message); g_error_free (err); return; } priv->settings = g_settings_new (WP_PATH_ID); g_settings_delay (priv->settings); priv->lock_settings = g_settings_new (WP_LOCK_PATH_ID); g_settings_delay (priv->lock_settings); /* add the top level widget */ widget = WID ("background-panel"); gtk_container_add (GTK_CONTAINER (self), widget); gtk_widget_show_all (GTK_WIDGET (self)); /* setup preview area */ widget = WID ("background-desktop-drawingarea"); g_signal_connect (widget, "draw", G_CALLBACK (on_preview_draw), self); widget = WID ("background-lock-drawingarea"); g_signal_connect (widget, "draw", G_CALLBACK (on_lock_preview_draw), self); priv->copy_cancellable = g_cancellable_new (); priv->capture_cancellable = g_cancellable_new (); priv->thumb_factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE); /* Load the backgrounds */ reload_current_bg (self, priv->settings); update_preview (priv, priv->settings, NULL); reload_current_bg (self, priv->lock_settings); update_preview (priv, priv->lock_settings, NULL); /* Background settings */ g_signal_connect (priv->settings, "changed", G_CALLBACK (on_settings_changed), self); g_signal_connect (priv->lock_settings, "changed", G_CALLBACK (on_settings_changed), self); /* Background buttons */ widget = WID ("background-set-button"); g_signal_connect (widget, "clicked", G_CALLBACK (on_background_button_clicked), self); widget = WID ("background-lock-set-button"); g_signal_connect (widget, "clicked", G_CALLBACK (on_lock_button_clicked), self); }
static void gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass) { GtkWidget *grid; GtkWidget *label; GtkWidget *exp; gchar *str; g_return_if_fail (GDAUI_IS_DSN_EDITOR (config)); gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL); /* allocate private structure */ config->priv = g_new0 (GdauiDsnEditorPrivate, 1); config->priv->dsn_info = g_new0 (GdaDsnInfo, 1); config->priv->no_change_signal = TRUE; /* data source's name and icon */ GtkWidget *hbox_header; hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6); config->priv->icon = gtk_image_new (); gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0); config->priv->wname = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10); GtkWidget *menu_button; menu_button = gtk_menu_button_new (); gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0); GtkWidget *menu_icon; menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon); GMenu *smenu; smenu = g_menu_new (); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu)); GMenuItem *mitem; mitem = g_menu_item_new ("Test data source", "win.DSNTest"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy"); g_menu_insert_item (smenu, -1, mitem); GtkWindow *win; win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config); /* stack in a scrolled window */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6); /* Stack */ config->priv->stack = gtk_stack_new (); gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_container_add (GTK_CONTAINER (sw), config->priv->stack); /* set up widgets */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_widget_show (grid); label = gtk_label_new_with_mnemonic (_("_System wide data source:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); config->priv->is_system = gtk_check_button_new (); gtk_widget_show (config->priv->is_system); g_signal_connect (G_OBJECT (config->priv->is_system), "toggled", G_CALLBACK (field_toggled_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1); str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:")); label = gtk_label_new (""); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); config->priv->wprovider = gdaui_provider_selector_new (); gtk_widget_set_hexpand (config->priv->wprovider, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider); gtk_widget_show (config->priv->wprovider); g_signal_connect (G_OBJECT (config->priv->wprovider), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1); label = gtk_label_new_with_mnemonic (_("_Description:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); config->priv->wdesc = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc); gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE); gtk_widget_set_vexpand (config->priv->wdesc, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc); g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1); config->priv->warning = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (config->priv->warning), _("<span foreground='red'>The database provider used by this data source is not available,\n" "editing the data source's attributes is disabled</span>")); gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER); gtk_widget_set_hexpand (config->priv->warning, TRUE); g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL); gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE); gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1); gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION); /* connection's spec */ config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_spec); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS); /* connection's authentication */ config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_auth); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH); config->priv->no_change_signal = FALSE; }
static void photos_base_item_check_effects_and_update_info (PhotosBaseItem *self) { PhotosBaseItemPrivate *priv = self->priv; GApplication *app; GIcon *pix; GList *emblem_icons = NULL; GList *windows; GdkPixbuf *emblemed_pixbuf = NULL; GdkPixbuf *thumbnailed_pixbuf = NULL; GdkWindow *window; gint scale; if (priv->original_icon == NULL) goto out; emblemed_pixbuf = g_object_ref (priv->original_icon); if (priv->favorite) { pix = photos_base_item_create_symbolic_emblem (PHOTOS_ICON_FAVORITE); emblem_icons = g_list_prepend (emblem_icons, pix); } if (g_list_length (emblem_icons) > 0) { GIcon *emblemed_icon; GList *l; GtkIconInfo *icon_info; GtkIconTheme *theme; gint height; gint size; gint width; emblem_icons = g_list_reverse (emblem_icons); emblemed_icon = g_emblemed_icon_new (G_ICON (priv->original_icon), NULL); for (l = emblem_icons; l != NULL; l = g_list_next (l)) { GEmblem *emblem; GIcon *emblem_icon = G_ICON (l->data); emblem = g_emblem_new (emblem_icon); g_emblemed_icon_add_emblem (G_EMBLEMED_ICON (emblemed_icon), emblem); g_object_unref (emblem); } theme = gtk_icon_theme_get_default (); width = gdk_pixbuf_get_width (priv->original_icon); height = gdk_pixbuf_get_height (priv->original_icon); size = (width > height) ? width : height; icon_info = gtk_icon_theme_lookup_by_gicon (theme, emblemed_icon, size, GTK_ICON_LOOKUP_FORCE_SIZE); if (icon_info != NULL) { GError *error = NULL; GdkPixbuf *tmp; tmp = gtk_icon_info_load_icon (icon_info, &error); if (error != NULL) { g_warning ("Unable to render the emblem: %s", error->message); g_error_free (error); } else { g_object_unref (emblemed_pixbuf); emblemed_pixbuf = tmp; } g_object_unref (icon_info); } g_object_unref (emblemed_icon); } g_clear_pointer (&priv->surface, (GDestroyNotify) cairo_surface_destroy); if (priv->thumb_path != NULL) { GtkBorder *slice; slice = photos_utils_get_thumbnail_frame_border (); thumbnailed_pixbuf = gd_embed_image_in_frame (emblemed_pixbuf, "resource:///org/gnome/photos/thumbnail-frame.png", slice, slice); gtk_border_free (slice); } else thumbnailed_pixbuf = g_object_ref (emblemed_pixbuf); app = g_application_get_default (); scale = photos_application_get_scale_factor (PHOTOS_APPLICATION (app)); windows = gtk_application_get_windows (GTK_APPLICATION (app)); window = gtk_widget_get_window (GTK_WIDGET (windows->data)); priv->surface = gdk_cairo_surface_create_from_pixbuf (thumbnailed_pixbuf, scale, window); g_signal_emit (self, signals[INFO_UPDATED], 0); out: g_clear_object (&thumbnailed_pixbuf); g_clear_object (&emblemed_pixbuf); g_list_free_full (emblem_icons, g_object_unref); }
GtkWidget * screenshot_interactive_dialog_new (CaptureClickedCallback f, gpointer user_data) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *button_box; GtkWidget *button; gboolean shows_app_menu; GtkSettings *settings; CaptureData *data; dialog = gtk_application_window_new (GTK_APPLICATION (g_application_get_default ())); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), _("Take Screenshot")); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); /* main container */ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5); gtk_container_add (GTK_CONTAINER (dialog), main_vbox); create_screenshot_frame (main_vbox, _("Take Screenshot")); create_effects_frame (main_vbox, _("Effects")); button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_END); gtk_container_add (GTK_CONTAINER (main_vbox), button_box); /* add help as a dialog button if we're not showing the application menu */ settings = gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (dialog))); g_object_get (settings, "gtk-shell-shows-app-menu", &shows_app_menu, NULL); if (!shows_app_menu) { button = gtk_button_new_from_stock (GTK_STOCK_HELP); g_signal_connect_swapped (button, "clicked", G_CALLBACK (screenshot_display_help), dialog); gtk_container_add (GTK_CONTAINER (button_box), button); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (button_box), button, TRUE); } button = gtk_button_new_with_mnemonic (_("Take _Screenshot")); data = g_new (CaptureData, 1); data->widget = dialog; data->callback = f; data->user_data = user_data; g_signal_connect (button, "clicked", G_CALLBACK (capure_button_clicked_cb), data); gtk_container_add (GTK_CONTAINER (button_box), button); gtk_widget_set_can_default (button, TRUE); gtk_widget_grab_default (button); g_signal_connect (dialog, "key-press-event", G_CALLBACK (interactive_dialog_key_press_cb), NULL); gtk_widget_show_all (dialog); return dialog; }
static void drag_data_received_callback (GtkWidget *widget, GdkDragContext *context, int x, int y, GtkSelectionData *data, guint info, guint32 time, gpointer callback_data) { char **names; int name_count; GtkWidget *window; gboolean new_windows_for_extras; char *prompt; char *detail; GFile *location; NautilusLocationEntry *self = NAUTILUS_LOCATION_ENTRY (widget); g_assert (data != NULL); g_assert (callback_data == NULL); names = g_uri_list_extract_uris ((const gchar *) gtk_selection_data_get_data (data)); if (names == NULL || *names == NULL) { g_warning ("No D&D URI's"); gtk_drag_finish (context, FALSE, FALSE, time); return; } window = gtk_widget_get_toplevel (widget); new_windows_for_extras = FALSE; /* Ask user if they really want to open multiple windows * for multiple dropped URIs. This is likely to have been * a mistake. */ name_count = g_strv_length (names); if (name_count > 1) { prompt = g_strdup_printf (ngettext("Do you want to view %d location?", "Do you want to view %d locations?", name_count), name_count); detail = g_strdup_printf (ngettext("This will open %d separate window.", "This will open %d separate windows.", name_count), name_count); /* eel_run_simple_dialog should really take in pairs * like gtk_dialog_new_with_buttons() does. */ new_windows_for_extras = eel_run_simple_dialog (GTK_WIDGET (window), TRUE, GTK_MESSAGE_QUESTION, prompt, detail, _("_Cancel"), _("_OK"), NULL) != 0 /* GNOME_OK */; g_free (prompt); g_free (detail); if (!new_windows_for_extras) { gtk_drag_finish (context, FALSE, FALSE, time); return; } } location = g_file_new_for_uri (names[0]); nautilus_location_entry_set_location (self, location); emit_location_changed (self); g_object_unref (location); if (new_windows_for_extras) { int i; for (i = 1; names[i] != NULL; ++i) { location = g_file_new_for_uri (names[i]); nautilus_application_open_location_full (NAUTILUS_APPLICATION (g_application_get_default ()), location, NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW, NULL, NULL, NULL); g_object_unref (location); } } g_strfreev (names); gtk_drag_finish (context, TRUE, FALSE, time); }
static void nautilus_bookmarks_window_constructed (GObject *object) { NautilusBookmarksWindow *self = NAUTILUS_BOOKMARKS_WINDOW (object); GtkBuilder *builder; GError *error = NULL; GtkWindow *window; GtkWidget *content; GtkTreeViewColumn *col; GtkCellRenderer *rend; G_OBJECT_CLASS (nautilus_bookmarks_window_parent_class)->constructed (object); builder = gtk_builder_new (); if (!gtk_builder_add_from_resource (builder, "/org/gnome/nautilus/nautilus-bookmarks-window.ui", &error)) { g_object_unref (builder); g_critical ("Can't load UI description for the bookmarks editor: %s", error->message); g_error_free (error); return; } window = GTK_WINDOW (object); gtk_window_set_title (window, _("Bookmarks")); gtk_window_set_default_size (window, BOOKMARKS_WINDOW_INITIAL_WIDTH, BOOKMARKS_WINDOW_INITIAL_HEIGHT); gtk_window_set_application (window, gtk_window_get_application (GTK_WINDOW (self->priv->parent_window))); gtk_window_set_destroy_with_parent (window, TRUE); gtk_window_set_transient_for (window, GTK_WINDOW (self->priv->parent_window)); gtk_window_set_position (window, GTK_WIN_POS_CENTER_ON_PARENT); gtk_container_set_border_width (GTK_CONTAINER (window), 6); g_signal_connect (window, "key-press-event", G_CALLBACK (nautilus_bookmarks_window_key_press_event_cb), NULL); content = GTK_WIDGET (gtk_builder_get_object (builder, "bookmarks_window_content")); gtk_container_add (GTK_CONTAINER (window), content); /* tree view */ self->priv->tree_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "bookmark_tree_view")); self->priv->selection = gtk_tree_view_get_selection (self->priv->tree_view); gtk_tree_selection_set_mode (self->priv->selection, GTK_SELECTION_BROWSE); rend = gtk_cell_renderer_pixbuf_new (); g_object_set (rend, "follow-state", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "gicon", BOOKMARK_LIST_COLUMN_ICON, NULL); gtk_tree_view_append_column (self->priv->tree_view, GTK_TREE_VIEW_COLUMN (col)); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), NAUTILUS_ICON_SIZE_SMALLER); rend = gtk_cell_renderer_text_new (); g_object_set (rend, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "text", BOOKMARK_LIST_COLUMN_NAME, "style", BOOKMARK_LIST_COLUMN_STYLE, NULL); gtk_tree_view_append_column (self->priv->tree_view, GTK_TREE_VIEW_COLUMN (col)); self->priv->model = create_bookmark_store (); setup_empty_list (self); /* name entry */ self->priv->name_field = nautilus_entry_new (); gtk_widget_show (self->priv->name_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_name_placeholder")), self->priv->name_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_name_label")), self->priv->name_field); /* URI entry */ self->priv->uri_field = nautilus_entry_new (); gtk_widget_show (self->priv->uri_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_location_placeholder")), self->priv->uri_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_location_label")), self->priv->uri_field); /* buttons */ self->priv->remove_button = GTK_WIDGET (gtk_builder_get_object (builder, "bookmark_remove_button")); self->priv->up_button = GTK_WIDGET (gtk_builder_get_object (builder, "bookmark_up_button")); self->priv->down_button = GTK_WIDGET (gtk_builder_get_object (builder, "bookmark_down_button")); g_object_unref (builder); /* setup bookmarks list and signals */ self->priv->bookmarks = nautilus_application_get_bookmarks (NAUTILUS_APPLICATION (g_application_get_default ())); self->priv->bookmarks_changed_id = g_signal_connect (self->priv->bookmarks, "changed", G_CALLBACK (on_bookmark_list_changed), self); self->priv->row_changed_id = g_signal_connect (self->priv->model, "row-changed", G_CALLBACK (on_row_changed), self); self->priv->row_deleted_id = g_signal_connect (self->priv->model, "row-deleted", G_CALLBACK (on_row_deleted), self); self->priv->row_activated_id = g_signal_connect (self->priv->tree_view, "row-activated", G_CALLBACK (on_row_activated), self); self->priv->button_press_id = g_signal_connect (self->priv->tree_view, "button-press-event", G_CALLBACK (on_button_pressed), self); self->priv->key_press_id = g_signal_connect (self->priv->tree_view, "key-press-event", G_CALLBACK (on_key_pressed), self); self->priv->selection_changed_id = g_signal_connect (self->priv->selection, "changed", G_CALLBACK (on_selection_changed), self); self->priv->name_changed_id = g_signal_connect (self->priv->name_field, "changed", G_CALLBACK (on_name_field_changed), self); g_signal_connect (self->priv->name_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), self); g_signal_connect (self->priv->name_field, "activate", G_CALLBACK (name_or_uri_field_activate), self); self->priv->uri_changed_id = g_signal_connect (self->priv->uri_field, "changed", G_CALLBACK (on_uri_field_changed), self); g_signal_connect (self->priv->uri_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), self); g_signal_connect (self->priv->uri_field, "activate", G_CALLBACK (name_or_uri_field_activate), self); g_signal_connect (self->priv->remove_button, "clicked", G_CALLBACK (on_remove_button_clicked), self); g_signal_connect (self->priv->up_button, "clicked", G_CALLBACK (on_up_button_clicked), self); g_signal_connect (self->priv->down_button, "clicked", G_CALLBACK (on_down_button_clicked), self); /* Fill in list widget with bookmarks, must be after signals are wired up. */ repopulate (self); }
/* Gobj */ static void bjb_window_base_constructed (GObject *obj) { BjbWindowBase *self = BJB_WINDOW_BASE (obj); BjbWindowBasePriv *priv; gboolean maximized; const gint32 *position; const gint32 *size; gsize n_elements; GVariant *variant; G_OBJECT_CLASS (bjb_window_base_parent_class)->constructed (obj); priv = self->priv; priv->settings = bjb_app_get_settings ((gpointer) g_application_get_default ()); gtk_window_set_position (GTK_WINDOW (self),GTK_WIN_POS_CENTER); gtk_window_set_title (GTK_WINDOW (self), _(BIJIBEN_MAIN_WIN_TITLE)); variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-size"); size = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32)); if (n_elements == 2) gtk_window_set_default_size (GTK_WINDOW (self), size[0], size[1]); g_variant_unref (variant); variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-position"); position = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32)); if (n_elements == 2) gtk_window_move (GTK_WINDOW (self), position[0], position[1]); g_variant_unref (variant); maximized = g_settings_get_boolean (G_SETTINGS (priv->settings), "window-maximized"); if (maximized) gtk_window_maximize (GTK_WINDOW (self)); /* We probably want to offer a no entry window at first (startup) */ priv->entry = NULL ; priv->controller = bjb_controller_new (bijiben_get_manager (BIJIBEN_APPLICATION(g_application_get_default())), GTK_WINDOW (obj), priv->entry ); /* Shared toolbar */ priv->view = bjb_main_view_new (GTK_WIDGET (obj), priv->controller); priv->main_toolbar = bjb_main_toolbar_new (priv->view, priv->controller); gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->main_toolbar)); /* Search entry toolbar */ priv->search_bar = bjb_search_toolbar_new (GTK_WIDGET (obj), priv->controller); gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->search_bar), FALSE, FALSE, 0); /* UI : stack for different views */ priv->stack = GTK_STACK (gtk_stack_new ()); gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->stack), TRUE, TRUE, 0); priv->spinner = gtk_spinner_new (); gtk_stack_add_named (priv->stack, priv->spinner, "spinner"); gtk_stack_set_visible_child_name (priv->stack, "spinner"); gtk_widget_show (priv->spinner); gtk_spinner_start (GTK_SPINNER (priv->spinner)); priv->no_note = bjb_empty_results_box_new (); gtk_stack_add_named (priv->stack, priv->no_note, "empty"); gtk_stack_add_named (priv->stack, GTK_WIDGET (priv->view), "main-view"); gtk_widget_show (GTK_WIDGET (priv->stack)); /* Connection to window signals */ g_signal_connect (GTK_WIDGET (self), "destroy", G_CALLBACK (bjb_window_base_destroy), self); g_signal_connect (self, "window-state-event", G_CALLBACK (bjb_application_window_state_changed), priv->settings); g_signal_connect (self, "configure-event", G_CALLBACK (bjb_application_window_configured), self); /* Keys */ g_signal_connect (GTK_WIDGET (self), "key-press-event", G_CALLBACK(on_key_pressed_cb), self); /* If a note is requested at creation, show it * This is a specific type of window not associated with any view */ if (priv->note == NULL) { bjb_window_base_switch_to (self, BJB_WINDOW_BASE_MAIN_VIEW); } else { priv->detached = TRUE; bjb_window_base_switch_to_item (self, BIJI_ITEM (priv->note)); } /* For some reason, do not gtk_widget_show _self_ * or gtk_application_get_menu_bar will run, * fire a warning, while app menu will not show up * you have been warned! * * This is probably due to the fact that, * at startup, we still are * inside... drums... gapplication startup () */ gtk_widget_show (priv->vbox); }
BijiManager * bjb_window_base_get_manager(GtkWidget * win) { return bijiben_get_manager (BIJIBEN_APPLICATION (g_application_get_default())); }
static void photos_view_container_constructed (GObject *object) { PhotosViewContainer *self = PHOTOS_VIEW_CONTAINER (object); PhotosViewContainerPrivate *priv = self->priv; AtkObject *accessible; GAction *action; GApplication *app; GtkWidget *generic_view; GtkWidget *grid; PhotosSearchContextState *state; gboolean status; gint size; G_OBJECT_CLASS (photos_view_container_parent_class)->constructed (object); app = g_application_get_default (); state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app)); accessible = gtk_widget_get_accessible (GTK_WIDGET (self)); if (accessible != NULL) atk_object_set_name (accessible, priv->name); priv->model = photos_view_model_new (priv->mode); grid = gtk_grid_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL); gtk_stack_add_named (GTK_STACK (self), grid, "view"); priv->no_results = photos_empty_results_box_new (priv->mode); gtk_stack_add_named (GTK_STACK (self), priv->no_results, "no-results"); priv->error_box = photos_error_box_new (); gtk_stack_add_named (GTK_STACK (self), priv->error_box, "error"); priv->view = gd_main_view_new (GD_MAIN_VIEW_ICON); generic_view = gd_main_view_get_generic_view (priv->view); size = photos_utils_get_icon_size_unscaled (); gtk_icon_view_set_item_width (GTK_ICON_VIEW (generic_view), size + 24); gtk_container_add (GTK_CONTAINER (grid), GTK_WIDGET (priv->view)); gtk_widget_show_all (GTK_WIDGET (self)); gtk_stack_set_visible_child_full (GTK_STACK (self), "view", GTK_STACK_TRANSITION_TYPE_NONE); g_signal_connect_swapped (priv->view, "item-activated", G_CALLBACK (photos_view_container_item_activated), self); g_signal_connect_swapped (priv->view, "selection-mode-request", G_CALLBACK (photos_view_container_selection_mode_request), self); g_signal_connect_swapped (priv->view, "view-selection-changed", G_CALLBACK (photos_view_container_view_selection_changed), self); priv->item_mngr = g_object_ref (state->item_mngr); priv->sel_cntrlr = photos_selection_controller_dup_singleton (); g_signal_connect_object (priv->sel_cntrlr, "selection-mode-changed", G_CALLBACK (photos_view_container_selection_mode_changed), self, G_CONNECT_SWAPPED); photos_view_container_selection_mode_changed (self, photos_selection_controller_get_selection_mode (priv->sel_cntrlr)); priv->mode_cntrlr = g_object_ref (state->mode_cntrlr); g_signal_connect_object (priv->mode_cntrlr, "window-mode-changed", G_CALLBACK (photos_view_container_window_mode_changed), self, G_CONNECT_SWAPPED); priv->remote_mngr = photos_remote_display_manager_dup_singleton (); switch (priv->mode) { case PHOTOS_WINDOW_MODE_COLLECTIONS: priv->trk_cntrlr = photos_tracker_collections_controller_dup_singleton (); priv->offset_cntrlr = photos_offset_collections_controller_dup_singleton (); break; case PHOTOS_WINDOW_MODE_FAVORITES: priv->trk_cntrlr = photos_tracker_favorites_controller_dup_singleton (); priv->offset_cntrlr = photos_offset_favorites_controller_dup_singleton (); break; case PHOTOS_WINDOW_MODE_OVERVIEW: priv->trk_cntrlr = photos_tracker_overview_controller_dup_singleton (); priv->offset_cntrlr = photos_offset_overview_controller_dup_singleton (); break; case PHOTOS_WINDOW_MODE_SEARCH: priv->trk_cntrlr = photos_tracker_search_controller_dup_singleton (); priv->offset_cntrlr = photos_offset_search_controller_dup_singleton (); break; case PHOTOS_WINDOW_MODE_NONE: case PHOTOS_WINDOW_MODE_EDIT: case PHOTOS_WINDOW_MODE_PREVIEW: default: g_assert_not_reached (); break; } action = g_action_map_lookup_action (G_ACTION_MAP (app), "select-all"); g_signal_connect_object (action, "activate", G_CALLBACK (photos_view_container_select_all), self, G_CONNECT_SWAPPED); action = g_action_map_lookup_action (G_ACTION_MAP (app), "select-none"); g_signal_connect_object (action, "activate", G_CALLBACK (gd_main_view_unselect_all), priv->view, G_CONNECT_SWAPPED); g_signal_connect_object (priv->offset_cntrlr, "count-changed", G_CALLBACK (photos_view_container_count_changed), self, G_CONNECT_SWAPPED); g_signal_connect_object (priv->trk_cntrlr, "query-error", G_CALLBACK (photos_view_container_query_error), self, G_CONNECT_SWAPPED); g_signal_connect_object (priv->trk_cntrlr, "query-status-changed", G_CALLBACK (photos_view_container_query_status_changed), self, G_CONNECT_SWAPPED); photos_tracker_controller_start (priv->trk_cntrlr); status = photos_tracker_controller_get_query_status (priv->trk_cntrlr); photos_view_container_query_status_changed (self, status); }
static GMenuModel * find_plugin_menu (void) { return (GMenuModel*) g_object_get_data (G_OBJECT (g_application_get_default ()), "plugin-menu"); }