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