malcontent/malcontent-control/application.c

376 lines
12 KiB
C

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
*
* Copyright © 2019 Endless Mobile, 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/>.
*
* Authors:
* - Philip Withnall <withnall@endlessm.com>
*/
#include "config.h"
#include <act/act.h>
#include <glib.h>
#include <glib-object.h>
#include <glib/gi18n-lib.h>
#include <gio/gio.h>
#include <gtk/gtk.h>
#include <libmalcontent-ui/malcontent-ui.h>
#include <polkit/polkit.h>
#include "application.h"
#include "user-selector.h"
static void user_selector_notify_user_cb (GObject *obj,
GParamSpec *pspec,
gpointer user_data);
static void user_manager_notify_is_loaded_cb (GObject *obj,
GParamSpec *pspec,
gpointer user_data);
static void permission_new_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data);
static void permission_notify_allowed_cb (GObject *obj,
GParamSpec *pspec,
gpointer user_data);
static void user_accounts_panel_button_clicked_cb (GtkButton *button,
gpointer user_data);
/**
* MctApplication:
*
* #MctApplication is a top-level object representing the parental controls
* application.
*
* Since: 0.5.0
*/
struct _MctApplication
{
GtkApplication parent_instance;
GCancellable *cancellable; /* (owned) */
GDBusConnection *dbus_connection; /* (owned) */
ActUserManager *user_manager; /* (owned) */
GPermission *permission; /* (owned) */
GError *permission_error; /* (nullable) (owned) */
MctUserSelector *user_selector;
MctUserControls *user_controls;
GtkStack *main_stack;
GtkLabel *error_title;
GtkLabel *error_message;
GtkLockButton *lock_button;
GtkButton *user_accounts_panel_button;
};
G_DEFINE_TYPE (MctApplication, mct_application, GTK_TYPE_APPLICATION)
static void
mct_application_init (MctApplication *self)
{
self->cancellable = g_cancellable_new ();
}
static void
mct_application_constructed (GObject *object)
{
GApplication *application = G_APPLICATION (object);
g_application_set_application_id (application, "org.freedesktop.MalcontentControl");
/* Localisation */
bindtextdomain ("malcontent", PACKAGE_LOCALE_DIR);
bind_textdomain_codeset ("malcontent", "UTF-8");
textdomain ("malcontent");
g_set_application_name (_("Parental Controls"));
gtk_window_set_default_icon_name ("org.freedesktop.MalcontentControl");
G_OBJECT_CLASS (mct_application_parent_class)->constructed (object);
}
static void
mct_application_dispose (GObject *object)
{
MctApplication *self = MCT_APPLICATION (object);
g_cancellable_cancel (self->cancellable);
if (self->user_manager != NULL)
{
g_signal_handlers_disconnect_by_func (self->user_manager,
user_manager_notify_is_loaded_cb, self);
g_clear_object (&self->user_manager);
}
if (self->permission != NULL)
{
g_signal_handlers_disconnect_by_func (self->permission,
permission_notify_allowed_cb, self);
g_clear_object (&self->permission);
}
g_clear_object (&self->dbus_connection);
g_clear_error (&self->permission_error);
g_clear_object (&self->cancellable);
G_OBJECT_CLASS (mct_application_parent_class)->dispose (object);
}
static GtkWindow *
mct_application_get_main_window (MctApplication *self)
{
return gtk_application_get_active_window (GTK_APPLICATION (self));
}
static void
mct_application_activate (GApplication *application)
{
MctApplication *self = MCT_APPLICATION (application);
GtkWindow *window = NULL;
window = mct_application_get_main_window (self);
if (window == NULL)
{
g_autoptr(GtkBuilder) builder = NULL;
g_autoptr(GError) local_error = NULL;
/* Ensure the types used in the UI are registered. */
g_type_ensure (MCT_TYPE_USER_CONTROLS);
g_type_ensure (MCT_TYPE_USER_SELECTOR);
/* Start loading the permission */
polkit_permission_new ("org.freedesktop.MalcontentControl.administration",
NULL, self->cancellable,
permission_new_cb, self);
builder = gtk_builder_new ();
g_assert (self->dbus_connection == NULL);
self->dbus_connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, self->cancellable, &local_error);
if (self->dbus_connection == NULL)
{
g_error ("Error getting system bus: %s", local_error->message);
return;
}
g_assert (self->user_manager == NULL);
self->user_manager = g_object_ref (act_user_manager_get_default ());
gtk_builder_set_translation_domain (builder, "malcontent");
gtk_builder_expose_object (builder, "user_manager", G_OBJECT (self->user_manager));
gtk_builder_expose_object (builder, "dbus_connection", G_OBJECT (self->dbus_connection));
gtk_builder_add_from_resource (builder, "/org/freedesktop/MalcontentControl/ui/main.ui", &local_error);
g_assert (local_error == NULL);
/* Set up the main window. */
window = GTK_WINDOW (gtk_builder_get_object (builder, "main_window"));
gtk_window_set_application (window, GTK_APPLICATION (application));
self->main_stack = GTK_STACK (gtk_builder_get_object (builder, "main_stack"));
self->user_selector = MCT_USER_SELECTOR (gtk_builder_get_object (builder, "user_selector"));
self->user_controls = MCT_USER_CONTROLS (gtk_builder_get_object (builder, "user_controls"));
self->error_title = GTK_LABEL (gtk_builder_get_object (builder, "error_title"));
self->error_message = GTK_LABEL (gtk_builder_get_object (builder, "error_message"));
self->lock_button = GTK_LOCK_BUTTON (gtk_builder_get_object (builder, "lock_button"));
self->user_accounts_panel_button = GTK_BUTTON (gtk_builder_get_object (builder, "user_accounts_panel_button"));
/* Connect signals. */
g_signal_connect_object (self->user_selector, "notify::user",
G_CALLBACK (user_selector_notify_user_cb),
self, 0 /* flags */);
g_signal_connect_object (self->user_accounts_panel_button, "clicked",
G_CALLBACK (user_accounts_panel_button_clicked_cb),
self, 0 /* flags */);
g_signal_connect (self->user_manager, "notify::is-loaded",
G_CALLBACK (user_manager_notify_is_loaded_cb), self);
/* Work out whether to show the loading page or the main page, and show
* the controls for the initially selected user. */
user_selector_notify_user_cb (G_OBJECT (self->user_selector), NULL, self);
user_manager_notify_is_loaded_cb (G_OBJECT (self->user_manager), NULL, self);
gtk_widget_show (GTK_WIDGET (window));
}
/* Bring the window to the front. */
gtk_window_present (window);
}
static void
mct_application_class_init (MctApplicationClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GApplicationClass *application_class = G_APPLICATION_CLASS (klass);
object_class->constructed = mct_application_constructed;
object_class->dispose = mct_application_dispose;
application_class->activate = mct_application_activate;
}
static void
update_main_stack (MctApplication *self)
{
gboolean is_user_manager_loaded, is_permission_loaded, has_permission;
const gchar *new_page_name, *old_page_name;
GtkWidget *new_focus_widget;
ActUser *selected_user;
/* The implementation of #ActUserManager guarantees that once is-loaded is
* true, it is never reset to false. */
g_object_get (self->user_manager, "is-loaded", &is_user_manager_loaded, NULL);
is_permission_loaded = (self->permission != NULL || self->permission_error != NULL);
has_permission = (self->permission != NULL && g_permission_get_allowed (self->permission));
selected_user = mct_user_selector_get_user (self->user_selector);
/* Handle any loading errors (including those from getting the permission). */
if ((is_user_manager_loaded && act_user_manager_no_service (self->user_manager)) ||
self->permission_error != NULL)
{
gtk_label_set_label (self->error_title,
_("Failed to load user data from the system"));
gtk_label_set_label (self->error_message,
_("Please make sure that the AccountsService is installed and enabled."));
new_page_name = "error";
new_focus_widget = NULL;
}
else if (is_user_manager_loaded && selected_user == NULL)
{
new_page_name = "no-other-users";
new_focus_widget = GTK_WIDGET (self->user_accounts_panel_button);
}
else if (is_permission_loaded && !has_permission)
{
gtk_lock_button_set_permission (self->lock_button, self->permission);
mct_user_controls_set_permission (self->user_controls, self->permission);
new_page_name = "unlock";
new_focus_widget = GTK_WIDGET (self->lock_button);
}
else if (is_permission_loaded && is_user_manager_loaded)
{
mct_user_controls_set_user (self->user_controls, selected_user);
new_page_name = "controls";
new_focus_widget = GTK_WIDGET (self->user_selector);
}
else
{
new_page_name = "loading";
new_focus_widget = NULL;
}
old_page_name = gtk_stack_get_visible_child_name (self->main_stack);
gtk_stack_set_visible_child_name (self->main_stack, new_page_name);
if (new_focus_widget != NULL && !g_str_equal (old_page_name, new_page_name))
gtk_widget_grab_focus (new_focus_widget);
}
static void
user_selector_notify_user_cb (GObject *obj,
GParamSpec *pspec,
gpointer user_data)
{
MctApplication *self = MCT_APPLICATION (user_data);
update_main_stack (self);
}
static void
user_manager_notify_is_loaded_cb (GObject *obj,
GParamSpec *pspec,
gpointer user_data)
{
MctApplication *self = MCT_APPLICATION (user_data);
update_main_stack (self);
}
static void
permission_new_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
MctApplication *self = MCT_APPLICATION (user_data);
g_autoptr(GPermission) permission = NULL;
g_autoptr(GError) local_error = NULL;
permission = polkit_permission_new_finish (result, &local_error);
if (permission == NULL)
{
g_assert (self->permission_error == NULL);
self->permission_error = g_steal_pointer (&local_error);
g_debug ("Error getting permission: %s", self->permission_error->message);
}
else
{
g_assert (self->permission == NULL);
self->permission = g_steal_pointer (&permission);
g_signal_connect (self->permission, "notify::allowed",
G_CALLBACK (permission_notify_allowed_cb), self);
}
/* Recalculate the UI. */
update_main_stack (self);
}
static void
permission_notify_allowed_cb (GObject *obj,
GParamSpec *pspec,
gpointer user_data)
{
MctApplication *self = MCT_APPLICATION (user_data);
update_main_stack (self);
}
static void
user_accounts_panel_button_clicked_cb (GtkButton *button,
gpointer user_data)
{
g_autoptr(GError) local_error = NULL;
if (!g_spawn_command_line_async ("gnome-control-center user-accounts", &local_error))
{
g_warning ("Error opening GNOME Control Center: %s",
local_error->message);
return;
}
}
/**
* mct_application_new:
*
* Create a new #MctApplication.
*
* Returns: (transfer full): a new #MctApplication
* Since: 0.5.0
*/
MctApplication *
mct_application_new (void)
{
return g_object_new (MCT_TYPE_APPLICATION, NULL);
}