/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
*
* Copyright 2010, 2013 Red Hat, Inc,
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*
* Written by: Matthias Clasen <mclasen@redhat.com>
*/
#include "config.h"
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <gio/gio.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#define GSM_MANAGER_SCHEMA "org.gnome.SessionManager"
#define KEY_AUTOSAVE_ONE_SHOT "auto-save-session-one-shot"
static GtkBuilder *builder;
static GtkWidget *session_list;
static GtkListStore *store;
static GtkTreeModelSort *sort_model;
static void select_session (const char *name);
static char *
get_session_path (const char *name)
{
return g_build_filename (g_get_user_config_dir (), "gnome-session", name, NULL);
}
static char *
find_new_session_name (void)
{
char *name;
char *path;
int i;
for (i = 1; i < 20; i++) {
name = g_strdup_printf (_("Session %d"), i);
path = get_session_path (name);
if (!g_file_test (path, G_FILE_TEST_EXISTS)) {
g_free (path);
return name;
}
g_free (path);
g_free (name);
}
return NULL;
}
static gboolean
is_valid_session_name (const char *name)
{
GtkTreeIter iter;
char *n;
const char *info_text;
char *warning_text;
gboolean user_tried_dot;
gboolean user_tried_slash;
GtkWidget *info_bar;
GtkWidget *label;
if (name[0] == 0) {
return FALSE;
}
if (name[0] == '.') {
user_tried_dot = TRUE;
} else {
user_tried_dot = FALSE;
}
if (strchr (name, '/') != NULL) {
user_tried_slash = TRUE;
} else {
user_tried_slash = FALSE;
}
info_text = _("Please select a custom session to run");
warning_text = NULL;
if (user_tried_dot && user_tried_slash) {
warning_text = g_strdup_printf ("%s\n<small><b>Note:</b> <i>%s</i></small>",
info_text,
_("Session names are not allowed to start with “.” or contain “/” characters"));
} else if (user_tried_dot) {
warning_text = g_strdup_printf ("%s\n<small><b>Note:</b> <i>%s</i></small>",
info_text,
_("Session names are not allowed to start with “.”"));
} else if (user_tried_slash) {
warning_text = g_strdup_printf ("%s\n<small><b>Note:</b> <i>%s</i></small>",
info_text,
_("Session names are not allowed to contain “/” characters"));
}
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
do {
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, 0, &n, -1);
if (strcmp (n, name) == 0) {
char *message;
message = g_strdup_printf (_("A session named “%s” already exists"), name);
warning_text = g_strdup_printf ("%s\n<small><b>Note:</b> <i>%s</i></small>", info_text, message);
g_free (message);
g_free (n);
break;
}
g_free (n);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter));
info_bar = (GtkWidget *) gtk_builder_get_object (builder, "info-bar");
label = (GtkWidget*) gtk_builder_get_object (builder, "info-label");
if (warning_text != NULL) {
gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_WARNING);
gtk_label_set_markup (GTK_LABEL (label), warning_text);
g_free (warning_text);
return FALSE;
}
gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_OTHER);
gtk_label_set_markup (GTK_LABEL (label), info_text);
return TRUE;
}
static void
populate_session_list (GtkWidget *session_list)
{
GtkTreeIter iter;
char *path;
const char *name;
GDir *dir;
GError *error;
char *saved_session;
char *default_session;
char *default_name;
char last_session[PATH_MAX] = "";
saved_session = get_session_path ("saved-session");
if (!g_file_test (saved_session, G_FILE_TEST_IS_SYMLINK)) {
default_name = find_new_session_name ();
default_session = get_session_path (default_name);
rename (saved_session, default_session);
if (symlink (default_name, saved_session) < 0)
g_warning ("Failed to convert saved-session to symlink");
g_free (default_name);
g_free (default_session);
}
path = g_build_filename (g_get_user_config_dir (), "gnome-session", NULL);
error = NULL;
dir = g_dir_open (path, 0, &error);
if (dir == NULL) {
g_warning ("Failed to open %s: %s", path, error->message);
g_error_free (error);
goto out;
}
default_name = NULL;
if (readlink (saved_session, last_session, PATH_MAX - 1) > 0) {
default_name = g_path_get_basename (last_session);
}
while ((name = g_dir_read_name (dir)) != NULL) {
if (strcmp (name, "saved-session") == 0)
continue;
gtk_list_store_insert_with_values (store, &iter, 100, 0, name, -1);
if (g_strcmp0 (default_name, name) == 0) {
GtkTreeSelection *selection;
GtkTreeIter child_iter;
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &child_iter, &iter);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (session_list));
gtk_tree_selection_select_iter (selection, &child_iter);
}
}
g_free (default_name);
g_dir_close (dir);
out:
g_free (saved_session);
g_free (path);
}
static char *
get_selected_session (void)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *name;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (session_list));
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
gtk_tree_model_get (model, &iter, 0, &name, -1);
return name;
}
return NULL;
}
static void
remove_session (const char *name)
{
char *path1, *path2;
char *n, *path;
const char *d;
GDir *dir;
GError *error;
path1 = get_session_path ("saved-session");
path2 = get_session_path (name);
error = NULL;
n = g_file_read_link (path1, &error);
if (n == NULL) {
g_warning ("Failed to read link: %s", error->message);
g_error_free (error);
}
else if (strcmp (n, name) == 0) {
unlink (path1);
}
g_free (n);
dir = g_dir_open (path2, 0, NULL);
while ((d = g_dir_read_name (dir)) != NULL) {
path = g_build_filename (path2, d, NULL);
unlink (path);
g_free (path);
}
g_dir_close (dir);
remove (path2);
g_free (path1);
g_free (path2);
}
static void
on_remove_session_clicked (GtkButton *button,
gpointer data)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
char *name;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (session_list));
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
GtkTreeIter child_iter;
gtk_tree_model_get (model, &iter, 0, &name, -1);
remove_session (name);
g_free (name);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model), &child_iter, &iter);
gtk_list_store_remove (GTK_LIST_STORE (store), &child_iter);
if (!gtk_tree_selection_get_selected (selection, NULL, NULL)) {
gtk_tree_model_get_iter_first (model, &iter);
gtk_tree_model_get (model, &iter, 0, &name, -1);
select_session (name);
g_free (name);
}
}
}
static void
begin_rename (void)
{
GtkTreePath *path;
GtkTreeViewColumn *column;
GList *cells;
gtk_widget_grab_focus (session_list);
gtk_tree_view_get_cursor (GTK_TREE_VIEW (session_list),
&path, &column);
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
if (cells != NULL) {
GtkCellRenderer *cell;
cell = (GtkCellRenderer *) cells->data;
g_list_free (cells);
g_object_set (cell, "editable", TRUE, NULL);
gtk_tree_view_set_cursor_on_cell (GTK_TREE_VIEW (session_list), path,
column, cell, TRUE);
}
gtk_tree_path_free (path);
}
static void
on_rename_session_clicked (GtkButton *button,
gpointer data)
{
begin_rename ();
}
static void
on_continue_clicked (GtkButton *button,
gpointer data)
{
char *name;
name = get_selected_session ();
g_free (name);
gtk_main_quit ();
}
static void
create_session (const char *name)
{
char *path;
GtkTreeIter iter;
path = get_session_path (name);
if (mkdir (path, 0755) < 0) {
g_warning ("Failed to create directory %s", path);
}
else {
char *marker;
gtk_list_store_insert_with_values (store, &iter, 100, 0, name, -1);
marker = g_build_filename (path, ".new-session", NULL);
creat (marker, 0600);
g_free (marker);
}
g_free (path);
}
static gboolean
rename_session (const char *old_name,
const char *new_name)
{
char *old_path, *new_path;
int result;
if (g_strcmp0 (old_name, new_name) == 0) {
return TRUE;
}
if (!is_valid_session_name (new_name)) {
return FALSE;
}
old_path = get_session_path (old_name);
new_path = get_session_path (new_name);
result = g_rename (old_path, new_path);
if (result < 0) {
g_warning ("Failed to rename session from '%s' to '%s': %m", old_name, new_name);
}
g_free (old_path);
g_free (new_path);
return result == 0;
}
static gboolean
make_session_current (const char *name)
{
char *path1;
gboolean ret = TRUE;
path1 = g_build_filename (g_get_user_config_dir (), "gnome-session", "saved-session", NULL);
unlink (path1);
if (symlink (name, path1) < 0) {
g_warning ("Failed to make session '%s' current", name);
ret = FALSE;
}
g_free (path1);
return ret;
}
static gboolean
create_and_select_session (const char *name)
{
gchar *path;
if (name[0] == 0 || name[0] == '.' || strchr (name, '/')) {
g_warning ("Invalid session name");
return FALSE;
}
path = g_build_filename (g_get_user_config_dir (), "gnome-session", name, NULL);
if (!g_file_test (path, G_FILE_TEST_IS_DIR)) {
if (mkdir (path, 0755) < 0) {
g_warning ("Failed to create directory %s", path);
g_free (path);
return FALSE;
}
}
g_free (path);
return make_session_current (name);
}
static void
select_session (const char *name)
{
GtkTreeIter iter;
char *n;
make_session_current (name);
/* now select it in the list */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (sort_model), &iter);
do {
gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &iter, 0, &n, -1);
if (strcmp (n, name) == 0) {
GtkTreePath *path;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (sort_model), &iter);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (session_list), path, NULL, FALSE);
gtk_tree_path_free (path);
g_free (n);
break;
}
g_free (n);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (sort_model), &iter));
}
static void
on_new_session_clicked (GtkButton *button,
gpointer data)
{
gchar *name;
name = find_new_session_name ();
create_session (name);
select_session (name);
begin_rename ();
}
static void
on_selection_changed (GtkTreeSelection *selection,
gpointer data)
{
char *name;
name = get_selected_session ();
if (name == NULL) {
return;
}
make_session_current (name);
g_free (name);
}
static void
update_remove_button (void)
{
GtkWidget *button;
button = (GtkWidget *)gtk_builder_get_object (builder, "remove-session");
if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL) > 1) {
gtk_widget_set_sensitive (button, TRUE);
} else {
gtk_widget_set_sensitive (button, FALSE);
}
}
static void
on_row_edited (GtkCellRendererText *cell,
const char *path_string,
const char *new_name,
gpointer data)
{
GtkTreePath *path;
GtkTreeIter sort_iter, items_iter;
char *old_name;
gboolean was_renamed;
path = gtk_tree_path_new_from_string (path_string);
gtk_tree_model_get_iter (GTK_TREE_MODEL (sort_model), &sort_iter, path);
gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &sort_iter, 0, &old_name, -1);
was_renamed = rename_session (old_name, new_name);
if (was_renamed) {
gtk_tree_model_sort_convert_iter_to_child_iter (sort_model, &items_iter, &sort_iter);
gtk_list_store_set (store, &items_iter, 0, g_strdup (new_name), -1);
g_free (old_name);
make_session_current (new_name);
} else {
begin_rename ();
}
gtk_tree_path_free (path);
g_object_set (cell, "editable", FALSE, NULL);
}
static void
on_row_deleted (GtkTreeModel *model,
GtkTreePath *path,
gpointer data)
{
update_remove_button ();
}
static void
on_row_inserted (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
update_remove_button ();
}
static void
on_row_activated (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
gpointer data)
{
char *name;
name = get_selected_session ();
g_free (name);
gtk_main_quit ();
}
static void
auto_save_next_session (void)
{
GSettings *settings;
settings = g_settings_new (GSM_MANAGER_SCHEMA);
g_settings_set_boolean (settings, KEY_AUTOSAVE_ONE_SHOT, TRUE);
g_object_unref (settings);
}
static void
auto_save_next_session_if_needed (void)
{
char *marker;
marker = g_build_filename (g_get_user_config_dir (),
"gnome-session", "saved-session",
".new-session", NULL);
if (g_file_test (marker, G_FILE_TEST_EXISTS)) {
auto_save_next_session ();
unlink (marker);
}
g_free (marker);
}
static int
compare_sessions (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer data)
{
char *name_a, *name_b;
int result;
gtk_tree_model_get (model, a, 0, &name_a, -1);
gtk_tree_model_get (model, b, 0, &name_b, -1);
result = g_utf8_collate (name_a, name_b);
g_free (name_a);
g_free (name_b);
return result;
}
static void
on_map (GtkWidget *widget,
gpointer data)
{
gdk_window_focus (gtk_widget_get_window (widget), GDK_CURRENT_TIME);
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *widget;
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GError *error;
if (getenv ("SESSION_MANAGER") != NULL)
return 1;
gtk_init (&argc, &argv);
if (argc > 1) {
g_print ("create and select session\n");
if (!create_and_select_session (argv[1]))
return 1;
else
return 0;
}
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
error = NULL;
if (!gtk_builder_add_from_file (builder, GTKBUILDER_DIR "/" "session-selector.ui", &error)) {
g_warning ("Could not load file 'session-selector.ui': %s", error->message);
exit (1);
}
window = (GtkWidget *) gtk_builder_get_object (builder, "main-window");
store = (GtkListStore *) gtk_builder_get_object (builder, "session-store");
sort_model = (GtkTreeModelSort *) gtk_builder_get_object (builder, "sort-model");
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model),
0, compare_sessions, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
0, GTK_SORT_ASCENDING);
g_signal_connect (store, "row-deleted", G_CALLBACK (on_row_deleted), NULL);
g_signal_connect (store, "row-inserted", G_CALLBACK (on_row_inserted), NULL);
session_list = (GtkWidget *) gtk_builder_get_object (builder, "session-list");
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (session_list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
populate_session_list (session_list);
cell = gtk_cell_renderer_text_new ();
g_signal_connect (cell, "edited", G_CALLBACK (on_row_edited), NULL);
column = gtk_tree_view_column_new_with_attributes ("", cell, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (session_list), GTK_TREE_VIEW_COLUMN (column));
g_signal_connect (session_list, "row-activated", G_CALLBACK (on_row_activated), NULL);
g_signal_connect (selection, "changed",
G_CALLBACK (on_selection_changed), NULL);
widget = (GtkWidget *) gtk_builder_get_object (builder, "new-session");
g_signal_connect (widget, "clicked", G_CALLBACK (on_new_session_clicked), NULL);
widget = (GtkWidget *) gtk_builder_get_object (builder, "remove-session");
g_signal_connect (widget, "clicked", G_CALLBACK (on_remove_session_clicked), NULL);
widget = (GtkWidget *) gtk_builder_get_object (builder, "rename-session");
g_signal_connect (widget, "clicked", G_CALLBACK (on_rename_session_clicked), NULL);
widget = (GtkWidget *) gtk_builder_get_object (builder, "continue-button");
g_signal_connect (widget, "clicked", G_CALLBACK (on_continue_clicked), NULL);
g_signal_connect (window, "map", G_CALLBACK (on_map), NULL);
gtk_widget_show (window);
gtk_main ();
auto_save_next_session_if_needed ();
return 0;
}