static void
user_removed (UmUserManager *um, UmUser *user, UmUserPanelPrivate *d)
{
    GtkTreeView *tv;
    GtkTreeModel *model;
    GtkTreeSelection *selection;
    GtkListStore *store;
    GtkTreeIter iter, next;
    UmUser *u;

    g_debug ("user removed: %s\n", um_user_get_user_name (user));
    tv = (GtkTreeView *)get_widget (d, "list-treeview");
    selection = gtk_tree_view_get_selection (tv);
    model = gtk_tree_view_get_model (tv);
    store = GTK_LIST_STORE (model);
    if (gtk_tree_model_get_iter_first (model, &iter)) {
        do {
            gtk_tree_model_get (model, &iter, USER_COL, &u, -1);

            if (u != NULL) {
                if (um_user_get_uid (user) == um_user_get_uid (u)) {
                    if (!get_next_user_row (model, &iter, &next))
                        get_previous_user_row (model, &iter, &next);
                    gtk_list_store_remove (store, &iter);
                    gtk_tree_selection_select_iter (selection, &next);
                    g_object_unref (u);
                    break;
                }
                g_object_unref (u);
            }
        } while (gtk_tree_model_iter_next (model, &iter));
    }
}
static gint
sort_login_users (GtkTreeModel *model,
                  GtkTreeIter  *a,
                  GtkTreeIter  *b,
                  gpointer      data)
{
        UmUser *ua, *ub;
        gint result;

        gtk_tree_model_get (model, a, AUTOLOGIN_USER_COL, &ua, -1);
        gtk_tree_model_get (model, b, AUTOLOGIN_USER_COL, &ub, -1);

        if (ua == NULL)
                result = -1;
        else if (ub == NULL)
                result = 1;
        else if (um_user_get_uid (ua) == getuid ())
                result = -1;
        else if (um_user_get_uid (ub) == getuid ())
                result = 1;
        else
                result = um_user_collate (ua, ub);

        if (ua)
                g_object_unref (ua);

        if (ub)
                g_object_unref (ub);

        return result;
}
示例#3
0
static void
autologin_changed (GObject            *object,
                   GParamSpec         *pspec,
                   UmUserPanelPrivate *d)
{
        gboolean active;
        UmUser *user;

        active = gtk_switch_get_active (GTK_SWITCH (object));
        user = get_selected_user (d);

        if (active != um_user_get_automatic_login (user)) {
                um_user_set_automatic_login (user, active);
                if (um_user_get_automatic_login (user)) {
                        GSList *list;
                        GSList *l;
                        list = um_user_manager_list_users (d->um);
                        for (l = list; l != NULL; l = l->next) {
                                UmUser *u = l->data;
                                if (um_user_get_uid (u) != um_user_get_uid (user)) {
                                        um_user_set_automatic_login (user, FALSE);
                                }
                        }
                        g_slist_free (list);
                }
        }

        g_object_unref (user);
}
void
um_password_dialog_set_user (UmPasswordDialog *um,
                             UmUser           *user)
{
        GdkPixbuf *pixbuf;
        GtkTreeModel *model;

        if (um->user) {
                g_object_unref (um->user);
                um->user = NULL;
        }
        if (user) {
                um->user = g_object_ref (user);

                um->using_ecryptfs = is_using_ecryptfs (um_user_get_user_name (user));

                pixbuf = um_user_render_icon (user, FALSE, 48);
                gtk_image_set_from_pixbuf (GTK_IMAGE (um->user_icon), pixbuf);
                g_object_unref (pixbuf);

                gtk_label_set_label (GTK_LABEL (um->user_name),
                                     um_user_get_real_name (user));

                gtk_entry_set_text (GTK_ENTRY (um->password_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->verify_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->normal_hint_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->old_password_entry), "");
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (um->show_password_button), FALSE);
                if (um_user_get_uid (um->user) == getuid () &&
                    um_user_get_password_mode (um->user) == UM_PASSWORD_MODE_REGULAR) {
                        gtk_widget_show (um->old_password_label);
                        gtk_widget_show (um->old_password_entry);
                        um->old_password_ok = FALSE;
                }
                else {
                        gtk_widget_hide (um->old_password_label);
                        gtk_widget_hide (um->old_password_entry);
                        um->old_password_ok = TRUE;
                }
                if (um_user_get_uid (um->user) == getuid()) {
                        if (um->passwd_handler != NULL)
                                passwd_destroy (um->passwd_handler);
                        um->passwd_handler = passwd_init ();
                }
        }

        model = gtk_combo_box_get_model (GTK_COMBO_BOX (um->action_combo));
        if (!GTK_IS_TREE_MODEL_FILTER (model)) {
                model = gtk_tree_model_filter_new (model, NULL);
                gtk_combo_box_set_model (GTK_COMBO_BOX (um->action_combo), model);
                gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
                                                        (GtkTreeModelFilterVisibleFunc) visible_func,
                                                        um, NULL);
        }

        gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
        gtk_combo_box_set_active (GTK_COMBO_BOX (um->action_combo), 0);
}
示例#5
0
static void
user_added (UmUserManager *um, UmUser *user, UmUserPanelPrivate *d)
{
        GtkWidget *widget;
        GtkTreeModel *model;
        GtkListStore *store;
        GtkTreeIter iter;
        GtkTreeIter dummy;
        GdkPixbuf *pixbuf;
        gchar *text;
        GtkTreeSelection *selection;
        gint sort_key;
        gboolean is_autologin;

        g_debug ("user added: %d %s\n", um_user_get_uid (user), um_user_get_real_name (user));
        widget = get_widget (d, "list-treeview");
        model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
        store = GTK_LIST_STORE (model);
        selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));

        pixbuf = um_user_render_icon (user, TRUE, 48);
        text = get_name_col_str (user);

        is_autologin = um_user_get_automatic_login (user);

        if (um_user_get_uid (user) == getuid ()) {
                sort_key = 1;
        }
        else {
                sort_key = 3;
        }
        gtk_list_store_append (store, &iter);

        gtk_list_store_set (store, &iter,
                            USER_COL, user,
                            FACE_COL, pixbuf,
                            NAME_COL, text,
                            USER_ROW_COL, TRUE,
                            TITLE_COL, NULL,
                            HEADING_ROW_COL, FALSE,
                            SORT_KEY_COL, sort_key,
                            AUTOLOGIN_COL, is_autologin,
                            -1);
        g_object_unref (pixbuf);
        g_free (text);

        if (sort_key == 1 &&
            !gtk_tree_selection_get_selected (selection, &model, &dummy)) {
                gtk_tree_selection_select_iter (selection, &iter);
        }
}
void
um_user_manager_delete_user (UmUserManager       *manager,
                             UmUser              *user,
                             gboolean             remove_files,
                             GAsyncReadyCallback  done,
                             gpointer             done_data,
                             GDestroyNotify       destroy)
{
        AsyncUserOpData *data;

        data = g_new0 (AsyncUserOpData, 1);
        data->manager = g_object_ref (manager);
        data->callback = done;
        data->data = done_data;
        data->destroy = destroy;

        g_dbus_proxy_call (manager->proxy,
                           "DeleteUser",
                           g_variant_new ("(xb)", (gint64) um_user_get_uid (user), remove_files),
                           G_DBUS_CALL_FLAGS_NONE,
                           -1,
                           NULL,
                           delete_user_done,
                           data);
}
static void
show_user (UmUser *user, UmUserPanelPrivate *d)
{
    GtkWidget *image;
    GtkWidget *label;
    GtkWidget *label2;
    GtkWidget *label3;
    GdkPixbuf *pixbuf;
    gchar *lang;
    GtkWidget *widget;
    GtkTreeModel *model;
    GtkTreeIter iter;
    gboolean show, enable;

    pixbuf = um_user_render_icon (user, FALSE, 48);
    image = get_widget (d, "user-icon-image");
    gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
    image = get_widget (d, "user-icon-image2");
    gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
    g_object_unref (pixbuf);

    um_photo_dialog_set_user (d->photo_dialog, user);

    widget = get_widget (d, "full-name-entry");
    cc_editable_entry_set_text (CC_EDITABLE_ENTRY (widget), um_user_get_real_name (user));
    gtk_widget_set_tooltip_text (widget, um_user_get_user_name (user));

    widget = get_widget (d, "account-type-combo");
    um_editable_combo_set_active (UM_EDITABLE_COMBO (widget), um_user_get_account_type (user));

    widget = get_widget (d, "account-password-button");
    um_editable_button_set_text (UM_EDITABLE_BUTTON (widget), get_password_mode_text (user));
    enable = um_user_is_local_account (user);
    gtk_widget_set_sensitive (widget, enable);

    widget = get_widget (d, "account-language-combo");
    model = um_editable_combo_get_model (UM_EDITABLE_COMBO (widget));
    cc_add_user_languages (model);

    lang = g_strdup (um_user_get_language (user));
    if (!lang)
        lang = cc_common_language_get_current_language ();
    cc_common_language_get_iter_for_language (model, lang, &iter);
    um_editable_combo_set_active_iter (UM_EDITABLE_COMBO (widget), &iter);
    g_free (lang);

    /* Fingerprint: show when self, possible, and local account */
    widget = get_widget (d, "account-fingerprint-notebook");
    label = get_widget (d, "account-fingerprint-label");
    label2 = get_widget (d, "account-fingerprint-value-label");
    label3 = get_widget (d, "account-fingerprint-button-label");
    show = (um_user_get_uid (user) == getuid() &&
            um_user_is_local_account (user) &&
            set_fingerprint_label (label2, label3));
    gtk_widget_set_visible (label, show);
    gtk_widget_set_visible (widget, show);
}
static void
user_removed (UmUserManager *um, UmUser *user, UmLoginOptions *d)
{
        GtkComboBox *combo;
        GtkTreeModel *model;
        GtkListStore *store;
        GtkTreeIter iter;
        UmUser *u;

        combo = GTK_COMBO_BOX (d->autologin_combo);
        model = gtk_combo_box_get_model (combo);
        store = (GtkListStore*)model;

        gtk_combo_box_get_active_iter (combo, &iter);
        gtk_tree_model_get (model, &iter, AUTOLOGIN_USER_COL, &u, -1);
        if (u != NULL) {
                if (um_user_get_uid (user) == um_user_get_uid (u)) {
                        /* autologin user got removed, set back to Disabled */
                        gtk_list_store_remove (store, &iter);
                        gtk_combo_box_set_active (combo, 0);
                        g_object_unref (u);
                        return;
                }
                g_object_unref (u);
        }
        if (gtk_tree_model_get_iter_first (model, &iter)) {
                do {
                        gtk_tree_model_get (model, &iter, AUTOLOGIN_USER_COL, &u, -1);

                        if (u != NULL) {
                                if (um_user_get_uid (user) == um_user_get_uid (u)) {
                                        gtk_list_store_remove (store, &iter);
                                        g_object_unref (u);
                                        return;
                                }
                                g_object_unref (u);
                        }
                } while (gtk_tree_model_iter_next (model, &iter));
        }
}
void
um_language_dialog_set_user (UmLanguageDialog *um,
                             UmUser           *user)
{
        GdkPixbuf *pixbuf;
        const gchar *name;

        if (um->user) {
                g_object_unref (um->user);
                um->user = NULL;
        }
        if (um->language) {
                g_free (um->language);
                um->language = NULL;
        }
        um->force_setting = FALSE;

        um->user = user;
        if (um->user) {
                const gchar *language;

                g_object_ref (user);

                pixbuf = um_user_render_icon (user, FALSE, 48);
                gtk_image_set_from_pixbuf (GTK_IMAGE (um->user_icon), pixbuf);
                g_object_unref (pixbuf);

                name = um_user_get_real_name (user);
                gtk_label_set_label (GTK_LABEL (um->user_name), name);

                um_add_user_languages (um->dialog_combo);

                language = um_user_get_language (user);
                if (language) {
                        select_language (um, language);
                } else if (um_user_get_uid (user) == getuid ()) {
                        const char *locale;
                        char *lang;

                        locale = (const char *) setlocale(LC_MESSAGES, NULL);
                        lang = gdm_normalize_language_name (locale);

                        select_language (um, lang);
                        g_free (lang);
                        um->force_setting = TRUE;
                }
        }
}
static void
accept_password_dialog (GtkButton        *button,
                        UmPasswordDialog *um)
{
        GtkTreeModel *model;
        GtkTreeIter iter;
        gint mode;
        const gchar *hint;
        const gchar *password;

        model = gtk_combo_box_get_model (GTK_COMBO_BOX (um->action_combo));
        gtk_combo_box_get_active_iter (GTK_COMBO_BOX (um->action_combo), &iter);
        gtk_tree_model_get (model, &iter, 1, &mode, -1);

        password = gtk_entry_get_text (GTK_ENTRY (um->password_entry));
        hint = gtk_entry_get_text (GTK_ENTRY (um->normal_hint_entry));

        if (mode == 0 && um_user_get_uid (um->user) == getuid ()) {
                GdkDisplay *display;
                GdkCursor *cursor;

                /* When setting a password for the current user,
                 * use passwd directly, to preserve the audit trail
                 * and to e.g. update the keyring password.
                 */
                passwd_change_password (um->passwd_handler, password, (PasswdCallback) password_changed_cb, um);
                gtk_widget_set_sensitive (um->dialog, FALSE);
                display = gtk_widget_get_display (um->dialog);
                cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
                gdk_window_set_cursor (gtk_widget_get_window (um->dialog), cursor);
                gdk_display_flush (display);
                g_object_unref (cursor);
        }
        else {
                um_user_set_password (um->user, mode, password, hint);
                finish_password_change (um);
        }
}
static void
on_permission_changed (GPermission *permission,
                       GParamSpec  *pspec,
                       gpointer     data)
{
    UmUserPanelPrivate *d = data;
    gboolean is_authorized;
    gboolean self_selected;
    UmUser *user;
    GtkWidget *widget;

    user = get_selected_user (d);
    if (!user) {
        return;
    }

    is_authorized = g_permission_get_allowed (G_PERMISSION (d->permission));
    self_selected = um_user_get_uid (user) == geteuid ();

    widget = get_widget (d, "add-user-toolbutton");
    gtk_widget_set_sensitive (widget, is_authorized);
    if (is_authorized) {
        setup_tooltip_with_embedded_icon (widget, _("Create a user account"), NULL, NULL);
    }
    else {
        gchar *names[3];
        GIcon *icon;

        names[0] = "changes-allow-symbolic";
        names[1] = "changes-allow";
        names[2] = NULL;
        icon = (GIcon *)g_themed_icon_new_from_names (names, -1);
        setup_tooltip_with_embedded_icon (widget,
                                          _("To create a user account,\nclick the * icon first"),
                                          "*",
                                          icon);
        g_object_unref (icon);
    }

    widget = get_widget (d, "remove-user-toolbutton");
    gtk_widget_set_sensitive (widget, is_authorized && !self_selected);
    if (is_authorized) {
        setup_tooltip_with_embedded_icon (widget, _("Delete the selected user account"), NULL, NULL);
    }
    else {
        gchar *names[3];
        GIcon *icon;

        names[0] = "changes-allow-symbolic";
        names[1] = "changes-allow";
        names[2] = NULL;
        icon = (GIcon *)g_themed_icon_new_from_names (names, -1);

        setup_tooltip_with_embedded_icon (widget,
                                          _("To delete the selected user account,\nclick the * icon first"),
                                          "*",
                                          icon);
        g_object_unref (icon);
    }

    if (!um_user_is_local_account (user)) {
        um_editable_combo_set_editable (UM_EDITABLE_COMBO (get_widget (d, "account-type-combo")), FALSE);
        remove_unlock_tooltip (get_widget (d, "account-type-combo"));

    } else if (is_authorized && um_user_is_local_account (user)) {
        um_editable_combo_set_editable (UM_EDITABLE_COMBO (get_widget (d, "account-type-combo")), TRUE);
        remove_unlock_tooltip (get_widget (d, "account-type-combo"));
    }
    else {
        um_editable_combo_set_editable (UM_EDITABLE_COMBO (get_widget (d, "account-type-combo")), FALSE);
        add_unlock_tooltip (get_widget (d, "account-type-combo"));
    }

    /* The full name entry: insensitive if remote or not authorized and not self */
    widget = get_widget (d, "full-name-entry");
    if (!um_user_is_local_account (user)) {
        cc_editable_entry_set_editable (CC_EDITABLE_ENTRY (widget), FALSE);
        remove_unlock_tooltip (widget);

    } else if (is_authorized || self_selected) {
        cc_editable_entry_set_editable (CC_EDITABLE_ENTRY (widget), TRUE);
        remove_unlock_tooltip (widget);

    } else {
        cc_editable_entry_set_editable (CC_EDITABLE_ENTRY (widget), FALSE);
        add_unlock_tooltip (widget);
    }

    if (is_authorized || self_selected) {
        gtk_widget_show (get_widget (d, "user-icon-button"));
        gtk_widget_hide (get_widget (d, "user-icon-nonbutton"));

        um_editable_combo_set_editable (UM_EDITABLE_COMBO (get_widget (d, "account-language-combo")), TRUE);
        remove_unlock_tooltip (get_widget (d, "account-language-combo"));

        um_editable_button_set_editable (UM_EDITABLE_BUTTON (get_widget (d, "account-password-button")), TRUE);
        remove_unlock_tooltip (get_widget (d, "account-password-button"));

        gtk_notebook_set_current_page (GTK_NOTEBOOK (get_widget (d, "account-fingerprint-notebook")), 1);
    }
    else {
        gtk_widget_hide (get_widget (d, "user-icon-button"));
        gtk_widget_show (get_widget (d, "user-icon-nonbutton"));

        um_editable_combo_set_editable (UM_EDITABLE_COMBO (get_widget (d, "account-language-combo")), FALSE);
        add_unlock_tooltip (get_widget (d, "account-language-combo"));

        um_editable_button_set_editable (UM_EDITABLE_BUTTON (get_widget (d, "account-password-button")), FALSE);
        add_unlock_tooltip (get_widget (d, "account-password-button"));

        gtk_notebook_set_current_page (GTK_NOTEBOOK (get_widget (d, "account-fingerprint-notebook")), 0);
    }

    um_password_dialog_set_privileged (d->password_dialog, is_authorized);

    g_object_unref (user);
}
static void
delete_user (GtkButton *button, UmUserPanelPrivate *d)
{
    UmUser *user;
    GtkWidget *dialog;

    user = get_selected_user (d);
    if (user == NULL) {
        return;
    }
    else if (um_user_get_uid (user) == getuid ()) {
        dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (d->main_box)),
                                         0,
                                         GTK_MESSAGE_INFO,
                                         GTK_BUTTONS_CLOSE,
                                         _("You cannot delete your own account."));
        g_signal_connect (dialog, "response",
                          G_CALLBACK (gtk_widget_destroy), NULL);
    }
    else if (um_user_is_logged_in (user)) {
        dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (d->main_box)),
                                         0,
                                         GTK_MESSAGE_INFO,
                                         GTK_BUTTONS_CLOSE,
                                         _("%s is still logged in"),
                                         um_user_get_real_name (user));

        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
                _("Deleting a user while they are logged in can leave the system in an inconsistent state."));
        g_signal_connect (dialog, "response",
                          G_CALLBACK (gtk_widget_destroy), NULL);
    }
    else {
        dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (d->main_box)),
                                         0,
                                         GTK_MESSAGE_QUESTION,
                                         GTK_BUTTONS_NONE,
                                         _("Do you want to keep %s's files?"),
                                         um_user_get_real_name (user));

        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
                _("It is possible to keep the home directory, mail spool and temporary files around when deleting a user account."));

        gtk_dialog_add_buttons (GTK_DIALOG (dialog),
                                _("_Delete Files"), GTK_RESPONSE_NO,
                                _("_Keep Files"), GTK_RESPONSE_YES,
                                _("_Cancel"), GTK_RESPONSE_CANCEL,
                                NULL);

        gtk_window_set_icon_name (GTK_WINDOW (dialog), "system-users");

        g_signal_connect (dialog, "response",
                          G_CALLBACK (delete_user_response), d);
    }

    g_signal_connect (dialog, "close",
                      G_CALLBACK (gtk_widget_destroy), NULL);

    gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);

    gtk_window_present (GTK_WINDOW (dialog));

    g_object_unref (user);
}
示例#13
0
static void
show_user (UmUser *user, UmUserPanelPrivate *d)
{
        GtkWidget *image;
        GtkWidget *label;
        GtkWidget *label2;
        GtkWidget *label3;
        GdkPixbuf *pixbuf;
        gchar *lang;
        GtkWidget *widget;
        GtkTreeModel *model;
        GtkTreeIter iter;

        pixbuf = um_user_render_icon (user, FALSE, 48);
        image = get_widget (d, "user-icon-image");
        gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
        image = get_widget (d, "user-icon-image2");
        gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
        g_object_unref (pixbuf);

        um_photo_dialog_set_user (d->photo_dialog, user);

        widget = get_widget (d, "full-name-entry");
        cc_editable_entry_set_text (CC_EDITABLE_ENTRY (widget), um_user_get_real_name (user));
        gtk_widget_set_tooltip_text (widget, um_user_get_user_name (user));

        widget = get_widget (d, "account-type-combo");
        um_editable_combo_set_active (UM_EDITABLE_COMBO (widget), um_user_get_account_type (user));

        widget = get_widget (d, "account-password-button");
        um_editable_button_set_text (UM_EDITABLE_BUTTON (widget), get_password_mode_text (user));

        widget = get_widget (d, "autologin-switch");
        g_signal_handlers_block_by_func (widget, autologin_changed, d);
        gtk_switch_set_active (GTK_SWITCH (widget), um_user_get_automatic_login (user));
        g_signal_handlers_unblock_by_func (widget, autologin_changed, d);

        gtk_widget_set_sensitive (widget, !um_user_get_locked (user));

        widget = get_widget (d, "account-language-combo");
        model = um_editable_combo_get_model (UM_EDITABLE_COMBO (widget));
        cc_add_user_languages (model);

        lang = g_strdup (um_user_get_language (user));
        if (!lang)
                lang = cc_common_language_get_current_language ();
        cc_common_language_get_iter_for_language (model, lang, &iter);
        um_editable_combo_set_active_iter (UM_EDITABLE_COMBO (widget), &iter);
        g_free (lang);

        widget = get_widget (d, "account-fingerprint-notebook");
        label = get_widget (d, "account-fingerprint-label");
        label2 = get_widget (d, "account-fingerprint-value-label");
        label3 = get_widget (d, "account-fingerprint-button-label");
        if (um_user_get_uid (user) != getuid() ||
            !set_fingerprint_label (label2, label3)) {
                gtk_widget_hide (label);
                gtk_widget_hide (widget);
        } else {
                gtk_widget_show (label);
                gtk_widget_show (widget);
        }
}