/*
* Copyright (C) 2010 Stefan Walter
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gcr/gcr-icons.h"
#include "gcr/gcr-parser.h"
#include "gcr-display-view.h"
#include "gcr-secure-entry-buffer.h"
#include "gcr-unlock-renderer.h"
#include <gdk/gdk.h>
#include <glib/gi18n-lib.h>
enum {
PROP_0,
PROP_LABEL,
PROP_ATTRIBUTES
};
struct _GcrUnlockRendererPrivate {
GtkEntry *entry;
GtkLabel *warning;
GBytes *locked_data;
gchar *label;
gboolean unlocked;
GList *renderers;
guint unlock_tries;
/* block widget destroys during render */
gint no_destroy;
};
enum {
UNLOCK_CLICKED,
LAST_SIGNAL,
};
static guint signals[LAST_SIGNAL] = { 0 };
static void gcr_renderer_iface_init (GcrRendererIface *iface);
G_DEFINE_TYPE_WITH_CODE (GcrUnlockRenderer, _gcr_unlock_renderer, GTK_TYPE_BIN,
G_IMPLEMENT_INTERFACE (GCR_TYPE_RENDERER, gcr_renderer_iface_init);
);
static gchar*
calculate_label (GcrUnlockRenderer *self)
{
if (self->pv->label)
return g_strdup_printf (_("Unlock: %s"), self->pv->label);
return g_strdup (_("Unlock"));
}
void
_gcr_unlock_renderer_show_warning (GcrUnlockRenderer *self,
const gchar *message)
{
gchar *text;
g_return_if_fail (GCR_UNLOCK_RENDERER (self));
g_return_if_fail (message != NULL);
text = g_strdup_printf ("<i>%s</i>", message);
gtk_label_set_markup (self->pv->warning, text);
g_free (text);
gtk_widget_show (GTK_WIDGET (self->pv->warning));
}
static void
on_unlock_button_clicked (GtkButton *button,
gpointer user_data)
{
GcrUnlockRenderer *self = GCR_UNLOCK_RENDERER (user_data);
g_signal_emit (self, signals[UNLOCK_CLICKED], 0);
}
static void
on_entry_activated (GtkEntry *entry,
gpointer user_data)
{
GtkButton *button = GTK_BUTTON (user_data);
gtk_button_clicked (button);
}
static void
_gcr_unlock_renderer_init (GcrUnlockRenderer *self)
{
GtkWidget *box, *vbox;
GtkWidget *button;
GtkEntryBuffer *buffer;
self->pv = (G_TYPE_INSTANCE_GET_PRIVATE (self, GCR_TYPE_UNLOCK_RENDERER,
GcrUnlockRendererPrivate));
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
buffer = gcr_secure_entry_buffer_new ();
self->pv->entry = GTK_ENTRY (gtk_entry_new_with_buffer (buffer));
gtk_entry_set_visibility (self->pv->entry, FALSE);
gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (self->pv->entry), TRUE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (self->pv->entry));
g_object_unref (buffer);
gtk_entry_set_placeholder_text (self->pv->entry, _("Password"));
button = gtk_button_new_with_label (_("Unlock"));
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked", G_CALLBACK (on_unlock_button_clicked), self);
g_signal_connect (self->pv->entry, "activate", G_CALLBACK (on_entry_activated), button);
gtk_widget_show (button);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0);
gtk_widget_show (box);
self->pv->warning = GTK_LABEL (gtk_label_new (""));
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (self->pv->warning), FALSE, FALSE, 0);
gtk_widget_hide (GTK_WIDGET (self->pv->warning));
gtk_container_add (GTK_CONTAINER (self), vbox);
gtk_widget_show (vbox);
}
static void
_gcr_unlock_renderer_finalize (GObject *obj)
{
GcrUnlockRenderer *self = GCR_UNLOCK_RENDERER (obj);
g_bytes_unref (self->pv->locked_data);
g_free (self->pv->label);
g_list_free_full (self->pv->renderers, g_object_unref);
G_OBJECT_CLASS (_gcr_unlock_renderer_parent_class)->finalize (obj);
}
static void
_gcr_unlock_renderer_set_property (GObject *obj,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GcrUnlockRenderer *self = GCR_UNLOCK_RENDERER (obj);
switch (prop_id) {
case PROP_LABEL:
g_free (self->pv->label);
self->pv->label = g_value_dup_string (value);
g_object_notify (obj, "label");
gcr_renderer_emit_data_changed (GCR_RENDERER (self));
break;
case PROP_ATTRIBUTES:
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
_gcr_unlock_renderer_get_property (GObject *obj,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GcrUnlockRenderer *self = GCR_UNLOCK_RENDERER (obj);
switch (prop_id) {
case PROP_LABEL:
g_value_take_string (value, calculate_label (self));
break;
case PROP_ATTRIBUTES:
g_value_set_boxed (value, NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
_gcr_unlock_renderer_class_init (GcrUnlockRendererClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GcrUnlockRendererPrivate));
gobject_class->finalize = _gcr_unlock_renderer_finalize;
gobject_class->set_property = _gcr_unlock_renderer_set_property;
gobject_class->get_property = _gcr_unlock_renderer_get_property;
g_object_class_install_property (gobject_class, PROP_LABEL,
g_param_spec_string ("label", "Label", "Unlock Label",
"", G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_ATTRIBUTES,
g_param_spec_boxed ("attributes", "Attributes", "Certificate pkcs11 attributes",
GCK_TYPE_ATTRIBUTES, G_PARAM_READWRITE));
signals[UNLOCK_CLICKED] = g_signal_new ("unlock-clicked", GCR_TYPE_UNLOCK_RENDERER, G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GcrUnlockRendererClass, unlock_clicked),
NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
}
static void
gcr_unlock_renderer_render (GcrRenderer *renderer,
GcrViewer *viewer)
{
GcrUnlockRenderer *self = GCR_UNLOCK_RENDERER (renderer);
GcrDisplayView *view;
gchar *display;
GList *renderers;
GIcon *icon;
GList *l;
if (GCR_IS_DISPLAY_VIEW (viewer)) {
view = GCR_DISPLAY_VIEW (viewer);
} else {
g_warning ("GcrUnlockRenderer only works with internal specific "
"GcrViewer returned by gcr_viewer_new().");
return;
}
/*
* If we were successfully unlocked, then this will contain a list of
* renderers to add to the viewer.
*/
if (self->pv->unlocked) {
/* We used prepend above, so list is backwards */
renderers = g_list_reverse (self->pv->renderers);
self->pv->renderers = NULL;
for (l = renderers; l != NULL; l = g_list_next (l))
gcr_viewer_insert_renderer (viewer, l->data, renderer);
g_list_free_full (renderers, g_object_unref);
/* And finally remove ourselves from the viewer */
gcr_viewer_remove_renderer (viewer, GCR_RENDERER (self));
/*
* Not yet unlocked, display the unlock dialog.
*/
} else {
_gcr_display_view_begin (view, renderer);
icon = g_themed_icon_new ("emblem-readonly");
_gcr_display_view_set_icon (view, renderer, icon);
g_object_unref (icon);
display = calculate_label (self);
_gcr_display_view_append_title (view, renderer, display);
g_free (display);
if (self->pv->label)
display = g_strdup_printf (_("The contents of “%s” are locked. In order to view the contents, enter the correct password."),
self->pv->label);
else
display = g_strdup (_("The contents are locked. In order to view the contents, enter the correct password."));
_gcr_display_view_append_content (view, renderer, display, NULL);
g_free (display);
_gcr_display_view_add_widget_area (view, renderer, GTK_WIDGET (self));
gtk_widget_show (GTK_WIDGET (self));
_gcr_display_view_end (view, renderer);
}
}
static void
gcr_renderer_iface_init (GcrRendererIface *iface)
{
iface->render_view = gcr_unlock_renderer_render;
}
GcrUnlockRenderer*
_gcr_unlock_renderer_new (const gchar *label,
GBytes *locked_data)
{
GcrUnlockRenderer *renderer;
renderer = g_object_new (GCR_TYPE_UNLOCK_RENDERER,
"label", label,
NULL);
g_object_ref_sink (renderer);
renderer->pv->locked_data = g_bytes_ref (locked_data);
return renderer;
}
GcrUnlockRenderer *
_gcr_unlock_renderer_new_for_parsed (GcrParser *parser)
{
g_return_val_if_fail (GCR_IS_PARSER (parser), NULL);
return _gcr_unlock_renderer_new (gcr_parser_get_parsed_label (parser),
gcr_parser_get_parsed_bytes (parser));
}
const gchar *
_gcr_unlock_renderer_get_password (GcrUnlockRenderer *self)
{
g_return_val_if_fail (GCR_IS_UNLOCK_RENDERER (self), NULL);
return gtk_entry_get_text (self->pv->entry);
}
void
_gcr_unlock_renderer_set_password (GcrUnlockRenderer *self,
const gchar *text)
{
g_return_if_fail (GCR_IS_UNLOCK_RENDERER (self));
g_return_if_fail (text != NULL);
gtk_entry_set_text (self->pv->entry, text);
}
void
_gcr_unlock_renderer_focus_password (GcrUnlockRenderer *self)
{
g_return_if_fail (GCR_IS_UNLOCK_RENDERER (self));
gtk_widget_grab_focus (GTK_WIDGET (self->pv->entry));
}
GBytes *
_gcr_unlock_renderer_get_locked_data (GcrUnlockRenderer *self)
{
g_return_val_if_fail (GCR_IS_UNLOCK_RENDERER (self), NULL);
return self->pv->locked_data;
}