diff options
Diffstat (limited to 'src')
32 files changed, 8832 insertions, 0 deletions
diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..b890ee0 --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,76 @@ +# -*- Mode: Automake; indent-tabs-mode: t; tab-width: 4 -*- + +sbin_PROGRAMS = unity-greeter +noinst_PROGRAMS = logo-generator + +unity_greeter_SOURCES = \ + config.vapi \ + fixes.vapi \ + indicator.vapi \ + animate-timer.vala \ + background.vala \ + cached-image.vala \ + cairo-utils.vala \ + email-autocompleter.vala \ + dash-box.vala \ + dash-button.vala \ + dash-entry.vala \ + fadable.vala \ + fadable-box.vala \ + fading-label.vala \ + flat-button.vala \ + greeter-list.vala \ + list-stack.vala \ + main-window.vala \ + menu.vala \ + menubar.vala \ + prompt-box.vala \ + session-list.vala \ + remote-login-service.vala \ + settings.vala \ + settings-daemon.vala \ + shutdown-dialog.vala \ + toggle-box.vala \ + unity-greeter.vala \ + user-list.vala \ + user-prompt-box.vala + +logo_generator_SOURCES = logo-generator.vala + +unity_greeter_CFLAGS = \ + $(UNITY_GREETER_CFLAGS) \ + -w \ + -DGNOME_DESKTOP_USE_UNSTABLE_API \ + -DGETTEXT_PACKAGE=\"$(GETTEXT_PACKAGE)\" \ + -DLOCALEDIR=\""$(localedir)"\" \ + -DVERSION=\"$(VERSION)\" \ + -DCONFIG_FILE=\""$(sysconfdir)/lightdm/unity-greeter.conf"\" \ + -DPKGDATADIR=\""$(pkgdatadir)"\" \ + -DINDICATORDIR=\""$(INDICATORDIR)"\" + +logo_generator_CFLAGS = $(unity_greeter_CFLAGS) + +unity_greeter_VALAFLAGS = \ + --pkg posix \ + --pkg gtk+-3.0 \ + --pkg gdk-x11-3.0 \ + --pkg gio-unix-2.0 \ + --pkg x11 \ + --pkg liblightdm-gobject-1 \ + --pkg libcanberra \ + --pkg gio-2.0 \ + --pkg pixman-1 \ + --target-glib 2.32 + +logo_generator_VALAFLAGS = $(unity_greeter_VALAFLAGS) + +unity_greeter_LDADD = \ + $(UNITY_GREETER_LIBS) \ + -lm + +logo_generator_LDADD = $(unity_greeter_LDADD) + +unity_greeter_vala.stamp: $(top_srcdir)/config.h + +DISTCLEANFILES = \ + Makefile.in diff --git a/src/animate-timer.vala b/src/animate-timer.vala new file mode 100644 index 0000000..d5aaf71 --- /dev/null +++ b/src/animate-timer.vala @@ -0,0 +1,154 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +private class AnimateTimer : Object +{ + /* x and y are 0.0 to 1.0 */ + public delegate double EasingFunc (double x); + + /* The following are the same intervals that Unity uses */ + public static const int INSTANT = 150; /* Good for animations that don't convey any information */ + public static const int FAST = 250; /* Good for animations that convey duplicated information */ + public static const int NORMAL = 500; + public static const int SLOW = 1000; /* Good for animations that convey information that is only presented in the animation */ + + /* speed is in milliseconds */ + public unowned EasingFunc easing_func { get; private set; } + public int speed { get; set; } + public bool is_running { get { return timeout != 0; } } + public double progress { get; private set; } + + /* progress is from 0.0 to 1.0 */ + public signal void animate (double progress); + + /* AnimateTimer requires two things: an easing function and a speed. + + The speed is just the duration of the animation in milliseconds. + + The easing function describes how fast the animation occurs at different + parts of the duration. + + See http://hosted.zeh.com.br/tweener/docs/en-us/misc/transitions.html + for examples of various easing functions. + + A few are provided with this class, notably ease_in_out and + ease_out_quint. + */ + /* speed is in milliseconds */ + public AnimateTimer (EasingFunc func, int speed) + { + Object (speed: speed); + this.easing_func = func; + } + + ~AnimateTimer () + { + stop (); + } + + /* temp_speed is in milliseconds */ + public void reset (int temp_speed = -1) + { + stop (); + + timeout = Timeout.add (16, animate_cb); + progress = 0; + start_time = 0; + extra_time = 0; + extra_progress = 0; + + if (temp_speed == -1) + temp_speed = speed; + + length = temp_speed * TimeSpan.MILLISECOND; + } + + public void stop () + { + if (timeout != 0) + Source.remove (timeout); + timeout = 0; + } + + private uint timeout = 0; + private TimeSpan start_time = 0; + private TimeSpan length = 0; + private TimeSpan extra_time = 0; + private double extra_progress = 0.0; + + private bool animate_cb () + { + if (start_time == 0) + start_time = GLib.get_monotonic_time (); + + var time_progress = normalize_time (GLib.get_monotonic_time ()); + progress = calculate_progress (time_progress); + animate (progress); + + if (time_progress >= 1.0) + { + timeout = 0; + return false; + } + else + return true; + } + + /* Returns 0.0 to 1.0 where 1.0 is at or past end_time */ + private double normalize_time (TimeSpan now) + { + if (length == 0) + return 1.0f; + + return (((double)(now - start_time)) / length).clamp (0.0, 1.0); + } + + /* Returns 0.0 to 1.0 where 1.0 is done. + time is not normalized yet! */ + private double calculate_progress (double time_progress) + { + var y = easing_func (time_progress); + return y.clamp (0.0, 1.0); + } + + public static double ease_in_out (double x) + { + return (1 - Math.cos (Math.PI * x)) / 2; + } + + /*public static double ease_in_quad (double x) + { + return Math.pow (x, 2); + }*/ + /*public static double ease_out_quad (double x) + { + return -1 * Math.pow (x - 1, 2) + 1; + }*/ + + /*public static double ease_in_quint (double x) + { + return Math.pow (x, 5); + }*/ + public static double ease_out_quint (double x) + { + return Math.pow (x - 1, 5) + 1; + } +} + diff --git a/src/background.vala b/src/background.vala new file mode 100644 index 0000000..a1c28e9 --- /dev/null +++ b/src/background.vala @@ -0,0 +1,705 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +class BackgroundLoader : Object +{ + public string filename { get; private set; } + public Cairo.Surface logo { get; set; } + + public int[] widths; + public int[] heights; + public Cairo.Pattern[] patterns; + public Gdk.RGBA average_color; + + private Cairo.Surface target_surface; + private bool draw_grid; + private Thread<void*> thread; + private Gdk.Pixbuf[] images; + private bool finished; + private uint ready_id; + + public signal void loaded (); + + public BackgroundLoader (Cairo.Surface target_surface, string filename, int[] widths, int[] heights, bool draw_grid) + { + this.target_surface = target_surface; + this.filename = filename; + this.widths = widths; + this.heights = heights; + patterns = new Cairo.Pattern[widths.length]; + images = new Gdk.Pixbuf[widths.length]; + this.draw_grid = draw_grid; + } + + public bool load () + { + /* Already loaded */ + if (finished) + return true; + + /* Currently loading */ + if (thread != null) + return false; + + /* No monitor data */ + if (widths.length == 0) + return false; + + var text = "Making background %s at %dx%d".printf (filename, widths[0], heights[0]); + for (var i = 1; i < widths.length; i++) + text += ",%dx%d".printf (widths[i], heights[i]); + debug (text); + + var color = Gdk.RGBA (); + if (color.parse (filename)) + { + var pattern = new Cairo.Pattern.rgba (color.red, color.green, color.blue, color.alpha); + for (var i = 0; i < widths.length; i++) + patterns[i] = pattern; + + average_color = color; + finished = true; + debug ("Render of background %s complete", filename); + return true; + } + else + { + try + { + this.ref (); + thread = new Thread<void*>.try ("background-loader", load_and_scale); + } + catch (Error e) + { + this.unref (); + finished = true; + return true; + } + } + + return false; + } + + public Cairo.Pattern? get_pattern (int width, int height) + { + for (var i = 0; i < widths.length; i++) + { + if (widths[i] == width && heights[i] == height) + return patterns[i]; + } + return null; + } + + ~BackgroundLoader () + { + if (ready_id > 0) + Source.remove (ready_id); + ready_id = 0; + } + + private bool ready_cb () + { + ready_id = 0; + + debug ("Render of background %s complete", filename); + + thread.join (); + thread = null; + finished = true; + + for (var i = 0; i < widths.length; i++) + { + if (images[i] != null) + { + patterns[i] = create_pattern (images[i]); + if (i == 0) + pixbuf_average_value (images[i], out average_color); + images[i] = null; + } + else + { + debug ("images[%d] was null for %s", i, filename); + patterns[i] = null; + } + } + + loaded (); + + this.unref (); + return false; + } + + private void* load_and_scale () + { + try + { + var image = new Gdk.Pixbuf.from_file (filename); + for (var i = 0; i < widths.length; i++) + images[i] = scale (image, widths[i], heights[i]); + } + catch (Error e) + { + debug ("Error loading background: %s", e.message); + } + + ready_id = Gdk.threads_add_idle (ready_cb); + + return null; + } + + private Gdk.Pixbuf? scale (Gdk.Pixbuf? image, int width, int height) + { + var target_aspect = (double) width / height; + var aspect = (double) image.width / image.height; + double scale, offset_x = 0, offset_y = 0; + if (aspect > target_aspect) + { + /* Fit height and trim sides */ + scale = (double) height / image.height; + offset_x = (image.width * scale - width) / 2; + } + else + { + /* Fit width and trim top and bottom */ + scale = (double) width / image.width; + offset_y = (image.height * scale - height) / 2; + } + + var scaled_image = new Gdk.Pixbuf (image.colorspace, image.has_alpha, image.bits_per_sample, width, height); + image.scale (scaled_image, 0, 0, width, height, -offset_x, -offset_y, scale, scale, Gdk.InterpType.BILINEAR); + + return scaled_image; + } + + private Cairo.Pattern? create_pattern (Gdk.Pixbuf image) + { + var grid_x_offset = get_grid_offset (image.width); + var grid_y_offset = get_grid_offset (image.height); + + /* Create background */ + var surface = new Cairo.Surface.similar (target_surface, Cairo.Content.COLOR, image.width, image.height); + var bc = new Cairo.Context (surface); + Gdk.cairo_set_source_pixbuf (bc, image, 0, 0); + + bc.paint (); + + /* Draw logo */ + if (logo != null) + { + bc.save (); + var y = (int) (image.height / grid_size - 2) * grid_size + grid_y_offset; + bc.translate (grid_x_offset, y); + bc.set_source_surface (logo, 0, 0); + bc.paint_with_alpha (0.5); + bc.restore (); + } + + var pattern = new Cairo.Pattern.for_surface (surface); + pattern.set_extend (Cairo.Extend.REPEAT); + + return pattern; + } + + /* The following color averaging algorithm was originally written for + Unity in C++, then patched into gnome-desktop3 in C. I've taken it + and put it here in Vala. It would be nice if we could get + gnome-desktop3 to expose this for our use instead of copying the + code... */ + + static const int QUAD_MAX_LEVEL_OF_RECURSION = 16; + static const int QUAD_MIN_LEVEL_OF_RECURSION = 2; + static const int QUAD_CORNER_WEIGHT_NW = 3; + static const int QUAD_CORNER_WEIGHT_NE = 1; + static const int QUAD_CORNER_WEIGHT_SE = 1; + static const int QUAD_CORNER_WEIGHT_SW = 3; + static const int QUAD_CORNER_WEIGHT_CENTER = 2; + static const int QUAD_CORNER_WEIGHT_TOTAL = (QUAD_CORNER_WEIGHT_NW + QUAD_CORNER_WEIGHT_NE + QUAD_CORNER_WEIGHT_SE + QUAD_CORNER_WEIGHT_SW + QUAD_CORNER_WEIGHT_CENTER); + + /* Pixbuf utilities */ + private Gdk.RGBA get_pixbuf_sample (uint8[] pixels, + int rowstride, + int channels, + int x, + int y) + { + var sample = Gdk.RGBA (); + double dd = 0xFF; + int offset = ((y * rowstride) + (x * channels)); + + sample.red = pixels[offset++] / dd; + sample.green = pixels[offset++] / dd; + sample.blue = pixels[offset++] / dd; + sample.alpha = 1.0f; + + return sample; + } + + private bool is_color_different (Gdk.RGBA color_a, + Gdk.RGBA color_b) + { + var diff = Gdk.RGBA (); + + diff.red = color_a.red - color_b.red; + diff.green = color_a.green - color_b.green; + diff.blue = color_a.blue - color_b.blue; + diff.alpha = 1.0f; + + if (GLib.Math.fabs (diff.red) > 0.15 || + GLib.Math.fabs (diff.green) > 0.15 || + GLib.Math.fabs (diff.blue) > 0.15) + return true; + + return false; + } + + private Gdk.RGBA get_quad_average (int x, + int y, + int width, + int height, + int level_of_recursion, + uint8[] pixels, + int rowstride, + int channels) + { + // samples four corners + // c1-----c2 + // | | + // c3-----c4 + + var average = Gdk.RGBA (); + var corner1 = get_pixbuf_sample (pixels, rowstride, channels, x , y ); + var corner2 = get_pixbuf_sample (pixels, rowstride, channels, x + width, y ); + var corner3 = get_pixbuf_sample (pixels, rowstride, channels, x , y + height); + var corner4 = get_pixbuf_sample (pixels, rowstride, channels, x + width, y + height); + var centre = get_pixbuf_sample (pixels, rowstride, channels, x + (width / 2), y + (height / 2)); + + /* If we're over the max we want to just take the average and be happy + with that value */ + if (level_of_recursion < QUAD_MAX_LEVEL_OF_RECURSION) { + /* Otherwise we want to look at each value and check it's distance + from the center color and take the average if they're far apart. */ + + /* corner 1 */ + if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION || + is_color_different(corner1, centre)) { + corner1 = get_quad_average (x, y, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels); + } + + /* corner 2 */ + if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION || + is_color_different(corner2, centre)) { + corner2 = get_quad_average (x + width/2, y, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels); + } + + /* corner 3 */ + if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION || + is_color_different(corner3, centre)) { + corner3 = get_quad_average (x, y + height/2, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels); + } + + /* corner 4 */ + if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION || + is_color_different(corner4, centre)) { + corner4 = get_quad_average (x + width/2, y + height/2, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels); + } + } + + average.red = ((corner1.red * QUAD_CORNER_WEIGHT_NW) + + (corner3.red * QUAD_CORNER_WEIGHT_SW) + + (centre.red * QUAD_CORNER_WEIGHT_CENTER) + + (corner2.red * QUAD_CORNER_WEIGHT_NE) + + (corner4.red * QUAD_CORNER_WEIGHT_SE)) + / QUAD_CORNER_WEIGHT_TOTAL; + average.green = ((corner1.green * QUAD_CORNER_WEIGHT_NW) + + (corner3.green * QUAD_CORNER_WEIGHT_SW) + + (centre.green * QUAD_CORNER_WEIGHT_CENTER) + + (corner2.green * QUAD_CORNER_WEIGHT_NE) + + (corner4.green * QUAD_CORNER_WEIGHT_SE)) + / QUAD_CORNER_WEIGHT_TOTAL; + average.blue = ((corner1.blue * QUAD_CORNER_WEIGHT_NW) + + (corner3.blue * QUAD_CORNER_WEIGHT_SW) + + (centre.blue * QUAD_CORNER_WEIGHT_CENTER) + + (corner2.blue * QUAD_CORNER_WEIGHT_NE) + + (corner4.blue * QUAD_CORNER_WEIGHT_SE)) + / QUAD_CORNER_WEIGHT_TOTAL; + average.alpha = 1.0f; + + return average; + } + + private void pixbuf_average_value (Gdk.Pixbuf pixbuf, + out Gdk.RGBA result) + { + var average = get_quad_average (0, 0, + pixbuf.get_width () - 1, pixbuf.get_height () - 1, + 1, + pixbuf.get_pixels (), + pixbuf.get_rowstride (), + pixbuf.get_n_channels ()); + + result = Gdk.RGBA (); + result.red = average.red; + result.green = average.green; + result.blue = average.blue; + result.alpha = average.alpha; + } +} + +public class Monitor +{ + public int x; + public int y; + public int width; + public int height; + + public Monitor (int x, int y, int width, int height) + { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + public bool equals (Monitor? other) + { + if (other != null) + return (x == other.x && y == other.y && width == other.width && height == other.height); + + return false; + } +} + +public class Background : Gtk.Fixed +{ + public enum DrawFlags + { + NONE, + GRID, + } + + public string default_background { get; set; default = UGSettings.get_string (UGSettings.KEY_BACKGROUND_COLOR); } + public string? current_background { get; set; default = null; } + public bool draw_grid { get; set; default = true; } + public double alpha { get; private set; default = 1.0; } + public Gdk.RGBA average_color { get { return current.average_color; } } + + private Cairo.Surface target_surface; + + private List<Monitor> monitors = null; + private Monitor? active_monitor = null; + + private AnimateTimer timer; + + private BackgroundLoader current; + private BackgroundLoader old; + + private HashTable<string, BackgroundLoader> loaders; + + private Cairo.Surface? version_logo_surface = null; + private int version_logo_width; + private int version_logo_height; + private Cairo.Surface? background_logo_surface = null; + private int background_logo_width; + private int background_logo_height; + + public Background (Cairo.Surface target_surface) + { + this.target_surface = target_surface; + timer = new AnimateTimer (AnimateTimer.ease_in_out, 700); + timer.animate.connect (animate_cb); + + loaders = new HashTable<string?, BackgroundLoader> (str_hash, str_equal); + + notify["current-background"].connect (() => { reload (); }); + } + + public void set_logo (string version_logo, string background_logo) + { + version_logo_surface = load_image (version_logo, out version_logo_width, out version_logo_height); + background_logo_surface = load_image (background_logo, out background_logo_width, out background_logo_height); + } + + private Cairo.Surface? load_image (string filename, out int width, out int height) + { + width = height = 0; + try + { + var image = new Gdk.Pixbuf.from_file (filename); + width = image.width; + height = image.height; + var surface = new Cairo.Surface.similar (target_surface, Cairo.Content.COLOR_ALPHA, image.width, image.height); + var c = new Cairo.Context (surface); + Gdk.cairo_set_source_pixbuf (c, image, 0, 0); + c.paint (); + return surface; + } + catch (Error e) + { + debug ("Failed to load background component %s: %s", filename, e.message); + } + + return null; + } + + public void set_monitors (List<Monitor> monitors) + { + this.monitors = new List<Monitor> (); + foreach (var m in monitors) + this.monitors.append (m); + queue_draw (); + } + + public void set_active_monitor (Monitor? monitor) + { + active_monitor = monitor; + } + + public override void size_allocate (Gtk.Allocation allocation) + { + var resized = allocation.height != get_allocated_height () || allocation.width != get_allocated_width (); + + base.size_allocate (allocation); + + /* Regenerate backgrounds */ + if (resized) + { + debug ("Regenerating backgrounds"); + loaders.remove_all (); + load_background (null); + reload (); + } + } + + public override bool draw (Cairo.Context c) + { + var flags = DrawFlags.NONE; + if (draw_grid) + flags |= DrawFlags.GRID; + draw_full (c, flags); + return base.draw (c); + } + + public void draw_full (Cairo.Context c, DrawFlags flags) + { + c.save (); + + /* Test whether we ran into an error loading this background */ + if (current == null || (current.load () && current.patterns[0] == null)) + { + /* We couldn't load it, so swap it out for the default background + and remember that choice */ + var new_background = load_background (null); + if (current != null) + loaders.insert (current.filename, new_background); + if (old == current) + old = new_background; + current = new_background; + publish_average_color (); + } + + /* Fade to this background when loaded */ + if (current.load () && current != old && !timer.is_running) + { + alpha = 0.0; + timer.reset (); + } + + c.set_source_rgba (0.0, 0.0, 0.0, 0.0); + var old_painted = false; + + /* Draw old background */ + if (old != null && old.load () && (alpha < 1.0 || !current.load ())) + { + draw_background (c, old, 1.0); + old_painted = true; + } + + /* Draw new background */ + if (current.load () && alpha > 0.0) + draw_background (c, current, old_painted ? alpha : 1.0); + + c.restore (); + + if ((flags & DrawFlags.GRID) != 0) + overlay_grid (c); + } + + private void draw_background (Cairo.Context c, BackgroundLoader background, double alpha) + { + foreach (var monitor in monitors) + { + var pattern = background.get_pattern (monitor.width, monitor.height); + if (pattern == null) + continue; + + c.save (); + pattern = background.get_pattern (monitor.width, monitor.height); + var matrix = Cairo.Matrix.identity (); + matrix.translate (-monitor.x, -monitor.y); + pattern.set_matrix (matrix); + c.set_source (pattern); + c.rectangle (monitor.x, monitor.y, monitor.width, monitor.height); + c.clip (); + c.paint_with_alpha (alpha); + c.restore (); + + if (monitor != active_monitor && background_logo_surface != null) + { + var width = background_logo_width; + var height = background_logo_height; + + c.save (); + pattern = new Cairo.Pattern.for_surface (background_logo_surface); + matrix = Cairo.Matrix.identity (); + var x = monitor.x + (monitor.width - width) / 2; + var y = monitor.y + (monitor.height - height) / 2; + matrix.translate (-x, -y); + pattern.set_matrix (matrix); + c.set_source (pattern); + c.rectangle (x, y, width, height); + c.clip (); + c.paint_with_alpha (alpha); + c.restore (); + } + } + } + + private void animate_cb (double progress) + { + alpha = progress; + queue_draw (); + + /* Stop when we get there */ + if (alpha >= 1.0) + old = current; + } + + private void reload () + { + if (get_realized ()) + { + var new_background = load_background (current_background); + + if (current != new_background) + { + old = current; + current = new_background; + alpha = 1.0; /* if the timer isn't going, we should always be at 1.0 */ + timer.stop (); + } + + queue_draw (); + publish_average_color (); + } + } + + private BackgroundLoader load_background (string? filename) + { + if (filename == null) + filename = default_background; + + var b = loaders.lookup (filename); + if (b == null) + { + /* Load required sizes to draw background */ + var widths = new int[monitors.length ()]; + var heights = new int[monitors.length ()]; + var n_sizes = 0; + foreach (var monitor in monitors) + { + if (monitor_is_unique_size (monitor)) + { + widths[n_sizes] = monitor.width; + heights[n_sizes] = monitor.height; + n_sizes++; + } + } + widths.resize (n_sizes); + heights.resize (n_sizes); + + b = new BackgroundLoader (target_surface, filename, widths, heights, draw_grid); + b.logo = version_logo_surface; + b.loaded.connect (() => { reload (); }); + b.load (); + loaders.insert (filename, b); + } + + return b; + } + + /* Check if a monitor has a unique size */ + private bool monitor_is_unique_size (Monitor monitor) + { + foreach (var m in monitors) + { + if (m == monitor) + break; + else if (m.width == monitor.width && m.height == monitor.height) + return false; + } + + return true; + } + + private void overlay_grid (Cairo.Context c) + { + var width = get_allocated_width (); + var height = get_allocated_height (); + var grid_x_offset = get_grid_offset (width); + var grid_y_offset = get_grid_offset (height); + + /* Overlay grid */ + var overlay_surface = new Cairo.Surface.similar (target_surface, Cairo.Content.COLOR_ALPHA, grid_size, grid_size); + var oc = new Cairo.Context (overlay_surface); + oc.rectangle (0, 0, 1, 1); + oc.rectangle (grid_size - 1, 0, 1, 1); + oc.rectangle (0, grid_size - 1, 1, 1); + oc.rectangle (grid_size - 1, grid_size - 1, 1, 1); + oc.set_source_rgba (1.0, 1.0, 1.0, 0.25); + oc.fill (); + var overlay = new Cairo.Pattern.for_surface (overlay_surface); + var matrix = Cairo.Matrix.identity (); + matrix.translate (-grid_x_offset, -grid_y_offset); + overlay.set_matrix (matrix); + overlay.set_extend (Cairo.Extend.REPEAT); + + /* Draw overlay */ + c.save (); + c.set_source (overlay); + c.rectangle (0, 0, width, height); + c.fill (); + c.restore (); + } + + void publish_average_color () + { + notify_property ("average-color"); + var rgba = current.average_color.to_string (); + var root = get_screen ().get_root_window (); + + Gdk.property_change (root, + Gdk.Atom.intern_static_string ("_GNOME_BACKGROUND_REPRESENTATIVE_COLORS"), + Gdk.Atom.intern_static_string ("STRING"), + 8, + Gdk.PropMode.REPLACE, + rgba.data, + rgba.data.length); + } +} diff --git a/src/cached-image.vala b/src/cached-image.vala new file mode 100644 index 0000000..56157a3 --- /dev/null +++ b/src/cached-image.vala @@ -0,0 +1,59 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +public class CachedImage : Gtk.Image +{ + private static HashTable<Gdk.Pixbuf, Cairo.Surface> surface_table; + + public static Cairo.Surface? get_cached_surface (Cairo.Context c, Gdk.Pixbuf pixbuf) + { + if (surface_table == null) + surface_table = new HashTable<Gdk.Pixbuf, Cairo.Surface> (direct_hash, direct_equal); + + var surface = surface_table.lookup (pixbuf); + if (surface == null) + { + surface = new Cairo.Surface.similar (c.get_target (), Cairo.Content.COLOR_ALPHA, pixbuf.width, pixbuf.height); + var new_c = new Cairo.Context (surface); + Gdk.cairo_set_source_pixbuf (new_c, pixbuf, 0, 0); + new_c.paint (); + surface_table.insert (pixbuf, surface); + } + return surface; + } + + public CachedImage (Gdk.Pixbuf? pixbuf) + { + Object (pixbuf: pixbuf); + } + + public override bool draw (Cairo.Context c) + { + if (pixbuf != null) + { + var cached_surface = get_cached_surface (c, pixbuf); + if (cached_surface != null) + { + c.set_source_surface (cached_surface, 0, 0); + c.paint (); + } + } + return false; + } +} diff --git a/src/cairo-utils.vala b/src/cairo-utils.vala new file mode 100644 index 0000000..a30a580 --- /dev/null +++ b/src/cairo-utils.vala @@ -0,0 +1,238 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2013 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Marco Trevisan <marco.trevisan@canonical.com> + * Mirco "MacSlow" Mueller <mirco.mueller@canonical.com> + */ + +namespace CairoUtils +{ + +public void rounded_rectangle (Cairo.Context c, double x, double y, + double width, double height, double radius) +{ + var w = width - radius * 2; + var h = height - radius * 2; + var kappa = 0.5522847498 * radius; + c.move_to (x + radius, y); + c.rel_line_to (w, 0); + c.rel_curve_to (kappa, 0, radius, radius - kappa, radius, radius); + c.rel_line_to (0, h); + c.rel_curve_to (0, kappa, kappa - radius, radius, -radius, radius); + c.rel_line_to (-w, 0); + c.rel_curve_to (-kappa, 0, -radius, kappa - radius, -radius, -radius); + c.rel_line_to (0, -h); + c.rel_curve_to (0, -kappa, radius - kappa, -radius, radius, -radius); +} + +class GaussianBlur +{ + /* Gaussian Blur, based on Mirco Mueller work on notify-osd */ + + public static void surface (Cairo.ImageSurface surface, uint radius, double sigma = 0.0f) + { + if (surface.get_format () != Cairo.Format.ARGB32) + { + warning ("Impossible to blur a non ARGB32-formatted ImageSurface"); + return; + } + + surface.flush (); + + double radiusf = Math.fabs (radius) + 1.0f; + + if (sigma == 0.0f) + sigma = Math.sqrt (-(radiusf * radiusf) / (2.0f * Math.log (1.0f / 255.0f))); + + int w = surface.get_width (); + int h = surface.get_height (); + int s = surface.get_stride (); + + // create pixman image for cairo image surface + unowned uchar[] p = surface.get_data (); + var src = new Pixman.Image.bits (Pixman.Format.A8R8G8B8, w, h, p, s); + + // attach gaussian kernel to pixman image + var params = create_gaussian_blur_kernel ((int) radius, sigma); + src.set_filter (Pixman.Filter.CONVOLUTION, params); + + // render blured image to new pixman image + Pixman.Image.composite (Pixman.Operation.SRC, src, null, src, + 0, 0, 0, 0, 0, 0, (uint16) w, (uint16) h); + + surface.mark_dirty (); + } + + private static Pixman.Fixed[] create_gaussian_blur_kernel (int radius, double sigma) + { + double scale2 = 2.0f * sigma * sigma; + double scale1 = 1.0f / (Math.PI * scale2); + int size = 2 * radius + 1; + int n_params = size * size; + double sum = 0; + + var tmp = new double[n_params]; + + // caluclate gaussian kernel in floating point format + for (int i = 0, x = -radius; x <= radius; ++x) + { + for (int y = -radius; y <= radius; ++y, ++i) + { + double u = x * x; + double v = y * y; + + tmp[i] = scale1 * Math.exp (-(u+v)/scale2); + + sum += tmp[i]; + } + } + + // normalize gaussian kernel and convert to fixed point format + var params = new Pixman.Fixed[n_params + 2]; + + params[0] = Pixman.Fixed.int (size); + params[1] = Pixman.Fixed.int (size); + + for (int i = 2; i < params.length; ++i) + params[i] = Pixman.Fixed.double (tmp[i] / sum); + + return params; + } +} + +class ExponentialBlur +{ + /* Exponential Blur, based on the Nux version */ + + const int APREC = 16; + const int ZPREC = 7; + + public static void surface (Cairo.ImageSurface surface, int radius) + { + if (radius < 1) + return; + + // before we mess with the surface execute any pending drawing + surface.flush (); + + unowned uchar[] pixels = surface.get_data (); + var width = surface.get_width (); + var height = surface.get_height (); + var format = surface.get_format (); + + switch (format) + { + case Cairo.Format.ARGB32: + blur (pixels, width, height, 4, radius); + break; + + case Cairo.Format.RGB24: + blur (pixels, width, height, 3, radius); + break; + + case Cairo.Format.A8: + blur (pixels, width, height, 1, radius); + break; + + default : + // do nothing + break; + } + + // inform cairo we altered the surfaces contents + surface.mark_dirty (); + } + + static void blur (uchar[] pixels, int width, int height, int channels, int radius) + { + // calculate the alpha such that 90% of + // the kernel is within the radius. + // (Kernel extends to infinity) + + int alpha = (int) ((1 << APREC) * (1.0f - Math.expf(-2.3f / (radius + 1.0f)))); + + for (int row = 0; row < height; ++row) + blurrow (pixels, width, height, channels, row, alpha); + + for (int col = 0; col < width; ++col) + blurcol (pixels, width, height, channels, col, alpha); + } + + static void blurrow (uchar[] pixels, int width, int height, int channels, int line, int alpha) + { + var scanline = &(pixels[line * width * channels]); + + int zR = *scanline << ZPREC; + int zG = *(scanline + 1) << ZPREC; + int zB = *(scanline + 2) << ZPREC; + int zA = *(scanline + 3) << ZPREC; + + for (int index = 0; index < width; ++index) + { + blurinner (&scanline[index * channels], alpha, ref zR, ref zG, ref zB, ref zA); + } + + for (int index = width - 2; index >= 0; --index) + { + blurinner (&scanline[index * channels], alpha, ref zR, ref zG, ref zB, ref zA); + } + } + + static void blurcol (uchar[] pixels, int width, int height, int channels, int x, int alpha) + { + var ptr = &(pixels[x * channels]); + + int zR = *ptr << ZPREC; + int zG = *(ptr + 1) << ZPREC; + int zB = *(ptr + 2) << ZPREC; + int zA = *(ptr + 3) << ZPREC; + + for (int index = width; index < (height - 1) * width; index += width) + { + blurinner (&ptr[index * channels], alpha, ref zR, ref zG, ref zB, ref zA); + } + + for (int index = (height - 2) * width; index >= 0; index -= width) + { + blurinner (&ptr[index * channels], alpha, ref zR, ref zG, ref zB, ref zA); + } + } + + static void blurinner (uchar *pixel, int alpha, ref int zR, ref int zG, ref int zB, ref int zA) + { + int R; + int G; + int B; + uchar A; + + R = *pixel; + G = *(pixel + 1); + B = *(pixel + 2); + A = *(pixel + 3); + + zR += (alpha * ((R << ZPREC) - zR)) >> APREC; + zG += (alpha * ((G << ZPREC) - zG)) >> APREC; + zB += (alpha * ((B << ZPREC) - zB)) >> APREC; + zA += (alpha * ((A << ZPREC) - zA)) >> APREC; + + *pixel = zR >> ZPREC; + *(pixel + 1) = zG >> ZPREC; + *(pixel + 2) = zB >> ZPREC; + *(pixel + 3) = zA >> ZPREC; + } +} + +} diff --git a/src/config.vapi b/src/config.vapi new file mode 100644 index 0000000..8fe2441 --- /dev/null +++ b/src/config.vapi @@ -0,0 +1,12 @@ +[CCode (cprefix = "", lower_case_cprefix = "", cheader_filename = "config.h")] +namespace Config +{ + public const string GETTEXT_PACKAGE; + public const string LOCALEDIR; + public const string VERSION; + public const string CONFIG_FILE; + public const string INDICATOR_FILE_DIR; + public const string PKGDATADIR; + public const string INDICATORDIR; + public const string USD_BINARY; +} diff --git a/src/dash-box.vala b/src/dash-box.vala new file mode 100644 index 0000000..889ba41 --- /dev/null +++ b/src/dash-box.vala @@ -0,0 +1,230 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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/>. + * + * Authored by: Michael Terry <michael.terry@canonical.com> + */ + +public class DashBox : Gtk.Box +{ + public Background? background { get; construct; default = null; } + + public bool has_base { get; private set; default = false; } + public double base_alpha { get; private set; default = 1.0; } + + private enum Mode + { + NORMAL, + PUSH_FADE_OUT, + PUSH_FADE_IN, + POP_FADE_OUT, + POP_FADE_IN, + } + + private GreeterList pushed; + private Gtk.Widget orig = null; + private FadeTracker orig_tracker; + private int orig_height = -1; + private Mode mode; + + public DashBox (Background bg) + { + Object (background: bg); + } + + construct + { + mode = Mode.NORMAL; + } + + /* Does not actually add w to this widget, as doing so would potentially mess with w's placement. */ + public void set_base (Gtk.Widget? w) + { + return_if_fail (pushed == null); + return_if_fail (mode == Mode.NORMAL); + + if (orig != null) + orig.size_allocate.disconnect (base_size_allocate_cb); + orig = w; + + if (orig != null) + { + orig.size_allocate.connect (base_size_allocate_cb); + orig_tracker = new FadeTracker (orig); + orig_tracker.notify["alpha"].connect (() => + { + base_alpha = orig_tracker.alpha; + queue_draw (); + }); + orig_tracker.done.connect (fade_done_cb); + base_alpha = orig_tracker.alpha; + has_base = true; + } + else + { + orig_height = -1; + get_preferred_height (null, out orig_height); /* save height */ + + orig_tracker = null; + base_alpha = 1.0; + has_base = false; + } + + queue_resize (); + } + + public void push (GreeterList l) + { + /* This isn't designed to push more than one widget at a time yet */ + return_if_fail (pushed == null); + return_if_fail (orig != null); + return_if_fail (mode == Mode.NORMAL); + + get_preferred_height (null, out orig_height); + pushed = l; + pushed.fade_done.connect (fade_done_cb); + mode = Mode.PUSH_FADE_OUT; + orig_tracker.reset (FadeTracker.Mode.FADE_OUT); + queue_resize (); + } + + public void pop () + { + return_if_fail (pushed != null); + return_if_fail (orig != null); + return_if_fail (mode == Mode.NORMAL); + + mode = Mode.POP_FADE_OUT; + pushed.fade_out (); + } + + private void fade_done_cb () + { + switch (mode) + { + case Mode.PUSH_FADE_OUT: + mode = Mode.PUSH_FADE_IN; + orig.hide (); + pushed.fade_in (); + break; + case Mode.PUSH_FADE_IN: + mode = Mode.NORMAL; + pushed.grab_focus (); + break; + case Mode.POP_FADE_OUT: + mode = Mode.POP_FADE_IN; + orig_tracker.reset (FadeTracker.Mode.FADE_IN); + orig.show (); + break; + case Mode.POP_FADE_IN: + mode = Mode.NORMAL; + pushed.fade_done.disconnect (fade_done_cb); + pushed.destroy (); + pushed = null; + queue_resize (); + orig.grab_focus (); + break; + } + } + + private void base_size_allocate_cb () + { + queue_resize (); + } + + public override void get_preferred_height (out int min, out int nat) + { + if (orig == null) + { + /* Return cached height if we have it. This makes transitions between two base widgets smoother. */ + if (orig_height >= 0) + { + min = orig_height; + nat = orig_height; + } + else + { + min = grid_size * GreeterList.DEFAULT_BOX_HEIGHT - GreeterList.BORDER * 2; + nat = grid_size * GreeterList.DEFAULT_BOX_HEIGHT - GreeterList.BORDER * 2; + } + } + else + { + if (pushed == null) + orig.get_preferred_height (out min, out nat); + else + { + pushed.selected_entry.get_preferred_height (out min, out nat); + min = int.max (orig_height, min); + nat = int.max (orig_height, nat); + } + } + } + + public override void get_preferred_width (out int min, out int nat) + { + min = grid_size * GreeterList.BOX_WIDTH - GreeterList.BORDER * 2; + nat = grid_size * GreeterList.BOX_WIDTH - GreeterList.BORDER * 2; + } + + public override bool draw (Cairo.Context c) + { + if (background != null) + { + int x, y; + background.translate_coordinates (this, 0, 0, out x, out y); + c.save (); + c.translate (x, y); + background.draw_full (c, Background.DrawFlags.NONE); + c.restore (); + } + + /* Draw darker background with a rounded border */ + var box_r = 0.3 * grid_size; + int box_y = 0; + int box_w; + int box_h; + get_preferred_width (null, out box_w); + get_preferred_height (null, out box_h); + + if (mode == Mode.PUSH_FADE_OUT) + { + /* Grow dark bg to fit new pushed object */ + var new_box_h = box_h - (int) ((box_h - orig_height) * base_alpha); + box_h = new_box_h; + } + else if (mode == Mode.POP_FADE_IN) + { + /* Shrink dark bg to fit orig */ + var new_box_h = box_h - (int) ((box_h - orig_height) * base_alpha); + box_h = new_box_h; + } + + c.save (); + + CairoUtils.rounded_rectangle (c, 0, box_y, box_w, box_h, box_r); + + c.set_source_rgba (0.1, 0.1, 0.1, 0.4); + c.fill_preserve (); + + c.set_source_rgba (0.4, 0.4, 0.4, 0.4); + c.set_line_width (1); + c.stroke (); + + c.restore (); + + return base.draw (c); + } +} diff --git a/src/dash-button.vala b/src/dash-button.vala new file mode 100644 index 0000000..c562a28 --- /dev/null +++ b/src/dash-button.vala @@ -0,0 +1,89 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +public class DashButton : FlatButton, Fadable +{ + protected FadeTracker fade_tracker { get; protected set; } + private Gtk.Label text_label; + + private string _text = ""; + public string text + { + get { return _text; } + set + { + _text = value; + text_label.set_markup ("<span font=\"Ubuntu 13\">%s</span>".printf (value)); + } + } + + public DashButton (string text) + { + fade_tracker = new FadeTracker (this); + + var hbox = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 0); + + /* Add text */ + text_label = new Gtk.Label (""); + text_label.use_markup = true; + text_label.hexpand = true; + text_label.halign = Gtk.Align.START; + hbox.add (text_label); + this.text = text; + + /* Add chevron */ + var path = Path.build_filename (Config.PKGDATADIR, "arrow_right.png", null); + try + { + var pixbuf = new Gdk.Pixbuf.from_file (path); + var image = new CachedImage (pixbuf); + image.valign = Gtk.Align.CENTER; + hbox.add (image); + } + catch (Error e) + { + debug ("Error loading image %s: %s", path, e.message); + } + + hbox.show_all (); + add (hbox); + + try + { + var style = new Gtk.CssProvider (); + style.load_from_data ("* {padding: 6px 8px 6px 8px; + -GtkWidget-focus-line-width: 0px; + }", -1); + this.get_style_context ().add_provider (style, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading session chooser style: %s", e.message); + } + } + + public override bool draw (Cairo.Context c) + { + c.push_group (); + base.draw (c); + c.pop_group_to_source (); + c.paint_with_alpha (fade_tracker.alpha); + return false; + } +} diff --git a/src/dash-entry.vala b/src/dash-entry.vala new file mode 100644 index 0000000..9528705 --- /dev/null +++ b/src/dash-entry.vala @@ -0,0 +1,319 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +/* Vala's vapi for gtk3 is broken for lookup_color (it forgets the out keyword) */ +[CCode (cheader_filename = "gtk/gtk.h")] +extern bool gtk_style_context_lookup_color (Gtk.StyleContext ctx, string color_name, out Gdk.RGBA color); + +public class DashEntry : Gtk.Entry, Fadable +{ + public static string font = "Ubuntu 14"; + public signal void respond (); + + public string constant_placeholder_text { get; set; } + public bool can_respond { get; set; default = true; } + + private bool _did_respond; + public bool did_respond + { + get + { + return _did_respond; + } + set + { + _did_respond = value; + if (value) + set_state_flags (Gtk.StateFlags.ACTIVE, false); + else + unset_state_flags (Gtk.StateFlags.ACTIVE); + queue_draw (); + } + } + + private static const string NO_BORDER_CLASS = "unity-greeter-no-border"; + + protected FadeTracker fade_tracker { get; protected set; } + private Gdk.Window arrow_win; + private static Gdk.Pixbuf arrow_pixbuf; + + construct + { + fade_tracker = new FadeTracker (this); + + notify["can-respond"].connect (queue_draw); + button_press_event.connect (button_press_event_cb); + + if (arrow_pixbuf == null) + { + var filename = Path.build_filename (Config.PKGDATADIR, "arrow_right.png"); + try + { + arrow_pixbuf = new Gdk.Pixbuf.from_file (filename); + } + catch (Error e) + { + debug ("Internal error loading arrow icon: %s", e.message); + } + } + + override_font (Pango.FontDescription.from_string (font)); + + var style_ctx = get_style_context (); + + try + { + var padding_provider = new Gtk.CssProvider (); + var css = "* {padding-right: %dpx;}".printf (get_arrow_size ()); + padding_provider.load_from_data (css, -1); + style_ctx.add_provider (padding_provider, + Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading padding style: %s", e.message); + } + + // We add the styles and classes we need for normal operation of the + // spinner animation. These are always "on" and we just turn them off + // right before drawing our parent class's draw function. This is done + // opt-out like that rather than just turning the styles on when we + // need to draw the spinner because the animation doesn't work right + // otherwise. See the draw() function for how we turn it off. + var no_border_provider = new Gtk.CssProvider (); + try + { + var css = ".%s {border: 0px;}".printf (NO_BORDER_CLASS); + no_border_provider.load_from_data (css, -1); + } + catch (Error e) + { + debug ("Internal error loading spinner style: %s", e.message); + } + style_ctx.add_provider (no_border_provider, + Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + style_ctx.add_class (NO_BORDER_CLASS); + style_ctx.add_class (Gtk.STYLE_CLASS_SPINNER); + } + + public override bool draw (Cairo.Context c) + { + var style_ctx = get_style_context (); + + // See construct method for explanation of why we remove classes + style_ctx.save (); + style_ctx.remove_class (Gtk.STYLE_CLASS_SPINNER); + style_ctx.remove_class (NO_BORDER_CLASS); + c.save (); + c.push_group (); + base.draw (c); + c.pop_group_to_source (); + c.paint_with_alpha (fade_tracker.alpha); + c.restore (); + style_ctx.restore (); + + /* Now draw the prompt text */ + if (get_text_length () == 0 && constant_placeholder_text.length > 0) + draw_prompt_text (c); + + /* Draw activity spinner if we need to */ + if (did_respond) + draw_spinner (c); + else if (can_respond && get_text_length () > 0) + draw_arrow (c); + + return false; + } + + private void draw_spinner (Cairo.Context c) + { + c.save (); + + var style_ctx = get_style_context (); + var arrow_size = get_arrow_size (); + Gtk.cairo_transform_to_window (c, this, arrow_win); + style_ctx.render_activity (c, 0, 0, arrow_size, arrow_size); + + c.restore (); + } + + private void draw_arrow (Cairo.Context c) + { + if (arrow_pixbuf == null) + return; + + c.save (); + + var arrow_size = get_arrow_size (); + Gtk.cairo_transform_to_window (c, this, arrow_win); + c.translate (arrow_size - arrow_pixbuf.get_width () - 1, 0); // right align + Gdk.cairo_set_source_pixbuf (c, arrow_pixbuf, 0, 0); + + c.paint (); + c.restore (); + } + + private void draw_prompt_text (Cairo.Context c) + { + c.save (); + + /* Position text */ + int x, y; + get_layout_offsets (out x, out y); + c.move_to (x, y); + + /* Set foreground color */ + var fg = Gdk.RGBA (); + var context = get_style_context (); + if (!gtk_style_context_lookup_color (context, "placeholder_text_color", out fg)) + fg.parse ("#888"); + c.set_source_rgba (fg.red, fg.green, fg.blue, fg.alpha); + + /* Draw text */ + var layout = create_pango_layout (constant_placeholder_text); + layout.set_font_description (Pango.FontDescription.from_string ("Ubuntu 13")); + Pango.cairo_show_layout (c, layout); + + c.restore (); + } + + public override void activate () + { + base.activate (); + if (can_respond) + { + did_respond = true; + respond (); + } + else + { + get_toplevel ().child_focus (Gtk.DirectionType.TAB_FORWARD); + } + } + + public bool button_press_event_cb (Gdk.EventButton event) + { + if (event.window == arrow_win && get_text_length () > 0) + { + activate (); + return true; + } + else + return false; + } + + private int get_arrow_size () + { + // height is larger than width for the arrow, so we measure using that + if (arrow_pixbuf != null) + return arrow_pixbuf.get_height (); + else + return 20; // Shouldn't happen + } + + private void get_arrow_location (out int x, out int y) + { + var arrow_size = get_arrow_size (); + + Gtk.Allocation allocation; + get_allocation (out allocation); + + // height is larger than width for the arrow, so we measure using that + var margin = (allocation.height - arrow_size) / 2; + + x = allocation.x + allocation.width - margin - arrow_size; + y = allocation.y + margin; + } + + public override void size_allocate (Gtk.Allocation allocation) + { + base.size_allocate (allocation); + + if (arrow_win == null) + return; + + int arrow_x, arrow_y; + get_arrow_location (out arrow_x, out arrow_y); + var arrow_size = get_arrow_size (); + + arrow_win.move_resize (arrow_x, arrow_y, arrow_size, arrow_size); + } + + public override void realize () + { + base.realize (); + + var cursor = new Gdk.Cursor (Gdk.CursorType.LEFT_PTR); + var attrs = Gdk.WindowAttr (); + attrs.x = 0; + attrs.y = 0; + attrs.width = 1; + attrs.height = 1; + attrs.cursor = cursor; + attrs.wclass = Gdk.WindowWindowClass.INPUT_ONLY; + attrs.window_type = Gdk.WindowType.CHILD; + attrs.event_mask = get_events () | + Gdk.EventMask.BUTTON_PRESS_MASK; + + arrow_win = new Gdk.Window (get_window (), attrs, + Gdk.WindowAttributesType.X | + Gdk.WindowAttributesType.Y | + Gdk.WindowAttributesType.CURSOR); + arrow_win.ref (); + arrow_win.set_user_data (this); + } + + public override void unrealize () + { + if (arrow_win != null) + { + arrow_win.destroy (); + arrow_win = null; + } + base.unrealize (); + } + + public override void map () + { + base.map (); + if (arrow_win != null) + arrow_win.show (); + } + + public override void unmap () + { + if (arrow_win != null) + arrow_win.hide (); + base.unmap (); + } + + public override bool key_press_event (Gdk.EventKey event) + { + // This is a workaroud for bug https://launchpad.net/bugs/944159 + // The problem is that orca seems to not notice that it's in a password + // field on startup. We just need to kick orca in the pants. + if (UnityGreeter.singleton.orca_needs_kick) + { + Signal.emit_by_name (get_accessible (), "focus-event", true); + UnityGreeter.singleton.orca_needs_kick = false; + } + + return base.key_press_event (event); + } +} diff --git a/src/email-autocompleter.vala b/src/email-autocompleter.vala new file mode 100644 index 0000000..d11fb30 --- /dev/null +++ b/src/email-autocompleter.vala @@ -0,0 +1,79 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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/>. + * + */ + +public class EmailAutocompleter +{ + private Gtk.Entry entry; + private string[] domains; + private string prevText = ""; + + private void entry_changed () + { + if (entry.text.length < prevText.length) + { + /* Do nothing on erases of text */ + prevText = entry.text; + return; + } + + prevText = entry.text; + + int first_at = entry.text.index_of ("@"); + if (first_at != -1) + { + int second_at = entry.text.index_of ("@", first_at + 1); + if (second_at == -1) + { + /* We have exactly one @ */ + string text_after_at = entry.text.slice (first_at + 1, entry.text.length); + + /* Find first prefix match */ + int match = -1; + for (int i = 0; match == -1 && i < domains.length; ++i) + { + if (domains[i].has_prefix (text_after_at)) + match = i; + } + + if (match != -1) + { + /* Calculate the suffix part we need to add */ + var best_match = domains[match]; + var text_to_add = best_match.slice (text_after_at.length, best_match.length); + if (text_to_add.length > 0) + { + entry.text = entry.text + text_to_add; + /* TODO This is quite ugly/hacky :-/ */ + Timeout.add (0, () => + { + entry.select_region (entry.text.length - text_to_add.length, entry.text.length); + return false; + }); + } + } + } + } + } + + public EmailAutocompleter (Gtk.Entry e, string[] email_domains) + { + entry = e; + domains = email_domains; + entry.changed.connect (entry_changed); + } +} diff --git a/src/fadable-box.vala b/src/fadable-box.vala new file mode 100644 index 0000000..c287d21 --- /dev/null +++ b/src/fadable-box.vala @@ -0,0 +1,46 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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/>. + * + * Authored by: Michael Terry <michael.terry@canonical.com> + */ + +public class FadableBox : Gtk.EventBox, Fadable +{ + public signal void fade_done (); + + protected FadeTracker fade_tracker { get; protected set; } + + construct + { + visible_window = false; + fade_tracker = new FadeTracker (this); + fade_tracker.done.connect (() => { fade_done (); }); + } + + protected virtual void draw_full_alpha (Cairo.Context c) + { + base.draw (c); + } + + public override bool draw (Cairo.Context c) + { + c.push_group (); + draw_full_alpha (c); + c.pop_group_to_source (); + c.paint_with_alpha (fade_tracker.alpha); + return false; + } +} diff --git a/src/fadable.vala b/src/fadable.vala new file mode 100644 index 0000000..a67ad63 --- /dev/null +++ b/src/fadable.vala @@ -0,0 +1,99 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +public class FadeTracker : Object +{ + public signal void done (); + + public double alpha { get; set; default = 1.0; } + public Gtk.Widget widget { get; construct; } + + public enum Mode + { + FADE_IN, + FADE_OUT, + } + + public FadeTracker (Gtk.Widget widget) + { + Object (widget: widget); + } + + public void reset (Mode mode) + { + this.mode = mode; + animate_cb (0.0); + widget.show (); + timer.reset (); + } + + private AnimateTimer timer; + private Mode mode; + + construct + { + timer = new AnimateTimer (AnimateTimer.ease_out_quint, AnimateTimer.INSTANT); + timer.animate.connect (animate_cb); + } + + private void animate_cb (double progress) + { + if (mode == Mode.FADE_IN) + { + alpha = progress; + if (progress == 1.0) + { + done (); + } + } + else + { + alpha = 1.0 - progress; + if (progress == 1.0) + { + widget.hide (); /* finish the job */ + done (); + } + } + + widget.queue_draw (); + } +} + +public interface Fadable : Gtk.Widget +{ + protected abstract FadeTracker fade_tracker { get; protected set; } + + public void fade_in () + { + fade_tracker.reset (FadeTracker.Mode.FADE_IN); + } + + public void fade_out () + { + fade_tracker.reset (FadeTracker.Mode.FADE_OUT); + } + + /* In case you want to control fade manually */ + public void set_alpha (double alpha) + { + fade_tracker.alpha = alpha; + queue_draw (); + } +} diff --git a/src/fading-label.vala b/src/fading-label.vala new file mode 100644 index 0000000..80977e6 --- /dev/null +++ b/src/fading-label.vala @@ -0,0 +1,85 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +public class FadingLabel : Gtk.Label +{ + private Cairo.Surface cached_surface; + + public FadingLabel (string text) + { + Object (label: text); + } + + public override void get_preferred_width (out int minimum, out int natural) + { + base.get_preferred_width (out minimum, out natural); + minimum = 0; + } + + public override void get_preferred_width_for_height (int height, out int minimum, out int natural) + { + base.get_preferred_width_for_height (height, out minimum, out natural); + minimum = 0; + } + + public override void size_allocate (Gtk.Allocation allocation) + { + base.size_allocate (allocation); + cached_surface = null; + } + + private Cairo.Surface make_surface (Cairo.Context orig_c) + { + int w, h; + get_layout ().get_pixel_size (out w, out h); + + var bw = get_allocated_width (); + var bh = get_allocated_height (); + + var surface = new Cairo.Surface.similar (orig_c.get_target (), Cairo.Content.COLOR_ALPHA, bw, bh); + var c = new Cairo.Context (surface); + + if (w > bw) + { + c.push_group (); + base.draw (c); + c.pop_group_to_source (); + + var mask = new Cairo.Pattern.linear (0, 0, bw, 0); + mask.add_color_stop_rgba (1.0 - 27.0 / bw, 1.0, 1.0, 1.0, 1.0); + mask.add_color_stop_rgba (1.0 - 21.6 / bw, 1.0, 1.0, 1.0, 0.5); + mask.add_color_stop_rgba (1.0, 1.0, 1.0, 1.0, 0.0); + + c.mask (mask); + } + else + base.draw (c); + + return surface; + } + + public override bool draw (Cairo.Context c) + { + if (cached_surface == null) + cached_surface = make_surface (c); + c.set_source_surface (cached_surface, 0, 0); + c.paint (); + return false; + } +} diff --git a/src/fixes.vapi b/src/fixes.vapi new file mode 100644 index 0000000..8d08370 --- /dev/null +++ b/src/fixes.vapi @@ -0,0 +1,57 @@ +#if !VALA_0_22 +namespace Posix +{ + [CCode (cheader_filename = "sys/mman.h")] + public const int MCL_CURRENT; + [CCode (cheader_filename = "sys/mman.h")] + public const int MCL_FUTURE; + [CCode (cheader_filename = "sys/mman.h")] + public int mlockall (int flags); + [CCode (cheader_filename = "sys/mman.h")] + public int munlockall (); +} +#endif + +// See https://bugzilla.gnome.org/show_bug.cgi?id=727113 +[CCode (cprefix = "", lower_case_cprefix = "", cheader_filename = "X11/Xlib.h")] +namespace X +{ + [CCode (cname = "XCreatePixmap")] + public int CreatePixmap (X.Display display, X.Drawable d, uint width, uint height, uint depth); + [CCode (cname = "XSetWindowBackgroundPixmap")] + public int SetWindowBackgroundPixmap (X.Display display, X.Window w, int Pixmap); + [CCode (cname = "XClearWindow")] + public int ClearWindow (X.Display display, X.Window w); + public const int RetainPermanent; +} + +namespace Gtk +{ + namespace RGB + { + // Fixed in Vala 0.24 + public void to_hsv (double r, double g, double b, out double h, out double s, out double v); + } +} + +namespace Gnome +{ + [CCode (cheader_filename = "libgnome-desktop/gnome-idle-monitor.h")] + public class IdleMonitor : GLib.Object + { + public IdleMonitor (); + public IdleMonitor.for_device (Gdk.Device device); + public uint add_idle_watch (uint64 interval_msec, IdleMonitorWatchFunc callback, GLib.DestroyNotify? notify = null); + public uint add_user_active_watch (IdleMonitorWatchFunc callback, GLib.DestroyNotify? notify = null); + public void remove_watch (uint id); + public int64 get_idletime (); + } + + public delegate void IdleMonitorWatchFunc (IdleMonitor monitor, uint id); +} + +// Note, fixed in 1.10.0 +namespace LightDM +{ + bool greeter_start_session_sync (LightDM.Greeter greeter, string session) throws GLib.Error; +} diff --git a/src/flat-button.vala b/src/flat-button.vala new file mode 100644 index 0000000..3a718d2 --- /dev/null +++ b/src/flat-button.vala @@ -0,0 +1,66 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +public class FlatButton : Gtk.Button +{ + private bool did_press; + + construct + { + UnityGreeter.add_style_class (this); + try + { + var style = new Gtk.CssProvider (); + style.load_from_data ("* {-GtkButton-child-displacement-x: 0px; + -GtkButton-child-displacement-y: 0px; + -GtkWidget-focus-line-width: 1px; + }", -1); + get_style_context ().add_provider (style, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading session chooser style: %s", e.message); + } + } + + public override bool draw (Cairo.Context c) + { + // Make sure we don't react to mouse hovers + unset_state_flags (Gtk.StateFlags.PRELIGHT); + return base.draw (c); + } + + public override void pressed () + { + // Do nothing. The normal handler sets priv->button_down which + // internally causes draw() to draw a special border and background + // that we don't want. + did_press = true; + } + + public override void released () + { + if (did_press) + { + base.pressed (); // fake an insta-click + did_press = false; + } + base.released (); + } +} diff --git a/src/greeter-list.vala b/src/greeter-list.vala new file mode 100644 index 0000000..dee584f --- /dev/null +++ b/src/greeter-list.vala @@ -0,0 +1,949 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + * Scott Sweeny <scott.sweeny@canonical.com> + */ + +private int get_grid_offset (int size) +{ + return (int) (size % grid_size) / 2; +} + +[DBus (name="com.canonical.UnityGreeter.List")] +public class ListDBusInterface : Object +{ + private GreeterList list; + + public ListDBusInterface (GreeterList list) + { + this.list = list; + this.list.entry_selected.connect ((name) => { + entry_selected (name); + }); + } + + public string get_active_entry () + { + string entry = ""; + + if (list.selected_entry != null && list.selected_entry.id != null) + entry = list.selected_entry.id; + + return entry; + } + + public void set_active_entry (string entry_name) + { + list.set_active_entry (entry_name); + } + + public signal void entry_selected (string entry_name); +} + +public abstract class GreeterList : FadableBox +{ + public Background background { get; construct; } + public MenuBar menubar { get; construct; } + public PromptBox? selected_entry { get; private set; default = null; } + public bool start_scrolling { get; set; default = true; } + + protected string greeter_authenticating_user; + + protected bool _always_show_manual = false; + public bool always_show_manual + { + get { return _always_show_manual; } + set + { + _always_show_manual = value; + if (value) + add_manual_entry (); + else if (have_entries ()) + remove_entry ("*other"); + } + } + + protected List<PromptBox> entries = null; + + private ListDBusInterface dbus_object; + + private double scroll_target_location; + private double scroll_start_location; + private double scroll_location; + private double scroll_direction; + + private AnimateTimer scroll_timer; + + private Gtk.Fixed fixed; + public DashBox greeter_box; + private int cached_box_height = -1; + + protected enum Mode + { + ENTRY, + SCROLLING, + } + protected Mode mode = Mode.ENTRY; + + public static const int BORDER = 4; + public static const int BOX_WIDTH = 8; /* in grid_size blocks */ + public static const int DEFAULT_BOX_HEIGHT = 3; /* in grid_size blocks */ + + private uint n_above = 4; + private uint n_below = 4; + + private int box_x + { + get { return 0; } + } + + private int box_y + { + get + { + /* First, get grid row number as if menubar weren't there */ + var row = (MainWindow.MENUBAR_HEIGHT + get_allocated_height ()) / grid_size; + row = row - DEFAULT_BOX_HEIGHT; /* and no default dash box */ + row = row / 2; /* and in the middle */ + /* Now calculate y pixel spot keeping in mind menubar's allocation */ + return row * grid_size - MainWindow.MENUBAR_HEIGHT; + } + } + + public signal void entry_selected (string? name); + public signal void entry_displayed_start (); + public signal void entry_displayed_done (); + + protected virtual string? get_selected_id () + { + if (selected_entry == null) + return null; + return selected_entry.id; + } + + private string? _manual_name = null; + public string? manual_name + { + get { return _manual_name; } + set + { + _manual_name = value; + if (find_entry ("*other") != null) + add_manual_entry (); + } + } + + private PromptBox _scrolling_entry = null; + private PromptBox scrolling_entry + { + get { return _scrolling_entry; } + set + { + /* When we swap out a scrolling entry, make sure to hide its + * image button, else it will appear in the tab chain. */ + if (_scrolling_entry != null) + _scrolling_entry.set_options_image (null); + _scrolling_entry = value; + } + } + + public GreeterList (Background bg, MenuBar mb) + { + Object (background: bg, menubar: mb); + } + + construct + { + can_focus = false; + visible_window = false; + + fixed = new Gtk.Fixed (); + fixed.show (); + add (fixed); + + greeter_box = new DashBox (background); + greeter_box.notify["base-alpha"].connect (() => { queue_draw (); }); + greeter_box.show (); + greeter_box.size_allocate.connect (greeter_box_size_allocate_cb); + add_with_class (greeter_box); + + scroll_timer = new AnimateTimer (AnimateTimer.ease_out_quint, AnimateTimer.FAST); + scroll_timer.animate.connect (animate_scrolling); + + try + { + Bus.get.begin (BusType.SESSION, null, on_bus_acquired); + } + catch (IOError e) + { + debug ("Error getting session bus: %s", e.message); + } + } + + private void on_bus_acquired (Object? obj, AsyncResult res) + { + try + { + var conn = Bus.get.end (res); + this.dbus_object = new ListDBusInterface (this); + conn.register_object ("/list", this.dbus_object); + } + catch (IOError e) + { + debug ("Error registering user list dbus object: %s", e.message); + } + } + + public enum ScrollTarget + { + START, + END, + UP, + DOWN, + } + + public override void get_preferred_width (out int min, out int nat) + { + min = BOX_WIDTH * grid_size; + nat = BOX_WIDTH * grid_size; + } + + public override void get_preferred_height (out int min, out int nat) + { + base.get_preferred_height (out min, out nat); + min = 0; + } + + public void cancel_authentication () + { + UnityGreeter.singleton.cancel_authentication (); + entry_selected (selected_entry.id); + } + + public void scroll (ScrollTarget target) + { + if (!sensitive) + return; + + switch (target) + { + case ScrollTarget.START: + select_entry (entries.nth_data (0), -1.0); + break; + case ScrollTarget.END: + select_entry (entries.nth_data (entries.length () - 1), 1.0); + break; + case ScrollTarget.UP: + var index = entries.index (selected_entry) - 1; + if (index < 0) + index = 0; + select_entry (entries.nth_data (index), -1.0); + break; + case ScrollTarget.DOWN: + var index = entries.index (selected_entry) + 1; + if (index >= (int) entries.length ()) + index = (int) entries.length () - 1; + select_entry (entries.nth_data (index), 1.0); + break; + } + } + + protected void add_with_class (Gtk.Widget widget) + { + fixed.add (widget); + UnityGreeter.add_style_class (widget); + } + + protected void redraw_greeter_box () + { + Gtk.Allocation allocation; + greeter_box.get_allocation (out allocation); + queue_draw_area (allocation.x, allocation.y, allocation.width, allocation.height); + } + + public void show_message (string text, bool is_error = false) + { + if (will_clear) + { + selected_entry.clear (); + will_clear = false; + } + + selected_entry.add_message (text, is_error); + } + + public DashEntry add_prompt (string text, bool secret = false) + { + if (will_clear) + { + selected_entry.clear (); + will_clear = false; + } + + string accessible_text = null; + if (selected_entry != null && selected_entry.label != null) + accessible_text = _("Enter password for %s").printf (selected_entry.label); + var prompt = selected_entry.add_prompt (text, accessible_text, secret); + + if (mode != Mode.SCROLLING) + selected_entry.show_prompts (); + + focus_prompt (); + redraw_greeter_box (); + + return prompt; + } + + public Gtk.ComboBox add_combo (GenericArray<string> texts, bool read_only) + { + if (will_clear) + { + selected_entry.clear (); + will_clear = false; + } + + var combo = selected_entry.add_combo (texts, read_only); + + focus_prompt (); + redraw_greeter_box (); + + return combo; + } + + public override void grab_focus () + { + focus_prompt (); + } + + public virtual void focus_prompt () + { + selected_entry.sensitive = true; + selected_entry.grab_focus (); + } + + public abstract void show_authenticated (bool successful = true); + + protected PromptBox? find_entry (string id) + { + foreach (var entry in entries) + { + if (entry.id == id) + return entry; + } + + return null; + } + + protected static int compare_entry (PromptBox a, PromptBox b) + { + if (a.id.has_prefix ("*") || b.id.has_prefix ("*")) + { + /* Special entries go after normal ones */ + if (!a.id.has_prefix ("*")) + return -1; + if (!b.id.has_prefix ("*")) + return 1; + + /* Manual comes before guest */ + if (a.id == "*other") + return -1; + if (a.id == "*guest") + return 1; + } + + /* Alphabetical by label */ + return a.label.ascii_casecmp (b.label); + } + + protected bool have_entries () + { + foreach (var e in entries) + { + if (e.id != "*other") + return true; + } + return false; + } + + protected virtual void insert_entry (PromptBox entry) + { + entries.insert_sorted (entry, compare_entry); + } + + protected abstract void add_manual_entry (); + + protected void add_entry (PromptBox entry) + { + entry.expand = true; + entry.set_size_request (grid_size * BOX_WIDTH - BORDER * 2, -1); + add_with_class (entry); + + insert_entry (entry); + + entry.name_clicked.connect (entry_clicked_cb); + + if (selected_entry == null) + select_entry (entry, 1.0); + else + select_entry (selected_entry, 1.0); + + move_names (); + } + + public void set_active_entry (string ?name) + { + var e = find_entry (name); + if (e != null) + { + var direction = 1.0; + if (selected_entry != null && + entries.index (selected_entry) > entries.index (e)) + { + direction = -1.0; + } + select_entry (e, direction); + } + } + + public void set_active_first_entry_with_prefix (string prefix) + { + foreach (var e in entries) + { + if (e.id.has_prefix (prefix)) + { + select_entry (e, 1.0); + break; + } + } + } + + public void remove_entry (string? name) + { + remove_entry_by_entry (find_entry (name)); + } + + public void remove_entries_with_prefix (string prefix) + { + int i = 0; + while (i < entries.length ()) + { + PromptBox e = entries.nth_data (i); + if (e.id.has_prefix (prefix)) + remove_entry_by_entry (e); + else + i++; + } + } + + public void remove_entry_by_entry (PromptBox? entry) + { + if (entry == null) + return; + + var index = entries.index (entry); + entry.destroy (); + entries.remove (entry); + + /* Select another entry if the selected one was removed */ + if (entry == selected_entry) + { + if (index >= entries.length () && index > 0) + index--; + else if (index < entries.length ()) + index++; + + if (entries.nth_data (index) != null) + select_entry (entries.nth_data (index), -1.0); + } + + /* Show a manual login if no users and no remote login entry */ + if (!have_entries () && !UnityGreeter.singleton.show_remote_login_hint ()) + add_manual_entry (); + + queue_draw (); + } + + protected int get_greeter_box_height () + { + int height; + greeter_box.get_preferred_height (null, out height); + return height; + } + + protected int get_greeter_box_height_grids () + { + int height = get_greeter_box_height (); + return height / grid_size + 1; /* +1 because we'll be slightly under due to BORDER */ + } + + protected int get_greeter_box_x () + { + return box_x + BORDER; + } + + protected int get_greeter_box_y () + { + return box_y + BORDER; + } + + protected virtual int get_position_y (double position) + { + // Most position heights are just the grid height. Except for the + // greeter box itself. + int box_height = get_greeter_box_height_grids () * grid_size; + double offset; + + if (position < 0) + offset = position * grid_size; + else if (position < 1) + offset = position * box_height; + else + offset = (position - 1) * grid_size + box_height; + + return box_y + (int)Math.round(offset); + } + + private void move_entry (PromptBox entry, double position) + { + var alpha = 1.0; + if (position < 0) + alpha = 1.0 + position / (n_above + 1); + else + alpha = 1.0 - position / (n_below + 1); + entry.set_alpha (alpha); + + /* Some entry types may care where they are (e.g. wifi prompt) */ + entry.position = position; + + Gtk.Allocation allocation; + get_allocation (out allocation); + + var child_allocation = Gtk.Allocation (); + child_allocation.width = grid_size * BOX_WIDTH - BORDER * 2; + entry.get_preferred_height_for_width (child_allocation.width, null, out child_allocation.height); + child_allocation.x = allocation.x + get_greeter_box_x (); + child_allocation.y = allocation.y + get_position_y (position); + fixed.move (entry, child_allocation.x, child_allocation.y); + entry.size_allocate (child_allocation); + } + + public void greeter_box_size_allocate_cb (Gtk.Allocation allocation) + { + /* If the greeter box allocation changes while not moving fix the entries position */ + if (scrolling_entry == null && allocation.height != cached_box_height) + { + /* We run in idle because it's kind of a recursive loop and + * ends up positioning the entries in the wrong place if we try + * to do it during an existing allocation. */ + Idle.add (() => { move_names (); return false; }); + } + cached_box_height = allocation.height; + } + + public void move_names () + { + var index = 0; + foreach (var entry in entries) + { + var position = index - scroll_location; + + /* Draw entries above, in and below the box */ + if (position > -1 * (int)(n_above + 1) && position < n_below + 1) + { + move_entry (entry, position); + // Sometimes we will be overlayed by another widget like the + // session chooser. In such cases, don't try to show ourselves + var is_hidden = (position == 0 && greeter_box.has_base && + greeter_box.base_alpha == 0.0); + if (!is_hidden) + entry.show (); + } + else + entry.hide (); + + index++; + } + queue_draw (); + } + + private void animate_scrolling (double progress) + { + /* Total height of list */ + var h = entries.length (); + + /* How far we have to go in total, either up or down with wrapping */ + var distance = scroll_target_location - scroll_start_location; + if (scroll_direction * distance < 0) + distance += scroll_direction * h; + + /* How far we've gone so far */ + distance *= progress; + + /* Go that far and wrap around */ + scroll_location = scroll_start_location + distance; + if (scroll_location > h) + scroll_location -= h; + if (scroll_location < 0) + scroll_location += h; + + move_names (); + + if (progress >= 0.975 && !greeter_box.has_base) + { + setup_prompt_box (); + entry_displayed_start (); + } + + /* Stop when we get there */ + if (progress >= 1.0) + finished_scrolling (); + } + + private void finished_scrolling () + { + scrolling_entry = null; + selected_entry.show_prompts (); /* set prompts to be visible immediately */ + focus_prompt (); + entry_displayed_done (); + mode = Mode.ENTRY; + } + + protected void select_entry (PromptBox entry, double direction, bool do_scroll = true) + { + if (!get_realized ()) + { + /* Just note it for the future if we haven't been realized yet */ + selected_entry = entry; + return; + } + + if (scroll_target_location != entries.index (entry)) + { + var new_target = entries.index (entry); + var new_direction = direction; + var new_start = scroll_location; + + if (scroll_location != new_target && do_scroll) + { + var new_distance = new_direction * (new_target - new_start); + /* Base rate is 350 (250 + 100). If we find ourselves going further, slow down animation */ + scroll_timer.reset (250 + int.min ((int)(100 * (Math.fabs (new_distance))), 500)); + + mode = Mode.SCROLLING; + } + + scrolling_entry = selected_entry; + scroll_target_location = new_target; + scroll_direction = new_direction; + scroll_start_location = new_start; + } + + if (selected_entry != entry) + { + greeter_box.set_base (null); + if (selected_entry != null) + selected_entry.clear (); + + selected_entry = entry; + entry_selected (selected_entry.id); + + if (mode == Mode.ENTRY) + { + /* don't need to move, but make sure we trigger the same side effects */ + setup_prompt_box (); + scroll_timer.reset (0); + } + } + } + + protected virtual void setup_prompt_box (bool fade = true) + { + greeter_box.set_base (selected_entry); + selected_entry.add_static_prompts (); + if (fade) + selected_entry.fade_in_prompts (); + else + selected_entry.show_prompts (); + } + + public override void realize () + { + base.realize (); + + /* NOTE: This is going to cause the entry_selected signal to be emitted even if selected_entry has not changed */ + var saved_entry = selected_entry; + selected_entry = null; + select_entry (saved_entry, 1, start_scrolling); + move_names (); + } + + private void allocate_greeter_box () + { + Gtk.Allocation allocation; + get_allocation (out allocation); + + var child_allocation = Gtk.Allocation (); + greeter_box.get_preferred_width (null, out child_allocation.width); + greeter_box.get_preferred_height (null, out child_allocation.height); + child_allocation.x = allocation.x + get_greeter_box_x (); + child_allocation.y = allocation.y + get_greeter_box_y (); + fixed.move (greeter_box, child_allocation.x, child_allocation.y); + greeter_box.size_allocate (child_allocation); + + foreach (var entry in entries) + { + entry.set_zone (greeter_box); + } + } + + public override void size_allocate (Gtk.Allocation allocation) + { + base.size_allocate (allocation); + + if (!get_realized ()) + return; + + allocate_greeter_box (); + move_names (); + } + + public override bool draw (Cairo.Context c) + { + c.push_group (); + + c.save (); + fixed.propagate_draw (greeter_box, c); /* Always full alpha */ + c.restore (); + + if (greeter_box.base_alpha != 0.0) + { + c.save (); + c.push_group (); + + c.rectangle (get_greeter_box_x (), get_greeter_box_y () - n_above * grid_size, grid_size * BOX_WIDTH - BORDER * 2, grid_size * (n_above + n_below + get_greeter_box_height_grids ())); + c.clip (); + + foreach (var child in fixed.get_children ()) + { + if (child != greeter_box) + fixed.propagate_draw (child, c); + } + + c.pop_group_to_source (); + c.paint_with_alpha (greeter_box.base_alpha); + c.restore (); + } + + c.pop_group_to_source (); + c.paint_with_alpha (fade_tracker.alpha); + + return false; + } + + private void entry_clicked_cb (PromptBox entry) + { + if (mode != Mode.ENTRY) + return; + + var index = entries.index (entry); + var position = index - scroll_location; + + if (position < 0.0) + select_entry (entry, -1.0); + else if (position >= 1.0) + select_entry (entry, 1.0); + } + + + /* Not all subclasses are going to be interested in talking to lightdm, but for those that are, make it easy. */ + + protected bool will_clear = false; + protected bool prompted = false; + protected bool unacknowledged_messages = false; + + protected void connect_to_lightdm () + { + UnityGreeter.singleton.show_message.connect (show_message_cb); + UnityGreeter.singleton.show_prompt.connect (show_prompt_cb); + UnityGreeter.singleton.authentication_complete.connect (authentication_complete_cb); + } + + protected void show_message_cb (string text, LightDM.MessageType type) + { + unacknowledged_messages = true; + show_message (text, type == LightDM.MessageType.ERROR); + } + + protected virtual void show_prompt_cb (string text, LightDM.PromptType type) + { + /* Notify the greeter on what user has been logged */ + if (get_selected_id () == "*other" && manual_name == null) + { + if (UnityGreeter.singleton.test_mode) + manual_name = test_username; + else + manual_name = UnityGreeter.singleton.authentication_user(); + } + + prompted = true; + if (text == "Password: ") + text = _("Password:"); + if (text == "login:") + text = _("Username:"); + add_prompt (text, type == LightDM.PromptType.SECRET); + } + + protected virtual void authentication_complete_cb () + { + /* Not the best of the solutions but seems the asynchrony + * when talking to lightdm process means that you can + * go to the "Guest" account, start authenticating as guest + * keep moving down to some of the remote servers + * and the answer will come after that, and even calling + * greeter.cancel_authentication won't help + * so basically i'm just ignoring any authentication callback + * if we are not in the same place in the list as we were + * when we called greeter.authenticate* */ + if (greeter_authenticating_user != selected_entry.id) + return; + + bool is_authenticated; + if (UnityGreeter.singleton.test_mode) + is_authenticated = test_is_authenticated; + else + is_authenticated = UnityGreeter.singleton.is_authenticated(); + + if (is_authenticated) + { + /* Login immediately if prompted and user has acknowledged all messages */ + if (prompted && !unacknowledged_messages) + { + login_complete (); + if (UnityGreeter.singleton.test_mode) + start_session (); + else + { + if (background.alpha == 1.0) + start_session (); + else + background.notify["alpha"].connect (background_loaded_cb); + } + } + else + { + prompted = true; + show_authenticated (); + } + } + else + { + if (prompted) + { + /* Show an error if one wasn't provided */ + if (will_clear) + show_message (_("Invalid password, please try again"), true); + + selected_entry.reset_spinners (); + + /* Restart authentication */ + start_authentication (); + } + else + { + /* Show an error if one wasn't provided */ + if (!selected_entry.has_errors) + show_message (_("Failed to authenticate"), true); + + /* Stop authentication */ + show_authenticated (false); + } + } + } + + protected virtual void start_authentication () + { + prompted = false; + unacknowledged_messages = false; + + /* Reset manual username */ + manual_name = null; + + will_clear = false; + + greeter_authenticating_user = get_selected_id (); + + if (UnityGreeter.singleton.test_mode) + test_start_authentication (); + else + { + if (get_selected_id () == "*other") + UnityGreeter.singleton.authenticate (); + else if (get_selected_id () == "*guest") + UnityGreeter.singleton.authenticate_as_guest (); + else + UnityGreeter.singleton.authenticate (get_selected_id ()); + } + } + + private void background_loaded_cb (ParamSpec pspec) + { + if (background.alpha == 1.0) + { + background.notify["alpha"].disconnect (background_loaded_cb); + start_session (); + } + } + + private void start_session () + { + if (!UnityGreeter.singleton.start_session (get_lightdm_session (), background)) + { + show_message (_("Failed to start session"), true); + start_authentication (); + return; + } + + /* Set the background */ + background.draw_grid = false; + background.queue_draw (); + } + + public void login_complete () + { + sensitive = false; + + selected_entry.clear (); + selected_entry.add_message (_("Logging in…"), false); + + redraw_greeter_box (); + } + + protected virtual string get_lightdm_session () + { + return "ubuntu"; + } + + /* Testing code below this */ + + protected string? test_username = null; + protected bool test_is_authenticated = false; + + protected virtual void test_start_authentication () + { + } +} diff --git a/src/indicator.vapi b/src/indicator.vapi new file mode 100644 index 0000000..9b28c72 --- /dev/null +++ b/src/indicator.vapi @@ -0,0 +1,165 @@ +[CCode (cprefix = "Indicator", lower_case_cprefix = "indicator_")] +namespace Indicator { + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public class DesktopShortcuts : GLib.Object { + [CCode (has_construct_function = false)] + public DesktopShortcuts (string file, string identity); + public unowned string get_nicks (); + public bool nick_exec (string nick); + public unowned string nick_get_name (string nick); + public string desktop_file { construct; } + [NoAccessorMethod] + public string identity { owned get; construct; } + } + [CCode (cheader_filename = "libindicator/indicator-object.h")] + public class Object : GLib.Object { + [CCode (has_construct_function = false)] + protected Object (); + public bool check_environment (string env); + [NoWrapper] + public virtual void entry_activate (Indicator.ObjectEntry entry, uint timestamp); + [NoWrapper] + public virtual void entry_close (Indicator.ObjectEntry entry, uint timestamp); + [CCode (has_construct_function = false)] + public Object.from_file (string file); + [NoWrapper] + public virtual unowned string get_accessible_desc (); + public virtual GLib.List<unowned ObjectEntry> get_entries (); + public unowned string[] get_environment (); + [NoWrapper] + public virtual unowned Gtk.Image get_image (); + [NoWrapper] + public virtual unowned Gtk.Label get_label (); + public virtual uint get_location (Indicator.ObjectEntry entry); + [NoWrapper] + public virtual unowned Gtk.Menu get_menu (); + [NoWrapper] + public virtual unowned string get_name_hint (); + public virtual bool get_show_now (Indicator.ObjectEntry entry); + public virtual int get_position (); + [NoWrapper] + public virtual void reserved1 (); + [NoWrapper] + public virtual void reserved2 (); + [NoWrapper] + public virtual void reserved3 (); + [NoWrapper] + public virtual void reserved4 (); + [NoWrapper] + public virtual void reserved5 (); + public void set_environment (string[] env); + public virtual signal void accessible_desc_update (Indicator.ObjectEntry entry); + public virtual signal void entry_added (Indicator.ObjectEntry entry); + public virtual signal void entry_moved (Indicator.ObjectEntry entry, uint old_pos, uint new_pos); + public virtual signal void entry_removed (Indicator.ObjectEntry entry); + public virtual signal void entry_scrolled (Indicator.ObjectEntry entry, uint delta, Indicator.ScrollDirection direction); + public virtual signal void menu_show (Indicator.ObjectEntry entry, uint timestamp); + public virtual signal void show_now_changed (Indicator.ObjectEntry entry, bool show_now_state); + } + [CCode (cheader_filename = "libindicator/indicator-ng.h")] + public class Ng : Object { + [CCode (has_construct_function = false)] + public Ng.for_profile (string filename, string profile) throws GLib.Error; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public class ObjectEntry { + public weak string accessible_desc; + public weak Gtk.Image image; + public weak Gtk.Label label; + public weak Gtk.Menu menu; + public weak string name_hint; + public weak GLib.Callback reserved1; + public weak GLib.Callback reserved2; + public weak GLib.Callback reserved3; + public weak GLib.Callback reserved4; + public static void activate (Indicator.Object io, Indicator.ObjectEntry entry, uint timestamp); + public static void close (Indicator.Object io, Indicator.ObjectEntry entry, uint timestamp); + } + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public class Service : GLib.Object { + [CCode (has_construct_function = false)] + public Service (string name); + [NoWrapper] + public virtual void indicator_service_reserved1 (); + [NoWrapper] + public virtual void indicator_service_reserved2 (); + [NoWrapper] + public virtual void indicator_service_reserved3 (); + [NoWrapper] + public virtual void indicator_service_reserved4 (); + [CCode (has_construct_function = false)] + public Service.version (string name, uint version); + [NoAccessorMethod] + public string name { owned get; set; } + public virtual signal void shutdown (); + } + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public class ServiceManager : GLib.Object { + [CCode (has_construct_function = false)] + public ServiceManager (string dbus_name); + public bool connected (); + [NoWrapper] + public virtual void indicator_service_manager_reserved1 (); + [NoWrapper] + public virtual void indicator_service_manager_reserved2 (); + [NoWrapper] + public virtual void indicator_service_manager_reserved3 (); + [NoWrapper] + public virtual void indicator_service_manager_reserved4 (); + public void set_refresh (uint time_in_ms); + [CCode (has_construct_function = false)] + public ServiceManager.version (string dbus_name, uint version); + [NoAccessorMethod] + public string name { owned get; set; } + public virtual signal void connection_change (bool connected); + } + [CCode (cprefix = "INDICATOR_OBJECT_SCROLL_", has_type_id = false, cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public enum ScrollDirection { + UP, + DOWN, + LEFT, + RIGHT + } + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h", has_target = false)] + public delegate GLib.Type get_type_t (); + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h", has_target = false)] + public delegate unowned string get_version_t (); + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string GET_TYPE_S; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string GET_VERSION_S; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string OBJECT_SIGNAL_ACCESSIBLE_DESC_UPDATE; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string OBJECT_SIGNAL_ENTRY_ADDED; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string OBJECT_SIGNAL_ENTRY_MOVED; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string OBJECT_SIGNAL_ENTRY_REMOVED; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string OBJECT_SIGNAL_ENTRY_SCROLLED; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string OBJECT_SIGNAL_MENU_SHOW; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string OBJECT_SIGNAL_SHOW_NOW_CHANGED; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string SERVICE_SIGNAL_SHUTDOWN; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const int SET_VERSION; + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public const string VERSION; + [CCode (cname = "get_version", cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public static unowned string get_version (); + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public static unowned Gtk.Image image_helper (string name); + [CCode (cheader_filename = "gtk/gtk.h,libindicator/indicator.h,libindicator/indicator-desktop-shortcuts.h,libindicator/indicator-image-helper.h,libindicator/indicator-object.h,libindicator/indicator-service.h,libindicator/indicator-service-manager.h")] + public static void image_helper_update (Gtk.Image image, string name); +} + +[CCode (cheader_filename="libido/libido.h", lower_case_cprefix = "ido_")] +namespace Ido { + public void init (); +} diff --git a/src/list-stack.vala b/src/list-stack.vala new file mode 100644 index 0000000..cd9745d --- /dev/null +++ b/src/list-stack.vala @@ -0,0 +1,92 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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/>. + * + * Authored by: Michael Terry <michael.terry@canonical.com> + */ + +public class ListStack : Gtk.Fixed +{ + public uint num_children + { + get + { + var children = get_children (); + return children.length (); + } + } + + private int width; + + construct + { + width = grid_size * GreeterList.BOX_WIDTH; + } + + public GreeterList? top () + { + var children = get_children (); + if (children == null) + return null; + else + return children.last ().data as GreeterList; + } + + public void push (GreeterList pushed) + { + return_if_fail (pushed != null); + + var children = get_children (); + + pushed.start_scrolling = false; + pushed.set_size_request (width, -1); + add (pushed); + + if (children != null) + { + var current = children.last ().data as GreeterList; + /* Clear any errors so when we come back, they will be gone. */ + current.selected_entry.reset_state (); + current.greeter_box.push (pushed); + } + } + + public void pop () + { + var children = get_children (); + + return_if_fail (children != null); + + unowned List<Gtk.Widget> prev = children.last ().prev; + if (prev != null) + (prev.data as GreeterList).greeter_box.pop (); + } + + public override void size_allocate (Gtk.Allocation allocation) + { + base.size_allocate (allocation); + var children = get_children (); + foreach (var child in children) + { + child.size_allocate (allocation); + } + } + + public override void get_preferred_width (out int min, out int nat) + { + min = width; + nat = width; + } +} diff --git a/src/logo-generator.vala b/src/logo-generator.vala new file mode 100644 index 0000000..244c4b3 --- /dev/null +++ b/src/logo-generator.vala @@ -0,0 +1,46 @@ +public class Main : Object +{ + + private static string? file = null; + private static string? text = null; + private static string? result = null; + private const OptionEntry[] options = { + {"logo", 0, 0, OptionArg.FILENAME, ref file, "Path to logo", "LOGO"}, + {"text", 0, 0, OptionArg.STRING, ref text, "Sublogo text", "TEXT"}, + {"output", 0, 0, OptionArg.FILENAME, ref result, "Path to rendered output", "OUTPUT"}, + {null} + }; + + public static int main(string[] args) { + try { + var opt_context = new OptionContext ("- OptionContext example"); + opt_context.set_help_enabled (true); + opt_context.add_main_entries (options, null); + opt_context.parse (ref args); + } catch (OptionError e) { + stdout.printf ("error: %s\n", e.message); + stdout.printf ("Run '%s --help' to see a full list of available command line options.\n", args[0]); + return 0; + } + Cairo.ImageSurface surface = new Cairo.ImageSurface (Cairo.Format.ARGB32, 245, 43); + Cairo.Context context = new Cairo.Context (surface); + context.translate (42, 11); + Cairo.ImageSurface logo = new Cairo.ImageSurface.from_png (file); + context.set_source_surface (logo, 0, 0); + context.paint(); + + context.set_source_rgba (1, 1, 1, 1); + context.translate (logo.get_width() + 0.25*logo.get_height(), logo.get_height()); + + var font_description = new Pango.FontDescription(); + font_description.set_family("Ubuntu"); + font_description.set_size((int)(0.75*logo.get_height() * Pango.SCALE)); + var layout = Pango.cairo_create_layout (context); + layout.set_font_description (font_description); + layout.set_text (text, -1); + Pango.cairo_show_layout_line(context, layout.get_line(0)); + + surface.write_to_png(result); + return 0; + } +} diff --git a/src/main-window.vala b/src/main-window.vala new file mode 100644 index 0000000..7574719 --- /dev/null +++ b/src/main-window.vala @@ -0,0 +1,398 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +public class MainWindow : Gtk.Window +{ + public MenuBar menubar; + + private List<Monitor> monitors; + private Monitor? primary_monitor; + private Monitor active_monitor; + private Background background; + private Gtk.Box login_box; + private Gtk.Box hbox; + private Gtk.Button back_button; + private ShutdownDialog? shutdown_dialog = null; + + public ListStack stack; + + // Menubar is smaller, but with shadow, we reserve more space + public static const int MENUBAR_HEIGHT = 32; + + construct + { + events |= Gdk.EventMask.POINTER_MOTION_MASK; + + var accel_group = new Gtk.AccelGroup (); + add_accel_group (accel_group); + + var bg_color = Gdk.RGBA (); + bg_color.parse (UGSettings.get_string (UGSettings.KEY_BACKGROUND_COLOR)); + override_background_color (Gtk.StateFlags.NORMAL, bg_color); + get_accessible ().set_name (_("Login Screen")); + has_resize_grip = false; + UnityGreeter.add_style_class (this); + + realize (); + background = new Background (Gdk.cairo_create (get_window ()).get_target ()); + background.draw_grid = UGSettings.get_boolean (UGSettings.KEY_DRAW_GRID); + background.default_background = UGSettings.get_string (UGSettings.KEY_BACKGROUND); + background.set_logo (UGSettings.get_string (UGSettings.KEY_LOGO), UGSettings.get_string (UGSettings.KEY_BACKGROUND_LOGO)); + background.show (); + add (background); + UnityGreeter.add_style_class (background); + + login_box = new Gtk.Box (Gtk.Orientation.VERTICAL, 0); + login_box.show (); + background.add (login_box); + + /* Box for menubar shadow */ + var menubox = new Gtk.EventBox (); + var menualign = new Gtk.Alignment (0.0f, 0.0f, 1.0f, 0.0f); + var shadow_path = Path.build_filename (Config.PKGDATADIR, + "shadow.png", null); + var shadow_style = ""; + if (FileUtils.test (shadow_path, FileTest.EXISTS)) + { + shadow_style = "background-image: url('%s'); + background-repeat: repeat;".printf(shadow_path); + } + try + { + var style = new Gtk.CssProvider (); + style.load_from_data ("* {background-color: transparent; + %s + }".printf(shadow_style), -1); + var context = menubox.get_style_context (); + context.add_provider (style, + Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading menubox style: %s", e.message); + } + menubox.set_size_request (-1, MENUBAR_HEIGHT); + menubox.show (); + menualign.show (); + menubox.add (menualign); + login_box.add (menubox); + UnityGreeter.add_style_class (menualign); + UnityGreeter.add_style_class (menubox); + + menubar = new MenuBar (background, accel_group); + menubar.show (); + menualign.add (menubar); + UnityGreeter.add_style_class (menubar); + + hbox = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 0); + hbox.expand = true; + hbox.show (); + login_box.add (hbox); + + var align = new Gtk.Alignment (0.5f, 0.5f, 0.0f, 0.0f); + align.set_size_request (grid_size, -1); + align.margin_bottom = MENUBAR_HEIGHT; /* offset for menubar at top */ + align.show (); + hbox.add (align); + + back_button = new FlatButton (); + back_button.get_accessible ().set_name (_("Back")); + back_button.focus_on_click = false; + var image = new Gtk.Image.from_file (Path.build_filename (Config.PKGDATADIR, "arrow_left.png", null)); + image.show (); + back_button.set_size_request (grid_size - GreeterList.BORDER * 2, grid_size - GreeterList.BORDER * 2); + back_button.add (image); + back_button.clicked.connect (pop_list); + align.add (back_button); + + align = new Gtk.Alignment (0.0f, 0.5f, 0.0f, 1.0f); + align.show (); + hbox.add (align); + + stack = new ListStack (); + stack.show (); + align.add (stack); + + add_user_list (); + + if (UnityGreeter.singleton.test_mode) + { + /* Simulate an 800x600 monitor to the left of a 640x480 monitor */ + monitors = new List<Monitor> (); + monitors.append (new Monitor (0, 0, 800, 600)); + monitors.append (new Monitor (800, 120, 640, 480)); + background.set_monitors (monitors); + move_to_monitor (monitors.nth_data (0)); + resize (800 + 640, 600); + } + else + { + var screen = get_screen (); + screen.monitors_changed.connect (monitors_changed_cb); + monitors_changed_cb (screen); + } + } + + public void push_list (GreeterList widget) + { + stack.push (widget); + + if (stack.num_children > 1) + back_button.show (); + } + + public void pop_list () + { + if (stack.num_children <= 2) + back_button.hide (); + + stack.pop (); + } + + public override void size_allocate (Gtk.Allocation allocation) + { + base.size_allocate (allocation); + + if (hbox != null) + { + hbox.margin_left = get_grid_offset (get_allocated_width ()) + grid_size; + hbox.margin_right = get_grid_offset (get_allocated_width ()); + hbox.margin_top = get_grid_offset (get_allocated_height ()); + hbox.margin_bottom = get_grid_offset (get_allocated_height ()); + } + } + + private void monitors_changed_cb (Gdk.Screen screen) + { + int primary = screen.get_primary_monitor (); + debug ("Screen is %dx%d pixels", screen.get_width (), screen.get_height ()); + monitors = new List<Monitor> (); + primary_monitor = null; + + for (var i = 0; i < screen.get_n_monitors (); i++) + { + Gdk.Rectangle geometry; + screen.get_monitor_geometry (i, out geometry); + debug ("Monitor %d is %dx%d pixels at %d,%d", i, geometry.width, geometry.height, geometry.x, geometry.y); + + if (monitor_is_unique_position (screen, i)) + { + var monitor = new Monitor (geometry.x, geometry.y, geometry.width, geometry.height); + monitors.append (monitor); + + if (primary_monitor == null || i == primary) + primary_monitor = monitor; + } + } + + background.set_monitors (monitors); + resize (screen.get_width (), screen.get_height ()); + move (0, 0); + move_to_monitor (primary_monitor); + } + + /* Check if a monitor has a unique position */ + private bool monitor_is_unique_position (Gdk.Screen screen, int n) + { + Gdk.Rectangle g0; + screen.get_monitor_geometry (n, out g0); + + for (var i = n + 1; i < screen.get_n_monitors (); i++) + { + Gdk.Rectangle g1; + screen.get_monitor_geometry (i, out g1); + + if (g0.x == g1.x && g0.y == g1.y) + return false; + } + + return true; + } + + public override bool motion_notify_event (Gdk.EventMotion event) + { + var x = (int) (event.x + 0.5); + var y = (int) (event.y + 0.5); + + /* Get motion event relative to this widget */ + if (event.window != get_window ()) + { + int w_x, w_y; + get_window ().get_origin (out w_x, out w_y); + x -= w_x; + y -= w_y; + event.window.get_origin (out w_x, out w_y); + x += w_x; + y += w_y; + } + + foreach (var m in monitors) + { + if (x >= m.x && x <= m.x + m.width && y >= m.y && y <= m.y + m.height) + { + move_to_monitor (m); + break; + } + } + + return false; + } + + private void move_to_monitor (Monitor monitor) + { + active_monitor = monitor; + login_box.set_size_request (monitor.width, monitor.height); + background.set_active_monitor (monitor); + background.move (login_box, monitor.x, monitor.y); + + if (shutdown_dialog != null) + { + shutdown_dialog.set_active_monitor (monitor); + background.move (shutdown_dialog, monitor.x, monitor.y); + } + } + + private void add_user_list () + { + GreeterList greeter_list; + greeter_list = new UserList (background, menubar); + greeter_list.show (); + UnityGreeter.add_style_class (greeter_list); + push_list (greeter_list); + } + + public override bool key_press_event (Gdk.EventKey event) + { + var top = stack.top (); + + if (stack.top () is UserList) + { + var user_list = stack.top () as UserList; + if (!user_list.show_hidden_users) + { + var shift_mask = Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD1_MASK; + var control_mask = Gdk.ModifierType.SHIFT_MASK | Gdk.ModifierType.MOD1_MASK; + var alt_mask = Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK; + if (((event.keyval == Gdk.Key.Shift_L || event.keyval == Gdk.Key.Shift_R) && (event.state & shift_mask) == shift_mask) || + ((event.keyval == Gdk.Key.Control_L || event.keyval == Gdk.Key.Control_R) && (event.state & control_mask) == control_mask) || + ((event.keyval == Gdk.Key.Alt_L || event.keyval == Gdk.Key.Alt_R) && (event.state & alt_mask) == alt_mask)) + { + debug ("Hidden user key combination detected"); + user_list.show_hidden_users = true; + return true; + } + } + } + + switch (event.keyval) + { + case Gdk.Key.Escape: + if (login_box.sensitive) + top.cancel_authentication (); + if (shutdown_dialog != null) + shutdown_dialog.cancel (); + return true; + case Gdk.Key.Page_Up: + case Gdk.Key.KP_Page_Up: + if (login_box.sensitive) + top.scroll (GreeterList.ScrollTarget.START); + return true; + case Gdk.Key.Page_Down: + case Gdk.Key.KP_Page_Down: + if (login_box.sensitive) + top.scroll (GreeterList.ScrollTarget.END); + return true; + case Gdk.Key.Up: + case Gdk.Key.KP_Up: + if (login_box.sensitive) + top.scroll (GreeterList.ScrollTarget.UP); + return true; + case Gdk.Key.Down: + case Gdk.Key.KP_Down: + if (login_box.sensitive) + top.scroll (GreeterList.ScrollTarget.DOWN); + return true; + case Gdk.Key.Left: + case Gdk.Key.KP_Left: + if (shutdown_dialog != null) + shutdown_dialog.focus_prev (); + return true; + case Gdk.Key.Right: + case Gdk.Key.KP_Right: + if (shutdown_dialog != null) + shutdown_dialog.focus_next (); + return true; + case Gdk.Key.F10: + if (login_box.sensitive) + menubar.select_first (false); + return true; + case Gdk.Key.PowerOff: + show_shutdown_dialog (ShutdownDialogType.SHUTDOWN); + return true; + case Gdk.Key.z: + if (UnityGreeter.singleton.test_mode && (event.state & Gdk.ModifierType.MOD1_MASK) != 0) + { + show_shutdown_dialog (ShutdownDialogType.SHUTDOWN); + return true; + } + break; + case Gdk.Key.Z: + if (UnityGreeter.singleton.test_mode && (event.state & Gdk.ModifierType.MOD1_MASK) != 0) + { + show_shutdown_dialog (ShutdownDialogType.RESTART); + return true; + } + break; + } + + return base.key_press_event (event); + } + + public void set_keyboard_state () + { + menubar.set_keyboard_state (); + } + + public void show_shutdown_dialog (ShutdownDialogType type) + { + if (shutdown_dialog != null) + shutdown_dialog.destroy (); + + /* Stop input to login box */ + login_box.sensitive = false; + + shutdown_dialog = new ShutdownDialog (type, background); + shutdown_dialog.closed.connect (close_shutdown_dialog); + background.add (shutdown_dialog); + move_to_monitor (active_monitor); + shutdown_dialog.visible = true; + } + + public void close_shutdown_dialog () + { + if (shutdown_dialog == null) + return; + + shutdown_dialog.destroy (); + shutdown_dialog = null; + + login_box.sensitive = true; + } +} diff --git a/src/menu.vala b/src/menu.vala new file mode 100644 index 0000000..71e70b1 --- /dev/null +++ b/src/menu.vala @@ -0,0 +1,47 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Andrea Cimitan <andrea.cimitan@canonical.com> + */ + + +public class Menu : Gtk.Menu +{ + public Background? background { get; construct; default = null; } + + public Menu (Background bg) + { + Object (background: bg); + } + + public override bool draw (Cairo.Context c) + { + if (background != null) + { + int x, y, bg_x, bg_y; + + background.get_window ().get_origin (out bg_x, out bg_y); + get_window ().get_origin (out x, out y); + c.save (); + c.translate (bg_x - x, bg_y - y); + background.draw_full (c, Background.DrawFlags.NONE); + c.restore (); + } + + base.draw (c); + return false; + } +} diff --git a/src/menubar.vala b/src/menubar.vala new file mode 100644 index 0000000..79783da --- /dev/null +++ b/src/menubar.vala @@ -0,0 +1,559 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +private class IndicatorMenuItem : Gtk.MenuItem +{ + public unowned Indicator.ObjectEntry entry; + private Gtk.Box hbox; + + public IndicatorMenuItem (Indicator.ObjectEntry entry) + { + this.entry = entry; + this.hbox = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3); + this.add (this.hbox); + this.hbox.show (); + + if (entry.label != null) + { + entry.label.show.connect (this.visibility_changed_cb); + entry.label.hide.connect (this.visibility_changed_cb); + hbox.pack_start (entry.label, false, false, 0); + } + if (entry.image != null) + { + entry.image.show.connect (visibility_changed_cb); + entry.image.hide.connect (visibility_changed_cb); + hbox.pack_start (entry.image, false, false, 0); + } + if (entry.accessible_desc != null) + get_accessible ().set_name (entry.accessible_desc); + if (entry.menu != null) + set_submenu (entry.menu as Gtk.Widget); + + if (has_visible_child ()) + show (); + } + + public bool has_visible_child () + { + return (entry.image != null && entry.image.get_visible ()) || + (entry.label != null && entry.label.get_visible ()); + } + + public void visibility_changed_cb (Gtk.Widget widget) + { + visible = has_visible_child (); + } +} + +public class MenuBar : Gtk.MenuBar +{ + public Background? background { get; construct; default = null; } + public bool high_contrast { get; private set; default = false; } + public Gtk.Window? keyboard_window { get; private set; default = null; } + public Gtk.AccelGroup? accel_group { get; construct; } + + private static const int HEIGHT = 24; + + public MenuBar (Background bg, Gtk.AccelGroup ag) + { + Object (background: bg, accel_group: ag); + } + + public override bool draw (Cairo.Context c) + { + if (background != null) + { + int x, y; + background.translate_coordinates (this, 0, 0, out x, out y); + c.save (); + c.translate (x, y); + background.draw_full (c, Background.DrawFlags.NONE); + c.restore (); + } + + c.set_source_rgb (0.1, 0.1, 0.1); + c.paint_with_alpha (0.4); + + foreach (var child in get_children ()) + { + propagate_draw (child, c); + } + + return false; + } + + /* Due to LP #973922 the keyboard has to be loaded after the main window + * is shown and given focus. Therefore we don't enable the active state + * until now. + */ + public void set_keyboard_state () + { + onscreen_keyboard_item.set_active (UGSettings.get_boolean (UGSettings.KEY_ONSCREEN_KEYBOARD)); + } + + private string default_theme_name; + private List<Indicator.Object> indicator_objects; + private Gtk.CheckMenuItem high_contrast_item; + private Pid keyboard_pid = 0; + private Pid reader_pid = 0; + private Gtk.CheckMenuItem onscreen_keyboard_item; + + construct + { + Gtk.Settings.get_default ().get ("gtk-theme-name", out default_theme_name); + + pack_direction = Gtk.PackDirection.RTL; + + if (UGSettings.get_boolean (UGSettings.KEY_SHOW_HOSTNAME)) + { + var label = new Gtk.Label (Posix.utsname ().nodename); + label.show (); + var hostname_item = new Gtk.MenuItem (); + hostname_item.add (label); + hostname_item.sensitive = false; + hostname_item.right_justified = true; + hostname_item.show (); + append (hostname_item); + + /* Hack to get a label showing on the menubar */ + label.ensure_style (); + var fg = label.get_style_context ().get_color (Gtk.StateFlags.NORMAL); + label.override_color (Gtk.StateFlags.INSENSITIVE, fg); + } + + /* Prevent dragging the window by the menubar */ + try + { + var style = new Gtk.CssProvider (); + style.load_from_data ("* {-GtkWidget-window-dragging: false;}", -1); + get_style_context ().add_provider (style, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading menubar style: %s", e.message); + } + + setup_indicators (); + + UnityGreeter.singleton.starting_session.connect (cleanup); + } + + private void close_pid (ref Pid pid) + { + if (pid > 0) + { + Posix.kill (pid, Posix.SIGTERM); + int status; + Posix.waitpid (pid, out status, 0); + pid = 0; + } + } + + public void cleanup () + { + close_pid (ref keyboard_pid); + close_pid (ref reader_pid); + } + + public override void get_preferred_height (out int min, out int nat) + { + min = HEIGHT; + nat = HEIGHT; + } + + private void greeter_set_env (string key, string val) + { + GLib.Environment.set_variable (key, val, true); + + /* And also set it in the DBus activation environment so that any + * indicator services pick it up. */ + try + { + var proxy = new GLib.DBusProxy.for_bus_sync (GLib.BusType.SESSION, + GLib.DBusProxyFlags.NONE, null, + "org.freedesktop.DBus", + "/org/freedesktop/DBus", + "org.freedesktop.DBus", + null); + + var builder = new GLib.VariantBuilder (GLib.VariantType.ARRAY); + builder.add ("{ss}", key, val); + + proxy.call_sync ("UpdateActivationEnvironment", new GLib.Variant ("(a{ss})", builder), GLib.DBusCallFlags.NONE, -1, null); + } + catch (Error e) + { + warning ("Could not get set environment for indicators: %s", e.message); + return; + } + } + + private Gtk.Widget make_a11y_indicator () + { + var a11y_item = new Gtk.MenuItem (); + var hbox = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3); + hbox.show (); + a11y_item.add (hbox); + var image = new Gtk.Image.from_file (Path.build_filename (Config.PKGDATADIR, "a11y.svg")); + image.show (); + hbox.add (image); + a11y_item.show (); + a11y_item.set_submenu (new Gtk.Menu () as Gtk.Widget); + onscreen_keyboard_item = new Gtk.CheckMenuItem.with_label (_("Onscreen keyboard")); + onscreen_keyboard_item.toggled.connect (keyboard_toggled_cb); + onscreen_keyboard_item.show (); + unowned Gtk.Menu submenu = a11y_item.submenu; + submenu.append (onscreen_keyboard_item); + high_contrast_item = new Gtk.CheckMenuItem.with_label (_("High Contrast")); + high_contrast_item.toggled.connect (high_contrast_toggled_cb); + high_contrast_item.add_accelerator ("activate", accel_group, Gdk.Key.h, Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE); + high_contrast_item.show (); + submenu.append (high_contrast_item); + high_contrast_item.set_active (UGSettings.get_boolean (UGSettings.KEY_HIGH_CONTRAST)); + var item = new Gtk.CheckMenuItem.with_label (_("Screen Reader")); + item.toggled.connect (screen_reader_toggled_cb); + item.add_accelerator ("activate", accel_group, Gdk.Key.s, Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE); + item.show (); + submenu.append (item); + item.set_active (UGSettings.get_boolean (UGSettings.KEY_SCREEN_READER)); + return a11y_item; + } + + private Indicator.Object? load_indicator_file (string indicator_name) + { + string dir = Config.INDICATOR_FILE_DIR; + string path; + Indicator.Object io; + + /* To stay backwards compatible, use com.canonical.indicator as the default prefix */ + if (indicator_name.index_of_char ('.') < 0) + path = @"$dir/com.canonical.indicator.$indicator_name"; + else + path = @"$dir/$indicator_name"; + + try + { + io = new Indicator.Ng.for_profile (path, "desktop_greeter"); + } + catch (FileError error) + { + /* the calling code handles file-not-found; don't warn here */ + return null; + } + catch (Error error) + { + warning ("unable to load %s: %s", indicator_name, error.message); + return null; + } + + return io; + } + + private Indicator.Object? load_indicator_library (string indicator_name) + { + // Find file, if it exists + string[] names_to_try = {"lib" + indicator_name + ".so", + indicator_name + ".so", + indicator_name}; + foreach (var filename in names_to_try) + { + var full_path = Path.build_filename (Config.INDICATORDIR, filename); + var io = new Indicator.Object.from_file (full_path); + if (io != null) + return io; + } + + return null; + } + + private void load_indicator (string indicator_name) + { + if (indicator_name == "ug-accessibility") + { + var a11y_item = make_a11y_indicator (); + insert (a11y_item, (int) get_children ().length () - 1); + } + else + { + var io = load_indicator_file (indicator_name); + + if (io == null) + io = load_indicator_library (indicator_name); + + if (io != null) + { + indicator_objects.append (io); + io.entry_added.connect (indicator_added_cb); + io.entry_removed.connect (indicator_removed_cb); + foreach (var entry in io.get_entries ()) + indicator_added_cb (io, entry); + } + } + } + + private void setup_indicators () + { + /* Set indicators to run with reduced functionality */ + greeter_set_env ("INDICATOR_GREETER_MODE", "1"); + + /* Don't allow virtual file systems? */ + greeter_set_env ("GIO_USE_VFS", "local"); + greeter_set_env ("GVFS_DISABLE_FUSE", "1"); + + /* Hint to have unity-settings-daemon run in greeter mode */ + greeter_set_env ("RUNNING_UNDER_GDM", "1"); + + /* Let indicators know about our unique dbus name */ + try + { + var conn = Bus.get_sync (BusType.SESSION); + greeter_set_env ("UNITY_GREETER_DBUS_NAME", conn.get_unique_name ()); + } + catch (IOError e) + { + debug ("Could not set DBUS_NAME: %s", e.message); + } + + debug ("LANG=%s LANGUAGE=%s", Environment.get_variable ("LANG"), Environment.get_variable ("LANGUAGE")); + + var indicator_list = UGSettings.get_strv(UGSettings.KEY_INDICATORS); + + var update_indicator_list = false; + for (var i = 0; i < indicator_list.length; i++) + { + if (indicator_list[i] == "ug-keyboard") + { + indicator_list[i] = "com.canonical.indicator.keyboard"; + update_indicator_list = true; + } + } + + if (update_indicator_list) + UGSettings.set_strv(UGSettings.KEY_INDICATORS, indicator_list); + + foreach (var indicator in indicator_list) + load_indicator(indicator); + + indicator_objects.sort((a, b) => { + int pos_a = a.get_position (); + int pos_b = b.get_position (); + + if (pos_a < 0) + pos_a = 1000; + if (pos_b < 0) + pos_b = 1000; + + return pos_a - pos_b; + }); + + debug ("LANG=%s LANGUAGE=%s", Environment.get_variable ("LANG"), Environment.get_variable ("LANGUAGE")); + } + + private void keyboard_toggled_cb (Gtk.CheckMenuItem item) + { + /* FIXME: The below would be sufficient if gnome-session were running + * to notice and run a screen keyboard in /etc/xdg/autostart... But + * since we're not running gnome-session, we hardcode onboard here. */ + /* var settings = new Settings ("org.gnome.desktop.a11y.applications");*/ + /*settings.set_boolean ("screen-keyboard-enabled", item.active);*/ + + UGSettings.set_boolean (UGSettings.KEY_ONSCREEN_KEYBOARD, item.active); + + if (keyboard_window == null) + { + int id = 0; + + try + { + string[] argv; + int onboard_stdout_fd; + + Shell.parse_argv ("onboard --xid", out argv); + Process.spawn_async_with_pipes (null, + argv, + null, + SpawnFlags.SEARCH_PATH, + null, + out keyboard_pid, + null, + out onboard_stdout_fd, + null); + var f = FileStream.fdopen (onboard_stdout_fd, "r"); + var stdout_text = new char[1024]; + if (f.gets (stdout_text) != null) + id = int.parse ((string) stdout_text); + + } + catch (Error e) + { + warning ("Error setting up keyboard: %s", e.message); + return; + } + + var keyboard_socket = new Gtk.Socket (); + keyboard_socket.show (); + keyboard_window = new Gtk.Window (); + keyboard_window.accept_focus = false; + keyboard_window.focus_on_map = false; + keyboard_window.add (keyboard_socket); + keyboard_socket.add_id (id); + + /* Put keyboard at the bottom of the screen */ + var screen = get_screen (); + var monitor = screen.get_monitor_at_window (get_window ()); + Gdk.Rectangle geom; + screen.get_monitor_geometry (monitor, out geom); + keyboard_window.move (geom.x, geom.y + geom.height - 200); + keyboard_window.resize (geom.width, 200); + } + + keyboard_window.visible = item.active; + } + + private void high_contrast_toggled_cb (Gtk.CheckMenuItem item) + { + var settings = Gtk.Settings.get_default (); + if (item.active) + settings.set ("gtk-theme-name", "HighContrastInverse"); + else + settings.set ("gtk-theme-name", default_theme_name); + high_contrast = item.active; + UGSettings.set_boolean (UGSettings.KEY_HIGH_CONTRAST, high_contrast); + } + + private void screen_reader_toggled_cb (Gtk.CheckMenuItem item) + { + /* FIXME: The below would be sufficient if gnome-session were running + * to notice and run a screen reader in /etc/xdg/autostart... But + * since we're not running gnome-session, we hardcode orca here. + /*var settings = new Settings ("org.gnome.desktop.a11y.applications");*/ + /*settings.set_boolean ("screen-reader-enabled", item.active);*/ + + UGSettings.set_boolean (UGSettings.KEY_SCREEN_READER, item.active); + + /* Hardcoded orca: */ + if (item.active) + { + try + { + string[] argv; + Shell.parse_argv ("orca --replace --no-setup --disable splash-window,", out argv); + Process.spawn_async (null, + argv, + null, + SpawnFlags.SEARCH_PATH, + null, + out reader_pid); + // This is a workaroud for bug https://launchpad.net/bugs/944159 + // The problem is that orca seems to not notice that it's in a + // password field on startup. We just need to kick orca in the + // pants. We do this two ways: a racy way and a non-racy way. + // We kick it after a second which is ideal if we win the race, + // because the user gets to hear what widget they are in, and + // the first character will be masked. Otherwise, if we lose + // that race, the first time the user types (see + // DashEntry.key_press_event), we will kick orca again. While + // this is not racy with orca startup, it is racy with whether + // orca will read the first character or not out loud. Hence + // why we do both. Ideally this would be fixed in orca itself. + UnityGreeter.singleton.orca_needs_kick = true; + Timeout.add_seconds (1, () => { + Signal.emit_by_name ((get_toplevel () as Gtk.Window).get_focus ().get_accessible (), "focus-event", true); + return false; + }); + } + catch (Error e) + { + warning ("Failed to run Orca: %s", e.message); + } + } + else + close_pid (ref reader_pid); + } + + private uint get_indicator_index (Indicator.Object object) + { + uint index = 0; + + foreach (var io in indicator_objects) + { + if (io == object) + return index; + index++; + } + + return index; + } + + private Indicator.Object? get_indicator_object_from_entry (Indicator.ObjectEntry entry) + { + foreach (var io in indicator_objects) + { + foreach (var e in io.get_entries ()) + { + if (e == entry) + return io; + } + } + + return null; + } + + private void indicator_added_cb (Indicator.Object object, Indicator.ObjectEntry entry) + { + var index = get_indicator_index (object); + var pos = 0; + foreach (var child in get_children ()) + { + if (!(child is IndicatorMenuItem)) + break; + + var menuitem = (IndicatorMenuItem) child; + var child_object = get_indicator_object_from_entry (menuitem.entry); + var child_index = get_indicator_index (child_object); + if (child_index > index) + break; + pos++; + } + + debug ("Adding indicator object %p at position %d", entry, pos); + + var menuitem = new IndicatorMenuItem (entry); + insert (menuitem, pos); + } + + private void indicator_removed_cb (Indicator.Object object, Indicator.ObjectEntry entry) + { + debug ("Removing indicator object %p", entry); + + foreach (var child in get_children ()) + { + var menuitem = (IndicatorMenuItem) child; + if (menuitem.entry == entry) + { + remove (child); + return; + } + } + + warning ("Indicator object %p not in menubar", entry); + } +} diff --git a/src/prompt-box.vala b/src/prompt-box.vala new file mode 100644 index 0000000..894870d --- /dev/null +++ b/src/prompt-box.vala @@ -0,0 +1,663 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +public class PromptBox : FadableBox +{ + public signal void respond (string[] response); + public signal void login (); + public signal void show_options (); + public signal void name_clicked (); + + public bool has_errors { get; set; default = false; } + public string id { get; construct; } + + public string label + { + get { return name_label.label; } + set + { + name_label.label = value; + small_name_label.label = value; + } + } + + public double position { get; set; default = 0; } + + private Gtk.Fixed fixed; + private Gtk.Widget zone; /* when overlapping zone we are fully expanded */ + + /* Expanded widgets */ + protected Gtk.Grid box_grid; + protected Gtk.Grid name_grid; + private ActiveIndicator active_indicator; + protected FadingLabel name_label; + protected FlatButton option_button; + private CachedImage option_image; + private CachedImage message_image; + + /* Condensed widgets */ + protected Gtk.Widget small_box_widget; + private ActiveIndicator small_active_indicator; + protected FadingLabel small_name_label; + private CachedImage small_message_image; + + protected static const int COL_ACTIVE = 0; + protected static const int COL_CONTENT = 1; + protected static const int COL_SPACER = 2; + + protected static const int ROW_NAME = 0; + protected static const int COL_NAME_LABEL = 0; + protected static const int COL_NAME_MESSAGE = 1; + protected static const int COL_NAME_OPTIONS = 2; + + protected static const int COL_ENTRIES_START = 1; + protected static const int COL_ENTRIES_END = 1; + protected static const int COL_ENTRIES_WIDTH = 1; + + protected int start_row; + protected int last_row; + + private enum PromptVisibility + { + HIDDEN, + FADING, + SHOWN, + } + private PromptVisibility prompt_visibility = PromptVisibility.HIDDEN; + + public PromptBox (string id) + { + Object (id: id); + } + + construct + { + set_start_row (); + reset_last_row (); + expand = true; + + fixed = new Gtk.Fixed (); + fixed.show (); + add (fixed); + + box_grid = new Gtk.Grid (); + box_grid.column_spacing = 4; + box_grid.row_spacing = 3; + box_grid.margin_top = GreeterList.BORDER; + box_grid.margin_bottom = 6; + box_grid.expand = true; + + /** Grid layout: + 0 1 2 3 4 + > Name M S < + Message....... + Entry......... + */ + + active_indicator = new ActiveIndicator (); + active_indicator.valign = Gtk.Align.START; + active_indicator.margin_top = (grid_size - ActiveIndicator.HEIGHT) / 2; + active_indicator.show (); + box_grid.attach (active_indicator, COL_ACTIVE, last_row, 1, 1); + + /* Add a second one on right just for equal-spacing purposes */ + var dummy_indicator = new ActiveIndicator (); + dummy_indicator.show (); + box_grid.attach (dummy_indicator, COL_SPACER, last_row, 1, 1); + + box_grid.show (); + + /* Create fully expanded version of ourselves */ + name_grid = create_name_grid (); + box_grid.attach (name_grid, COL_CONTENT, last_row, 1, 1); + + /* Now prep small versions of the above normal widgets. These are + * used when scrolling outside of the main dash box. */ + var small_box_grid = new Gtk.Grid (); + small_box_grid.column_spacing = 4; + small_box_grid.row_spacing = 6; + small_box_grid.hexpand = true; + small_box_grid.show (); + + small_active_indicator = new ActiveIndicator (); + small_active_indicator.valign = Gtk.Align.START; + small_active_indicator.margin_top = (grid_size - ActiveIndicator.HEIGHT) / 2; + small_active_indicator.show (); + small_box_grid.attach (small_active_indicator, 0, 0, 1, 1); + + var small_name_grid = create_small_name_grid (); + small_box_grid.attach (small_name_grid, 1, 0, 1, 1); + + /* Add a second indicator on right just for equal-spacing purposes */ + var small_dummy_indicator = new ActiveIndicator (); + small_dummy_indicator.show (); + small_box_grid.attach (small_dummy_indicator, 3, 0, 1, 1); + + var small_box_eventbox = new Gtk.EventBox (); + small_box_eventbox.visible_window = false; + small_box_eventbox.button_release_event.connect (() => + { + name_clicked (); + return true; + }); + small_box_eventbox.add (small_box_grid); + small_box_eventbox.show (); + small_box_widget = small_box_eventbox; + + fixed.add (small_box_widget); + fixed.add (box_grid); + } + + protected virtual Gtk.Grid create_name_grid () + { + var name_grid = new Gtk.Grid (); + name_grid.column_spacing = 4; + name_grid.hexpand = true; + + name_label = new FadingLabel (""); + name_label.override_font (Pango.FontDescription.from_string ("Ubuntu 13")); + name_label.override_color (Gtk.StateFlags.NORMAL, { 1.0f, 1.0f, 1.0f, 1.0f }); + name_label.valign = Gtk.Align.START; + name_label.vexpand = true; + name_label.yalign = 0.5f; + name_label.xalign = 0.0f; + name_label.margin_left = 2; + name_label.set_size_request (-1, grid_size); + name_label.show (); + name_grid.attach (name_label, COL_NAME_LABEL, ROW_NAME, 1, 1); + + message_image = new CachedImage (null); + try + { + message_image.pixbuf = new Gdk.Pixbuf.from_file (Path.build_filename (Config.PKGDATADIR, "message.png", null)); + } + catch (Error e) + { + debug ("Error loading message image: %s", e.message); + } + + var align = new Gtk.Alignment (0.5f, 0.5f, 0.0f, 0.0f); + align.valign = Gtk.Align.START; + align.set_size_request (-1, grid_size); + align.add (message_image); + align.show (); + name_grid.attach (align, COL_NAME_MESSAGE, ROW_NAME, 1, 1); + + option_button = new FlatButton (); + option_button.hexpand = true; + option_button.halign = Gtk.Align.END; + option_button.valign = Gtk.Align.START; + // Keep as much space on top as on the right + option_button.margin_top = ActiveIndicator.WIDTH + box_grid.column_spacing; + option_button.focus_on_click = false; + option_button.relief = Gtk.ReliefStyle.NONE; + option_button.get_accessible ().set_name (_("Session Options")); + option_button.clicked.connect (option_button_clicked_cb); + option_image = new CachedImage (null); + option_image.show (); + try + { + var style = new Gtk.CssProvider (); + style.load_from_data ("* {padding: 2px;}", -1); + option_button.get_style_context ().add_provider (style, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading session chooser style: %s", e.message); + } + option_button.add (option_image); + name_grid.attach (option_button, COL_NAME_OPTIONS, ROW_NAME, 1, 1); + + name_grid.show (); + + return name_grid; + } + + protected virtual Gtk.Grid create_small_name_grid () + { + var small_name_grid = new Gtk.Grid (); + small_name_grid.column_spacing = 4; + + small_name_label = new FadingLabel (""); + small_name_label.override_font (Pango.FontDescription.from_string ("Ubuntu 13")); + small_name_label.override_color (Gtk.StateFlags.NORMAL, { 1.0f, 1.0f, 1.0f, 1.0f }); + small_name_label.yalign = 0.5f; + small_name_label.xalign = 0.0f; + small_name_label.margin_left = 2; + small_name_label.set_size_request (-1, grid_size); + small_name_label.show (); + small_name_grid.attach (small_name_label, 1, 0, 1, 1); + + small_message_image = new CachedImage (null); + small_message_image.pixbuf = message_image.pixbuf; + + var align = new Gtk.Alignment (0.5f, 0.5f, 0.0f, 0.0f); + align.set_size_request (-1, grid_size); + align.add (small_message_image); + align.show (); + small_name_grid.attach (align, 2, 0, 1, 1); + + small_name_grid.show (); + return small_name_grid; + } + + protected virtual void set_start_row () + { + start_row = 0; + } + + protected virtual void reset_last_row () + { + last_row = start_row; + } + + private int round_to_grid (int size) + { + var num_grids = size / grid_size; + var remainder = size % grid_size; + if (remainder > 0) + num_grids += 1; + num_grids = int.max (num_grids, 3); + return num_grids * grid_size; + } + + public override void get_preferred_height (out int min, out int nat) + { + base.get_preferred_height (out min, out nat); + min = round_to_grid (min + GreeterList.BORDER * 2) - GreeterList.BORDER * 2; + nat = round_to_grid (nat + GreeterList.BORDER * 2) - GreeterList.BORDER * 2; + } + + public void set_zone (Gtk.Widget zone) + { + this.zone = zone; + queue_draw (); + } + + public void set_options_image (Gdk.Pixbuf? image) + { + if (option_button == null) + return; + + option_image.pixbuf = image; + + if (image == null) + option_button.hide (); + else + option_button.show (); + } + + private void option_button_clicked_cb (Gtk.Button button) + { + show_options (); + } + + public void set_show_message_icon (bool show) + { + message_image.visible = show; + small_message_image.visible = show; + } + + public void set_is_active (bool active) + { + active_indicator.active = active; + small_active_indicator.active = active; + } + + protected void foreach_prompt_widget (Gtk.Callback cb) + { + var prompt_widgets = new List<Gtk.Widget> (); + + var i = start_row + 1; + while (i <= last_row) + { + var c = box_grid.get_child_at (COL_ENTRIES_START, i); + if (c != null) /* c might have been deleted from selective clear */ + prompt_widgets.append (c); + i++; + } + + foreach (var w in prompt_widgets) + cb (w); + } + + public void clear () + { + prompt_visibility = PromptVisibility.HIDDEN; + foreach_prompt_widget ((w) => { w.destroy (); }); + reset_last_row (); + has_errors = false; + } + + /* Clears error messages */ + public void reset_messages () + { + has_errors = false; + foreach_prompt_widget ((w) => + { + var is_error = w.get_data<bool> ("prompt-box-is-error"); + if (is_error) + w.destroy (); + }); + } + + /* Stops spinners */ + public void reset_spinners () + { + foreach_prompt_widget ((w) => + { + if (w is DashEntry) + { + var e = w as DashEntry; + e.did_respond = false; + } + }); + } + + /* Clears error messages and stops spinners. Basically gets the box back to a filled-by-user-but-no-status state. */ + public void reset_state () + { + reset_messages (); + reset_spinners (); + } + + public virtual void add_static_prompts () + { + /* Subclasses may want to add prompts that are always present here */ + } + + private void update_prompt_visibility (Gtk.Widget w) + { + switch (prompt_visibility) + { + case PromptVisibility.HIDDEN: + w.hide (); + break; + case PromptVisibility.FADING: + var f = w as Fadable; + w.sensitive = true; + if (f != null) + f.fade_in (); + else + w.show (); + break; + case PromptVisibility.SHOWN: + w.show (); + w.sensitive = true; + break; + } + } + + public void fade_in_prompts () + { + prompt_visibility = PromptVisibility.FADING; + show (); + foreach_prompt_widget ((w) => { update_prompt_visibility (w); }); + } + + public void show_prompts () + { + prompt_visibility = PromptVisibility.SHOWN; + show (); + foreach_prompt_widget ((w) => { update_prompt_visibility (w); }); + } + + protected void attach_item (Gtk.Widget w, bool add_style_class = true) + { + w.set_data ("prompt-box-widget", this); + if (add_style_class) + UnityGreeter.add_style_class (w); + + last_row += 1; + box_grid.attach (w, COL_ENTRIES_START, last_row, COL_ENTRIES_WIDTH, 1); + + update_prompt_visibility (w); + queue_resize (); + } + + public void add_message (string text, bool is_error) + { + var label = new FadingLabel (text); + + label.override_font (Pango.FontDescription.from_string ("Ubuntu 10")); + + Gdk.RGBA color = { 1.0f, 1.0f, 1.0f, 1.0f }; + if (is_error) + color.parse ("#df382c"); + label.override_color (Gtk.StateFlags.NORMAL, color); + + label.xalign = 0.0f; + label.set_data<bool> ("prompt-box-is-error", is_error); + + attach_item (label); + + if (is_error) + has_errors = true; + } + + public DashEntry add_prompt (string text, string? accessible_text, bool is_secret) + { + /* Stop other entry's arrows/spinners from showing */ + foreach_prompt_widget ((w) => + { + if (w is DashEntry) + { + var e = w as DashEntry; + if (e != null) + e.can_respond = false; + } + }); + + var entry = new DashEntry (); + entry.sensitive = false; + + if (text.contains ("\n")) + { + add_message (text, false); + entry.constant_placeholder_text = ""; + } + else + { + /* Strip trailing colon if present (also handle CJK version) */ + var placeholder = text; + if (placeholder.has_suffix (":") || placeholder.has_suffix ("：")) + { + var len = placeholder.char_count (); + placeholder = placeholder.substring (0, placeholder.index_of_nth_char (len - 1)); + } + entry.constant_placeholder_text = placeholder; + } + + var accessible = entry.get_accessible (); + if (accessible_text != null) + accessible.set_name (accessible_text); + else + accessible.set_name (text); + + if (is_secret) + { + entry.visibility = false; + entry.caps_lock_warning = true; + } + + entry.respond.connect (entry_activate_cb); + + attach_item (entry); + + return entry; + } + + public Gtk.ComboBox add_combo (GenericArray<string> texts, bool read_only) + { + Gtk.ComboBoxText combo; + if (read_only) + combo = new Gtk.ComboBoxText (); + else + combo = new Gtk.ComboBoxText.with_entry (); + + combo.get_style_context ().add_class ("lightdm-combo"); + combo.get_child ().get_style_context ().add_class ("lightdm-combo"); + combo.get_child ().override_font (Pango.FontDescription.from_string (DashEntry.font)); + + attach_item (combo, false); + + texts.foreach ((text) => { combo.append_text (text); }); + + if (texts.length > 0) + combo.active = 0; + + return combo; + } + + protected void entry_activate_cb () + { + var response = new string[0]; + + foreach_prompt_widget ((w) => + { + if (w is Gtk.Entry) + { + var e = w as Gtk.Entry; + if (e != null) + response += e.text; + } + }); + respond (response); + } + + public void add_button (string text, string? accessible_text) + { + var button = new DashButton (text); + + var accessible = button.get_accessible (); + accessible.set_name (accessible_text); + + button.clicked.connect (button_clicked_cb); + + attach_item (button); + } + + private void button_clicked_cb (Gtk.Button button) + { + login (); + } + + public override void grab_focus () + { + var done = false; + Gtk.Widget best = null; + foreach_prompt_widget ((w) => + { + if (done) + return; + best = w; /* last entry wins, all else considered */ + var e = w as Gtk.Entry; + var b = w as Gtk.Button; + var c = w as Gtk.ComboBox; + + /* We've found ideal entry (first empty one), so stop looking */ + if ((e != null && e.text == "") || b != null || c != null) + done = true; + }); + if (best != null) + best.grab_focus (); + } + + public override void size_allocate (Gtk.Allocation allocation) + { + base.size_allocate (allocation); + box_grid.size_allocate (allocation); + + int small_height; + small_box_widget.get_preferred_height (null, out small_height); + allocation.height = small_height; + small_box_widget.size_allocate (allocation); + } + + public override void draw_full_alpha (Cairo.Context c) + { + /* Draw either small or normal version of ourselves, depending on where + our allocation put us relative to our zone */ + int x, y; + zone.translate_coordinates (this, 0, 0, out x, out y); + + Gtk.Allocation alloc, zone_alloc; + this.get_allocation (out alloc); + zone.get_allocation (out zone_alloc); + + /* Draw main grid only in that area */ + c.save (); + c.rectangle (x, y, zone_alloc.width, zone_alloc.height); + c.clip (); + fixed.propagate_draw (box_grid, c); + c.restore (); + + /* Do actual drawing */ + c.save (); + if (y > 0) + c.rectangle (x, 0, zone_alloc.width, y); + else + c.rectangle (x, y + zone_alloc.height, zone_alloc.width, -y); + c.clip (); + fixed.propagate_draw (small_box_widget, c); + c.restore (); + } +} + +private class ActiveIndicator : Gtk.Image +{ + public bool active { get; set; } + public static const int WIDTH = 8; + public static const int HEIGHT = 7; + + construct + { + var filename = Path.build_filename (Config.PKGDATADIR, "active.png"); + try + { + pixbuf = new Gdk.Pixbuf.from_file (filename); + } + catch (Error e) + { + debug ("Could not load active image: %s", e.message); + } + notify["active"].connect (() => { queue_draw (); }); + xalign = 0.0f; + } + + public override void get_preferred_width (out int min, out int nat) + { + min = WIDTH; + nat = min; + } + + public override void get_preferred_height (out int min, out int nat) + { + min = HEIGHT; + nat = min; + } + + public override bool draw (Cairo.Context c) + { + if (!active) + return false; + return base.draw (c); + } +} diff --git a/src/remote-login-service.vala b/src/remote-login-service.vala new file mode 100644 index 0000000..7099ac2 --- /dev/null +++ b/src/remote-login-service.vala @@ -0,0 +1,54 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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/>. + * + */ + +protected struct RemoteServerField +{ + public string type; + public bool required; + public Variant default_value; + public HashTable<string, Variant> properties; +} + +protected struct RemoteServerApplication +{ + public string application_id; + public int pin_position; +} + +protected struct RemoteServer +{ + public string type; + public string name; + public string url; + public bool last_used_server; + public RemoteServerField[] fields; + public RemoteServerApplication[] applications; +} + +[DBus (name = "com.canonical.RemoteLogin")] +interface RemoteLoginService : Object +{ + public abstract async void get_servers (out RemoteServer[] serverList) throws IOError; + public abstract async void get_servers_for_login (string url, string emailAddress, string password, bool allowCache, out bool loginSuccess, out string dataType, out RemoteServer[] serverList) throws IOError; + public abstract async void get_cached_domains_for_server (string url, out string[] domains) throws IOError; + public abstract async void set_last_used_server (string uccsUrl, string serverUrl) throws IOError; + + public signal void servers_updated (RemoteServer[] serverList); + public signal void login_servers_updated (string url, string emailAddress, string dataType, RemoteServer[] serverList); + public signal void login_changed (string url, string emailAddress); +} diff --git a/src/session-list.vala b/src/session-list.vala new file mode 100644 index 0000000..7127023 --- /dev/null +++ b/src/session-list.vala @@ -0,0 +1,158 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +public class SessionPrompt : PromptBox +{ + public string session { get; construct; } + public string default_session { get; construct; } + + public SessionPrompt (string id, string? session, string? default_session) + { + Object (id: id, session: session, default_session: default_session); + } + + private ToggleBox box; + + construct + { + label = _("Select desktop environment"); + name_label.vexpand = false; + + box = new ToggleBox (default_session, session); + + if (UnityGreeter.singleton.test_mode) + { + box.add_item ("gnome", "GNOME", SessionList.get_badge ("gnome")); + box.add_item ("kde", "KDE", SessionList.get_badge ("kde")); + box.add_item ("ubuntu", "Ubuntu", SessionList.get_badge ("ubuntu")); + } + else + { + foreach (var session in LightDM.get_sessions ()) + { + debug ("Adding session %s (%s)", session.key, session.name); + box.add_item (session.key, session.name, SessionList.get_badge (session.key)); + } + } + + box.notify["selected-key"].connect (selected_cb); + box.show (); + + attach_item (box); + } + + private void selected_cb () + { + respond ({ box.selected_key }); + } +} + +public class SessionList : GreeterList +{ + public signal void session_clicked (string session); + public string session { get; construct; } + public string default_session { get; construct; } + + private SessionPrompt prompt; + + public SessionList (Background bg, MenuBar mb, string? session, string? default_session) + { + Object (background: bg, menubar: mb, session: session, default_session: default_session); + } + + construct + { + prompt = add_session_prompt ("session"); + } + + private SessionPrompt add_session_prompt (string id) + { + var e = new SessionPrompt (id, session, default_session); + e.respond.connect ((responses) => { session_clicked (responses[0]); }); + add_entry (e); + return e; + } + + protected override void add_manual_entry () {} + public override void show_authenticated (bool successful = true) {} + + private static string? get_badge_name (string session) + { + switch (session) + { + case "ubuntu": + case "ubuntu-2d": + return "ubuntu_badge.png"; + case "gnome-classic": + case "gnome-flashback-compiz": + case "gnome-flashback": + case "gnome-fallback-compiz": + case "gnome-fallback": + case "gnome-shell": + case "gnome": + return "gnome_badge.png"; + case "kde": + case "kde-plasma": + return "kde_badge.png"; + case "xterm": + return "recovery_console_badge.png"; + case "remote-login": + return "remote_login_help.png"; + default: + return null; + } + } + + private static HashTable<string, Gdk.Pixbuf> badges; /* cache of badges */ + public static Gdk.Pixbuf? get_badge (string session) + { + var name = get_badge_name (session); + + if (name == null) + { + /* Not a known name, but let's see if we have a custom badge before + giving up entirely and using the unknown badget. */ + var maybe_name = "custom_%s_badge.png".printf (session); + var maybe_path = Path.build_filename (Config.PKGDATADIR, maybe_name, null); + if (FileUtils.test (maybe_path, FileTest.EXISTS)) + name = maybe_name; + else + name = "unknown_badge.png"; + } + + if (badges == null) + badges = new HashTable<string, Gdk.Pixbuf> (str_hash, str_equal); + + var pixbuf = badges.lookup (name); + if (pixbuf == null) + { + try + { + pixbuf = new Gdk.Pixbuf.from_file (Path.build_filename (Config.PKGDATADIR, name, null)); + badges.insert (name, pixbuf); + } + catch (Error e) + { + debug ("Error loading badge %s: %s", name, e.message); + } + } + + return pixbuf; + } +} diff --git a/src/settings-daemon.vala b/src/settings-daemon.vala new file mode 100644 index 0000000..9cf3908 --- /dev/null +++ b/src/settings-daemon.vala @@ -0,0 +1,234 @@ +/* -*- Mode:Vala; indent-tabs-mode:nil; tab-width:4 -*- + * + * Copyright (C) 2011 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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/>. + * + * Authored by: Michael Terry <michael.terry@canonical.com> + */ + +public class SettingsDaemon : Object +{ + private int logind_inhibit_fd = -1; + private ScreenSaverInterface screen_saver; + private SessionManagerInterface session_manager; + private int n_names = 0; + + public void start () + { + string[] disabled = { "org.gnome.settings-daemon.plugins.background", + "org.gnome.settings-daemon.plugins.clipboard", + "org.gnome.settings-daemon.plugins.font", + "org.gnome.settings-daemon.plugins.gconf", + "org.gnome.settings-daemon.plugins.gsdwacom", + "org.gnome.settings-daemon.plugins.housekeeping", + "org.gnome.settings-daemon.plugins.keybindings", + "org.gnome.settings-daemon.plugins.keyboard", + "org.gnome.settings-daemon.plugins.media-keys", + "org.gnome.settings-daemon.plugins.mouse", + "org.gnome.settings-daemon.plugins.print-notifications", + "org.gnome.settings-daemon.plugins.smartcard", + "org.gnome.settings-daemon.plugins.sound", + "org.gnome.settings-daemon.plugins.wacom" }; + + string[] enabled = { "org.gnome.settings-daemon.plugins.a11y-keyboard", + "org.gnome.settings-daemon.plugins.a11y-settings", + "org.gnome.settings-daemon.plugins.color", + "org.gnome.settings-daemon.plugins.cursor", + "org.gnome.settings-daemon.plugins.power", + "org.gnome.settings-daemon.plugins.xrandr", + "org.gnome.settings-daemon.plugins.xsettings" }; + + foreach (var schema in disabled) + set_plugin_enabled (schema, false); + + foreach (var schema in enabled) + set_plugin_enabled (schema, true); + + /* Pretend to be GNOME session */ + session_manager = new SessionManagerInterface (); + n_names++; + GLib.Bus.own_name (BusType.SESSION, "org.gnome.SessionManager", BusNameOwnerFlags.NONE, + (c) => + { + try + { + c.register_object ("/org/gnome/SessionManager", session_manager); + } + catch (Error e) + { + warning ("Failed to register /org/gnome/SessionManager: %s", e.message); + } + }, + () => + { + debug ("Acquired org.gnome.SessionManager"); + start_settings_daemon (); + }, + () => debug ("Failed to acquire name org.gnome.SessionManager")); + + /* The power plugin does the screen saver screen blanking and disables + * the builtin X screen saver. It relies on gnome-screensaver to generate + * the event to trigger this (which actually comes from gnome-session). + * We implement the gnome-screensaver inteface and start the settings + * daemon once it is registered on the bus so gnome-screensaver is not + * started when it accesses this interface */ + screen_saver = new ScreenSaverInterface (); + n_names++; + GLib.Bus.own_name (BusType.SESSION, "org.gnome.ScreenSaver", BusNameOwnerFlags.NONE, + (c) => + { + try + { + c.register_object ("/org/gnome/ScreenSaver", screen_saver); + } + catch (Error e) + { + warning ("Failed to register /org/gnome/ScreenSaver: %s", e.message); + } + }, + () => + { + debug ("Acquired org.gnome.ScreenSaver"); + start_settings_daemon (); + }, + () => debug ("Failed to acquire name org.gnome.ScreenSaver")); + + /* The media-keys plugin inhibits the power key, but we don't want + all the other keys doing things. So inhibit it ourselves */ + /* NOTE: We are using the synchronous method here since there is a bug in Vala/GLib in that + * g_dbus_connection_call_with_unix_fd_list_finish and g_dbus_proxy_call_with_unix_fd_list_finish + * don't have the GAsyncResult as the second argument. + * https://bugzilla.gnome.org/show_bug.cgi?id=688907 + */ + try + { + var b = Bus.get_sync (BusType.SYSTEM); + UnixFDList fd_list; + var result = b.call_with_unix_fd_list_sync ("org.freedesktop.login1", + "/org/freedesktop/login1", + "org.freedesktop.login1.Manager", + "Inhibit", + new Variant ("(ssss)", + "handle-power-key", + Environment.get_user_name (), + "Unity Greeter handling keypresses", + "block"), + new VariantType ("(h)"), + DBusCallFlags.NONE, + -1, + null, + out fd_list); + int32 index = -1; + result.get ("(h)", &index); + logind_inhibit_fd = fd_list.get (index); + } + catch (Error e) + { + warning ("Failed to inhibit power keys: %s", e.message); + } + } + + private void set_plugin_enabled (string schema_name, bool enabled) + { + var source = SettingsSchemaSource.get_default (); + var schema = source.lookup (schema_name, false); + if (schema != null) + { + var settings = new Settings (schema_name); + settings.set_boolean ("active", enabled); + } + } + + private void start_settings_daemon () + { + n_names--; + if (n_names != 0) + return; + + debug ("All bus names acquired, starting unity-settings-daemon"); + + try + { + Process.spawn_command_line_async (Config.USD_BINARY); + } + catch (SpawnError e) + { + debug ("Could not start unity-settings-daemon: %s", e.message); + } + } +} + +[DBus (name="org.gnome.ScreenSaver")] +public class ScreenSaverInterface : Object +{ + public signal void active_changed (bool value); + + private Gnome.IdleMonitor idle_monitor; + private bool _active = false; + private uint idle_watch = 0; + + public ScreenSaverInterface () + { + idle_monitor = new Gnome.IdleMonitor (); + _set_active (false); + } + + private void _set_active (bool value) + { + _active = value; + if (idle_watch != 0) + idle_monitor.remove_watch (idle_watch); + idle_watch = 0; + if (value) + idle_monitor.add_user_active_watch (() => set_active (false)); + else + { + var timeout = UGSettings.get_integer (UGSettings.KEY_IDLE_TIMEOUT); + if (timeout > 0) + idle_watch = idle_monitor.add_idle_watch (timeout * 1000, () => set_active (true)); + } + } + + public void set_active (bool value) + { + if (_active == value) + return; + + if (value) + debug ("Screensaver activated"); + else + debug ("Screensaver disabled"); + + _set_active (value); + active_changed (value); + } + + public bool get_active () + { + return _active; + } + + public uint32 get_active_time () { return 0; } + public void lock () {} + public void show_message (string summary, string body, string icon) {} + public void simulate_user_activity () {} +} + +[DBus (name="org.gnome.SessionManager")] +public class SessionManagerInterface : Object +{ + public bool session_is_active { get { return true; } } + public string session_name { get { return "ubuntu"; } } + public uint32 inhibited_actions { get { return 0; } } +} diff --git a/src/settings.vala b/src/settings.vala new file mode 100644 index 0000000..ebdc9e7 --- /dev/null +++ b/src/settings.vala @@ -0,0 +1,101 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +public class UGSettings +{ + public static const string KEY_BACKGROUND = "background"; + public static const string KEY_BACKGROUND_COLOR = "background-color"; + public static const string KEY_DRAW_USER_BACKGROUNDS = "draw-user-backgrounds"; + public static const string KEY_DRAW_GRID = "draw-grid"; + public static const string KEY_SHOW_HOSTNAME = "show-hostname"; + public static const string KEY_LOGO = "logo"; + public static const string KEY_BACKGROUND_LOGO = "background-logo"; + public static const string KEY_THEME_NAME = "theme-name"; + public static const string KEY_ICON_THEME_NAME = "icon-theme-name"; + public static const string KEY_FONT_NAME = "font-name"; + public static const string KEY_XFT_ANTIALIAS = "xft-antialias"; + public static const string KEY_XFT_DPI = "xft-dpi"; + public static const string KEY_XFT_HINTSTYLE = "xft-hintstyle"; + public static const string KEY_XFT_RGBA = "xft-rgba"; + public static const string KEY_ONSCREEN_KEYBOARD = "onscreen-keyboard"; + public static const string KEY_HIGH_CONTRAST = "high-contrast"; + public static const string KEY_SCREEN_READER = "screen-reader"; + public static const string KEY_PLAY_READY_SOUND = "play-ready-sound"; + public static const string KEY_INDICATORS = "indicators"; + public static const string KEY_HIDDEN_USERS = "hidden-users"; + public static const string KEY_IDLE_TIMEOUT = "idle-timeout"; + + public static bool get_boolean (string key) + { + var gsettings = new Settings (SCHEMA); + return gsettings.get_boolean (key); + } + + /* LP: 1006497 - utility function to make sure we have the key before trying to read it (which will segfault if the key isn't there) */ + public static bool safe_get_boolean (string key, bool default) + { + var gsettings = new Settings (SCHEMA); + string[] keys = gsettings.list_keys (); + foreach (var k in keys) + if (k == key) + return gsettings.get_boolean (key); + + /* key not in child list */ + return default; + } + + public static int get_integer (string key) + { + var gsettings = new Settings (SCHEMA); + return gsettings.get_int (key); + } + + public static double get_double (string key) + { + var gsettings = new Settings (SCHEMA); + return gsettings.get_double (key); + } + + public static string get_string (string key) + { + var gsettings = new Settings (SCHEMA); + return gsettings.get_string (key); + } + + public static bool set_boolean (string key, bool value) + { + var gsettings = new Settings (SCHEMA); + return gsettings.set_boolean (key, value); + } + + public static string[] get_strv (string key) + { + var gsettings = new Settings (SCHEMA); + return gsettings.get_strv (key); + } + + public static bool set_strv (string key, string[] value) + { + var gsettings = new Settings (SCHEMA); + return gsettings.set_strv (key, value); + } + + private static const string SCHEMA = "com.canonical.unity-greeter"; +} diff --git a/src/shutdown-dialog.vala b/src/shutdown-dialog.vala new file mode 100644 index 0000000..73e1bf4 --- /dev/null +++ b/src/shutdown-dialog.vala @@ -0,0 +1,622 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2013 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Marco Trevisan <marco.trevisan@canonical.com> + */ + +public enum ShutdownDialogType +{ + LOGOUT, + SHUTDOWN, + RESTART +} + +public class ShutdownDialog : Gtk.Fixed +{ + public signal void closed (); + + private Cairo.ImageSurface? bg_surface = null; + private Cairo.ImageSurface? corner_surface = null; + private Cairo.ImageSurface? left_surface = null; + private Cairo.ImageSurface? top_surface = null; + private Cairo.Pattern? corner_pattern = null; + private Cairo.Pattern? left_pattern = null; + private Cairo.Pattern? top_pattern = null; + + private const int BORDER_SIZE = 30; + private const int BORDER_INTERNAL_SIZE = 10; + private const int BORDER_EXTERNAL_SIZE = BORDER_SIZE - BORDER_INTERNAL_SIZE; + private const int CLOSE_OFFSET = 3; + private const int BUTTON_TEXT_SPACE = 9; + private const int BLUR_RADIUS = 8; + + private Monitor monitor; + private weak Background background; + private Gdk.RGBA avg_color; + + private Gtk.Box vbox; + private DialogButton close_button; + private Gtk.Box button_box; + private Gtk.EventBox monitor_events; + private Gtk.EventBox vbox_events; + + private AnimateTimer animation; + private bool closing = false; + + + public ShutdownDialog (ShutdownDialogType type, Background bg) + { + background = bg; + background.notify["alpha"].connect (rebuild_background); + background.notify["average-color"].connect (update_background_color); + update_background_color (); + + // This event box covers the monitor size, and closes the dialog on click. + monitor_events = new Gtk.EventBox (); + monitor_events.visible = true; + monitor_events.set_visible_window (false); + monitor_events.events |= Gdk.EventMask.BUTTON_PRESS_MASK; + monitor_events.button_press_event.connect (() => { + close (); + return true; + }); + add (monitor_events); + + vbox = new Gtk.Box (Gtk.Orientation.VERTICAL, 10); + vbox.visible = true; + + vbox.margin = BORDER_INTERNAL_SIZE; + vbox.margin_top += 9; + vbox.margin_left += 20; + vbox.margin_right += 20; + vbox.margin_bottom += 2; + + // This event box consumes the click events inside the vbox + vbox_events = new Gtk.EventBox(); + vbox_events.visible = true; + vbox_events.set_visible_window (false); + vbox_events.events |= Gdk.EventMask.BUTTON_PRESS_MASK; + vbox_events.button_press_event.connect (() => { return true; }); + vbox_events.add (vbox); + monitor_events.add (vbox_events); + + string text; + + if (type == ShutdownDialogType.SHUTDOWN) + { + text = _("Goodbye. Would you like to…"); + } + else + { + var title_label = new Gtk.Label (_("Shut Down")); + title_label.visible = true; + title_label.override_font (Pango.FontDescription.from_string ("Ubuntu Light 15")); + title_label.override_color (Gtk.StateFlags.NORMAL, { 1.0f, 1.0f, 1.0f, 1.0f }); + title_label.set_alignment (0.0f, 0.5f); + vbox.pack_start (title_label, false, false, 0); + + text = _("Are you sure you want to shut down the computer?"); + } + + var have_open_sessions = false; + try + { + var b = Bus.get_sync (BusType.SYSTEM); + var result = b.call_sync ("org.freedesktop.DisplayManager", + "/org/freedesktop/DisplayManager", + "org.freedesktop.DBus.Properties", + "Get", + new Variant ("(ss)", "org.freedesktop.DisplayManager", "Sessions"), + new VariantType ("(v)"), + DBusCallFlags.NONE, + -1, + null); + Variant value; + result.get ("(v)", out value); + have_open_sessions = value.n_children () > 0; + } + catch (Error e) + { + warning ("Failed to check sessions from logind: %s", e.message); + } + if (have_open_sessions) + text = "%s\n\n%s".printf (_("Other users are currently logged in to this computer, shutting down now will also close these other sessions."), text); + + var label = new Gtk.Label (text); + label.set_line_wrap (true); + label.override_font (Pango.FontDescription.from_string ("Ubuntu Light 12")); + label.override_color (Gtk.StateFlags.NORMAL, { 1.0f, 1.0f, 1.0f, 1.0f }); + label.set_alignment (0.0f, 0.5f); + label.visible = true; + vbox.pack_start (label, false, false, 0); + + button_box = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 20); + button_box.visible = true; + vbox.pack_start (button_box, false, false, 0); + + if (type == ShutdownDialogType.SHUTDOWN) + { + if (LightDM.get_can_suspend ()) + { + var button = add_button (_("Suspend"), Path.build_filename (Config.PKGDATADIR, "suspend.png"), Path.build_filename (Config.PKGDATADIR, "suspend_highlight.png")); + button.clicked.connect (() => + { + try + { + LightDM.suspend (); + close (); + } + catch (Error e) + { + warning ("Failed to suspend: %s", e.message); + } + }); + } + + if (LightDM.get_can_hibernate ()) + { + var button = add_button (_("Hibernate"), Path.build_filename (Config.PKGDATADIR, "hibernate.png"), Path.build_filename (Config.PKGDATADIR, "hibernate_highlight.png")); + button.clicked.connect (() => + { + try + { + LightDM.hibernate (); + close (); + } + catch (Error e) + { + warning ("Failed to hibernate: %s", e.message); + } + }); + } + } + + if (LightDM.get_can_restart ()) + { + var button = add_button (_("Restart"), Path.build_filename (Config.PKGDATADIR, "restart.png"), Path.build_filename (Config.PKGDATADIR, "restart_highlight.png")); + button.clicked.connect (() => + { + try + { + LightDM.restart (); + close (); + } + catch (Error e) + { + warning ("Failed to restart: %s", e.message); + } + }); + } + + if (LightDM.get_can_shutdown ()) + { + var button = add_button (_("Shut Down"), Path.build_filename (Config.PKGDATADIR, "shutdown.png"), Path.build_filename (Config.PKGDATADIR, "shutdown_highlight.png")); + button.clicked.connect (() => + { + try + { + LightDM.shutdown (); + close (); + } + catch (Error e) + { + warning ("Failed to shutdown: %s", e.message); + } + }); + + if (type != ShutdownDialogType.SHUTDOWN) + show.connect(() => { button.grab_focus (); }); + } + + close_button = new DialogButton (Path.build_filename (Config.PKGDATADIR, "dialog_close.png"), Path.build_filename (Config.PKGDATADIR, "dialog_close_highlight.png"), Path.build_filename (Config.PKGDATADIR, "dialog_close_press.png")); + close_button.can_focus = false; + close_button.clicked.connect (() => { close (); }); + close_button.visible = true; + add (close_button); + + animation = new AnimateTimer ((x) => { return x; }, AnimateTimer.INSTANT); + animation.animate.connect (() => { queue_draw (); }); + show.connect (() => { animation.reset(); }); + } + + public void close () + { + var start_value = 1.0f - animation.progress; + animation = new AnimateTimer ((x) => { return start_value + x; }, AnimateTimer.INSTANT); + animation.animate.connect ((p) => + { + queue_draw (); + + if (p >= 1.0f) + { + animation.stop (); + closed (); + } + }); + + closing = true; + animation.reset(); + } + + private void rebuild_background () + { + bg_surface = null; + queue_draw (); + } + + private void update_background_color () + { + // Apply the same color corrections we do in Unity + // For reference, see unity's unity-shared/BGHash.cpp + double hue, saturation, value; + const double COLOR_ALPHA = 0.72f; + + Gdk.RGBA color = background.average_color; + Gtk.RGB.to_hsv (color.red, color.green, color.blue, + out hue, out saturation, out value); + + if (saturation < 0.08) + { + // Got a grayscale image + avg_color = {0.18f, 0.20f, 0.21f, COLOR_ALPHA }; + } + else + { + const Gdk.RGBA[] cmp_colors = + { + {84/255.0f, 14/255.0f, 68/255.0f, 1.0f}, + {110/255.0f, 11/255.0f, 42/255.0f, 1.0f}, + {132/255.0f, 22/255.0f, 23/255.0f, 1.0f}, + {132/255.0f, 55/255.0f, 27/255.0f, 1.0f}, + {134/255.0f, 77/255.0f, 32/255.0f, 1.0f}, + {133/255.0f, 127/255.0f, 49/255.0f, 1.0f}, + {29/255.0f, 99/255.0f, 49/255.0f, 1.0f}, + {17/255.0f, 88/255.0f, 46/255.0f, 1.0f}, + {14/255.0f, 89/255.0f, 85/255.0f, 1.0f}, + {25/255.0f, 43/255.0f, 89/255.0f, 1.0f}, + {27/255.0f, 19/255.0f, 76/255.0f, 1.0f}, + {2/255.0f, 192/255.0f, 212/255.0f, 1.0f} + }; + + avg_color = {0, 0, 0, 1}; + double closest_diff = 200.0f; + + foreach (var c in cmp_colors) + { + double cmp_hue, cmp_sat, cmp_value; + Gtk.RGB.to_hsv (c.red, c.green, c.blue, + out cmp_hue, out cmp_sat, out cmp_value); + double color_diff = Math.fabs (hue - cmp_hue); + + if (color_diff < closest_diff) + { + avg_color = c; + closest_diff = color_diff; + } + } + + double new_hue, new_saturation, new_value; + Gtk.RGB.to_hsv (avg_color.red, avg_color.green, avg_color.blue, + out new_hue, out new_saturation, out new_value); + + saturation = double.min (saturation, new_saturation); + saturation *= (2.0f - saturation); + value = double.min (double.min (value, new_value), 0.26f); + Gtk.HSV.to_rgb (hue, saturation, value, + out avg_color.red, out avg_color.green, out avg_color.blue); + avg_color.alpha = COLOR_ALPHA; + } + + rebuild_background (); + } + + public void set_active_monitor (Monitor m) + { + if (m == this.monitor || m.equals (this.monitor)) + return; + + monitor = m; + rebuild_background (); + set_size_request (monitor.width, monitor.height); + } + + public void focus_next () + { + (get_toplevel () as Gtk.Window).move_focus (Gtk.DirectionType.TAB_FORWARD); + } + + public void focus_prev () + { + (get_toplevel () as Gtk.Window).move_focus (Gtk.DirectionType.TAB_BACKWARD); + } + + public void cancel () + { + var widget = (get_toplevel () as Gtk.Window).get_focus (); + if (widget is DialogButton) + (get_toplevel () as Gtk.Window).set_focus (null); + else + close (); + } + + public override void size_allocate (Gtk.Allocation allocation) + { + base.size_allocate (allocation); + monitor_events.size_allocate (allocation); + + var content_allocation = Gtk.Allocation (); + int minimum_width, natural_width, minimum_height, natural_height; + vbox_events.get_preferred_width (out minimum_width, out natural_width); + vbox_events.get_preferred_height_for_width (minimum_width, out minimum_height, out natural_height); + content_allocation.x = allocation.x + (allocation.width - minimum_width) / 2; + content_allocation.y = allocation.y + (allocation.height - minimum_height) / 2; + content_allocation.width = minimum_width; + content_allocation.height = minimum_height; + vbox_events.size_allocate (content_allocation); + + var a = Gtk.Allocation (); + close_button.get_preferred_width (out minimum_width, out natural_width); + close_button.get_preferred_height (out minimum_height, out natural_height); + a.x = content_allocation.x - BORDER_EXTERNAL_SIZE + CLOSE_OFFSET; + a.y = content_allocation.y - BORDER_EXTERNAL_SIZE + CLOSE_OFFSET; + a.width = minimum_width; + a.height = minimum_height; + close_button.size_allocate (a); + } + + public override bool draw (Cairo.Context c) + { + if (corner_surface == null) + { + corner_surface = new Cairo.ImageSurface.from_png (Path.build_filename (Config.PKGDATADIR, "switcher_corner.png")); + left_surface = new Cairo.ImageSurface.from_png (Path.build_filename (Config.PKGDATADIR, "switcher_left.png")); + top_surface = new Cairo.ImageSurface.from_png (Path.build_filename (Config.PKGDATADIR, "switcher_top.png")); + corner_pattern = new Cairo.Pattern.for_surface (corner_surface); + left_pattern = new Cairo.Pattern.for_surface (left_surface); + left_pattern.set_extend (Cairo.Extend.REPEAT); + top_pattern = new Cairo.Pattern.for_surface (top_surface); + top_pattern.set_extend (Cairo.Extend.REPEAT); + } + + int width = vbox_events.get_allocated_width (); + int height = vbox_events.get_allocated_height (); + int x = (get_allocated_width () - width) / 2; + int y = (get_allocated_height () - height) / 2; + + if (animation.is_running) + c.push_group (); + + /* Darken background */ + c.set_source_rgba (0, 0, 0, 0.25); + c.paint (); + + if (bg_surface == null || animation.is_running) + { + /* Create a new blurred surface of the current surface */ + bg_surface = new Cairo.ImageSurface (Cairo.Format.ARGB32, width, height); + var bg_cr = new Cairo.Context (bg_surface); + + bg_cr.set_source_surface (c.get_target (), -x - monitor.x, -y - monitor.y); + bg_cr.rectangle (0, 0, width, height); + bg_cr.fill (); + + CairoUtils.ExponentialBlur.surface (bg_surface, BLUR_RADIUS); + } + + /* Background */ + c.save (); + c.translate (x, y); + + CairoUtils.rounded_rectangle (c, 0, 0, width, height, 4); + c.set_source_surface (bg_surface, 0, 0); + c.fill_preserve (); + c.set_source_rgba (avg_color.red, avg_color.green, avg_color.blue, avg_color.alpha); + c.fill (); + + c.restore(); + + /* Draw borders */ + x -= BORDER_EXTERNAL_SIZE; + y -= BORDER_EXTERNAL_SIZE; + width += BORDER_EXTERNAL_SIZE * 2; + height += BORDER_EXTERNAL_SIZE * 2; + + c.save (); + c.translate (x, y); + + /* Top left */ + var m = Cairo.Matrix.identity (); + corner_pattern.set_matrix (m); + c.set_source (corner_pattern); + c.rectangle (0, 0, BORDER_SIZE, BORDER_SIZE); + c.fill (); + + /* Top right */ + m = Cairo.Matrix.identity (); + m.translate (width, 0); + m.scale (-1, 1); + corner_pattern.set_matrix (m); + c.set_source (corner_pattern); + c.rectangle (width - BORDER_SIZE, 0, BORDER_SIZE, BORDER_SIZE); + c.fill (); + + /* Bottom left */ + m = Cairo.Matrix.identity (); + m.translate (0, height); + m.scale (1, -1); + corner_pattern.set_matrix (m); + c.set_source (corner_pattern); + c.rectangle (0, height - BORDER_SIZE, BORDER_SIZE, BORDER_SIZE); + c.fill (); + + /* Bottom right */ + m = Cairo.Matrix.identity (); + m.translate (width, height); + m.scale (-1, -1); + corner_pattern.set_matrix (m); + c.set_source (corner_pattern); + c.rectangle (width - BORDER_SIZE, height - BORDER_SIZE, BORDER_SIZE, BORDER_SIZE); + c.fill (); + + /* Left */ + m = Cairo.Matrix.identity (); + left_pattern.set_matrix (m); + c.set_source (left_pattern); + c.rectangle (0, BORDER_SIZE, BORDER_SIZE, height - BORDER_SIZE * 2); + c.fill (); + + /* Right */ + m = Cairo.Matrix.identity (); + m.translate (width, 0); + m.scale (-1, 1); + left_pattern.set_matrix (m); + c.set_source (left_pattern); + c.rectangle (width - BORDER_SIZE, BORDER_SIZE, BORDER_SIZE, height - BORDER_SIZE * 2); + c.fill (); + + /* Top */ + m = Cairo.Matrix.identity (); + top_pattern.set_matrix (m); + c.set_source (top_pattern); + c.rectangle (BORDER_SIZE, 0, width - BORDER_SIZE * 2, BORDER_SIZE); + c.fill (); + + /* Bottom */ + m = Cairo.Matrix.identity (); + m.translate (0, height); + m.scale (1, -1); + top_pattern.set_matrix (m); + c.set_source (top_pattern); + c.rectangle (BORDER_SIZE, height - BORDER_SIZE, width - BORDER_SIZE * 2, BORDER_SIZE); + c.fill (); + + c.restore (); + + var ret = base.draw (c); + + if (animation.is_running) + { + c.pop_group_to_source (); + c.paint_with_alpha (closing ? 1.0f - animation.progress : animation.progress); + } + + return ret; + } + + private DialogButton add_button (string text, string inactive_filename, string active_filename) + { + var b = new Gtk.Box (Gtk.Orientation.VERTICAL, BUTTON_TEXT_SPACE); + b.visible = true; + button_box.pack_start (b, false, false, 0); + + var label = new Gtk.Label (text); + var button = new DialogButton (inactive_filename, active_filename, null, label); + button.visible = true; + + b.pack_start (button, false, false, 0); + b.pack_start (label, false, false, 0); + + return button; + } +} + +private class DialogButton : Gtk.Button +{ + private string inactive_filename; + private string focused_filename; + private string? active_filename; + private Gtk.Image i; + private Gtk.Label? l; + + public DialogButton (string inactive_filename, string focused_filename, string? active_filename, Gtk.Label? label = null) + { + this.inactive_filename = inactive_filename; + this.focused_filename = focused_filename; + this.active_filename = active_filename; + relief = Gtk.ReliefStyle.NONE; + focus_on_click = false; + i = new Gtk.Image.from_file (inactive_filename); + i.visible = true; + add (i); + + l = label; + + if (l != null) + { + l.visible = true; + l.override_font (Pango.FontDescription.from_string ("Ubuntu Light 12")); + l.override_color (Gtk.StateFlags.NORMAL, { 1.0f, 1.0f, 1.0f, 0.0f }); + l.override_color (Gtk.StateFlags.FOCUSED, { 1.0f, 1.0f, 1.0f, 1.0f }); + l.override_color (Gtk.StateFlags.ACTIVE, { 1.0f, 1.0f, 1.0f, 1.0f }); + this.get_accessible ().set_name (l.get_text ()); + } + + UnityGreeter.add_style_class (this); + try + { + // Remove the default GtkButton paddings and border + var style = new Gtk.CssProvider (); + style.load_from_data ("* {padding: 0px 0px 0px 0px; border: 0px; }", -1); + get_style_context ().add_provider (style, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading session chooser style: %s", e.message); + } + } + + public override bool enter_notify_event (Gdk.EventCrossing event) + { + grab_focus (); + return base.enter_notify_event (event); + } + + public override bool leave_notify_event (Gdk.EventCrossing event) + { + (get_toplevel () as Gtk.Window).set_focus (null); + return base.leave_notify_event (event); + } + + public override bool draw (Cairo.Context c) + { + i.draw (c); + return true; + } + + public override void state_flags_changed (Gtk.StateFlags previous_state) + { + var new_flags = get_state_flags (); + + if ((new_flags & Gtk.StateFlags.PRELIGHT) != 0 && !can_focus || + (new_flags & Gtk.StateFlags.FOCUSED) != 0) + { + if ((new_flags & Gtk.StateFlags.ACTIVE) != 0 && active_filename != null) + i.set_from_file (active_filename); + else + i.set_from_file (focused_filename); + } + else + { + i.set_from_file (inactive_filename); + } + + if (l != null) + l.set_state_flags (new_flags, true); + + base.state_flags_changed (previous_state); + } +} diff --git a/src/toggle-box.vala b/src/toggle-box.vala new file mode 100644 index 0000000..1862951 --- /dev/null +++ b/src/toggle-box.vala @@ -0,0 +1,131 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Michael Terry <michael.terry@canonical.com> + */ + +public class ToggleBox : Gtk.Box +{ + public string default_key {get; construct;} + public string starting_key {get; construct;} + public string selected_key {get; protected set;} + + public ToggleBox (string? default_key, string? starting_key) + { + Object (default_key: default_key, starting_key: starting_key, + selected_key: starting_key); + } + + public void add_item (string key, string label, Gdk.Pixbuf? icon) + { + var item = make_button (key, label, icon); + + if (get_children () == null || + (starting_key == null && default_key == key) || + starting_key == key) + select (item); + + item.show (); + add (item); + } + + private Gtk.Button selected_button; + + construct + { + orientation = Gtk.Orientation.VERTICAL; + } + + public override bool draw (Cairo.Context c) + { + Gtk.Allocation allocation; + get_allocation (out allocation); + + CairoUtils.rounded_rectangle (c, 0, 0, allocation.width, + allocation.height, 0.1 * grid_size); + c.set_source_rgba (0.5, 0.5, 0.5, 0.5); + c.set_line_width (1); + c.stroke (); + + return base.draw (c); + } + + private void select (Gtk.Button button) + { + if (selected_button != null) + selected_button.relief = Gtk.ReliefStyle.NONE; + selected_button = button; + selected_button.relief = Gtk.ReliefStyle.NORMAL; + selected_key = selected_button.get_data<string> ("toggle-list-key"); + } + + private Gtk.Button make_button (string key, string name_in, Gdk.Pixbuf? icon) + { + var item = new FlatButton (); + item.relief = Gtk.ReliefStyle.NONE; + item.clicked.connect (button_clicked_cb); + + var hbox = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 6); + + if (icon != null) + { + var image = new CachedImage (icon); + hbox.pack_start (image, false, false, 0); + } + + var name = name_in; + if (key == default_key) + { + /* Translators: %s is a session name like KDE or Ubuntu */ + name = _("%s (Default)").printf (name); + } + + var label = new Gtk.Label (null); + label.set_markup ("<span font=\"Ubuntu 13\">%s</span>".printf (name)); + label.halign = Gtk.Align.START; + hbox.pack_start (label, true, true, 0); + + item.hexpand = true; + item.add (hbox); + hbox.show_all (); + + try + { + /* Tighten padding on buttons to not be so large */ + var style = new Gtk.CssProvider (); + style.load_from_data ("* {padding: 8px;}", -1); + item.get_style_context ().add_provider (style, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION); + } + catch (Error e) + { + debug ("Internal error loading session chooser style: %s", e.message); + } + + item.set_data<string> ("toggle-list-key", key); + return item; + } + + private void button_clicked_cb (Gtk.Button button) + { + selected_key = button.get_data<string> ("toggle-list-key"); + } + + public override void grab_focus () + { + if (selected_button != null) + selected_button.grab_focus (); + } +} diff --git a/src/unity-greeter.vala b/src/unity-greeter.vala new file mode 100644 index 0000000..cf501af --- /dev/null +++ b/src/unity-greeter.vala @@ -0,0 +1,660 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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/>. + * + * Authored by: Robert Ancell <robert.ancell@canonical.com> + */ + +public const int grid_size = 40; + +public class UnityGreeter +{ + public static UnityGreeter singleton; + + public signal void show_message (string text, LightDM.MessageType type); + public signal void show_prompt (string text, LightDM.PromptType type); + public signal void authentication_complete (); + public signal void starting_session (); + + public bool test_mode = false; + + private string state_file; + private KeyFile state; + + private Cairo.XlibSurface background_surface; + + private SettingsDaemon settings_daemon; + + public bool orca_needs_kick; + private MainWindow main_window; + + private LightDM.Greeter greeter; + + private Canberra.Context canberra_context; + + private static Timer log_timer; + + private DialogDBusInterface dbus_object; + + private UnityGreeter (bool test_mode_) + { + singleton = this; + test_mode = test_mode_; + + /* Prepare to set the background */ + debug ("Creating background surface"); + background_surface = create_root_surface (Gdk.Screen.get_default ()); + + greeter = new LightDM.Greeter (); + greeter.show_message.connect ((text, type) => { show_message (text, type); }); + greeter.show_prompt.connect ((text, type) => { show_prompt (text, type); }); + greeter.autologin_timer_expired.connect (() => { greeter.authenticate_autologin (); }); + greeter.authentication_complete.connect (() => { authentication_complete (); }); + var connected = false; + try + { + connected = greeter.connect_sync (); + } + catch (Error e) + { + warning ("Failed to connect to LightDM daemon"); + } + if (!connected && !test_mode) + Posix.exit (Posix.EXIT_FAILURE); + + if (!test_mode) + { + settings_daemon = new SettingsDaemon (); + settings_daemon.start (); + } + + var state_dir = Path.build_filename (Environment.get_user_cache_dir (), "unity-greeter"); + DirUtils.create_with_parents (state_dir, 0775); + + var xdg_seat = GLib.Environment.get_variable("XDG_SEAT"); + var state_file_name = xdg_seat != null && xdg_seat != "seat0" ? xdg_seat + "-state" : "state"; + + state_file = Path.build_filename (state_dir, state_file_name); + state = new KeyFile (); + try + { + state.load_from_file (state_file, KeyFileFlags.NONE); + } + catch (Error e) + { + if (!(e is FileError.NOENT)) + warning ("Failed to load state from %s: %s\n", state_file, e.message); + } + + main_window = new MainWindow (); + + Bus.own_name (BusType.SESSION, "com.canonical.UnityGreeter", BusNameOwnerFlags.NONE); + + dbus_object = new DialogDBusInterface (); + dbus_object.open_dialog.connect ((type) => + { + ShutdownDialogType dialog_type; + switch (type) + { + default: + case 1: + dialog_type = ShutdownDialogType.LOGOUT; + break; + case 2: + dialog_type = ShutdownDialogType.RESTART; + break; + } + main_window.show_shutdown_dialog (dialog_type); + }); + dbus_object.close_dialog.connect ((type) => { main_window.close_shutdown_dialog (); }); + Bus.own_name (BusType.SESSION, "com.canonical.Unity", BusNameOwnerFlags.NONE, + (c) => + { + try + { + c.register_object ("/org/gnome/SessionManager/EndSessionDialog", dbus_object); + } + catch (Error e) + { + warning ("Failed to register /org/gnome/SessionManager/EndSessionDialog: %s", e.message); + } + }, + null, + () => debug ("Failed to acquire name com.canonical.Unity")); + + start_fake_wm (); + Gdk.threads_add_idle (ready_cb); + } + + public string? get_state (string key) + { + try + { + return state.get_value ("greeter", key); + } + catch (Error e) + { + return null; + } + } + + public void set_state (string key, string value) + { + state.set_value ("greeter", key, value); + var data = state.to_data (); + try + { + FileUtils.set_contents (state_file, data); + } + catch (Error e) + { + debug ("Failed to write state: %s", e.message); + } + } + + public void push_list (GreeterList widget) + { + main_window.push_list (widget); + } + + public void pop_list () + { + main_window.pop_list (); + } + + public static void add_style_class (Gtk.Widget widget) + { + /* Add style context class lightdm-user-list */ + var ctx = widget.get_style_context (); + ctx.add_class ("lightdm"); + } + + public bool start_session (string? session, Background bg) + { + /* Paint our background onto the root window before we close our own window */ + var c = new Cairo.Context (background_surface); + bg.draw_full (c, Background.DrawFlags.NONE); + c = null; + refresh_background (Gdk.Screen.get_default (), background_surface); + + if (test_mode) + { + debug ("Successfully logged in! Quitting..."); + Gtk.main_quit (); + return true; + } + + if (!session_is_valid (session)) + { + debug ("Session %s is not available, using system default %s instead", session, greeter.default_session_hint); + session = greeter.default_session_hint; + } + + var result = false; + try + { + result = LightDM.greeter_start_session_sync (greeter, session); + } + catch (Error e) + { + warning ("Failed to start session: %s", e.message); + } + + if (result) + starting_session (); + + return result; + } + + private bool session_is_valid (string? session) + { + if (session == null) + return true; + + foreach (var s in LightDM.get_sessions ()) + if (s.key == session) + return true; + + return false; + } + + private bool ready_cb () + { + debug ("starting system-ready sound"); + + /* Launch canberra */ + Canberra.Context.create (out canberra_context); + + if (UGSettings.get_boolean (UGSettings.KEY_PLAY_READY_SOUND)) + canberra_context.play (0, + Canberra.PROP_CANBERRA_XDG_THEME_NAME, + "ubuntu", + Canberra.PROP_EVENT_ID, + "system-ready"); + + return false; + } + + public void show () + { + debug ("Showing main window"); + main_window.show (); + main_window.get_window ().focus (Gdk.CURRENT_TIME); + main_window.set_keyboard_state (); + } + + public bool is_authenticated () + { + return greeter.is_authenticated; + } + + public void authenticate (string? userid = null) + { + greeter.authenticate (userid); + } + + public void authenticate_as_guest () + { + greeter.authenticate_as_guest (); + } + + public void authenticate_remote (string? session, string? userid) + { + UnityGreeter.singleton.greeter.authenticate_remote (session, userid); + } + + public void cancel_authentication () + { + greeter.cancel_authentication (); + } + + public void respond (string response) + { + greeter.respond (response); + } + + public string authentication_user () + { + return greeter.authentication_user; + } + + public string default_session_hint () + { + return greeter.default_session_hint; + } + + public string select_user_hint () + { + return greeter.select_user_hint; + } + + public bool show_manual_login_hint () + { + return greeter.show_manual_login_hint; + } + + public bool show_remote_login_hint () + { + return greeter.show_remote_login_hint; + } + + public bool hide_users_hint () + { + return greeter.hide_users_hint; + } + + public bool has_guest_account_hint () + { + return greeter.has_guest_account_hint; + } + + private Gdk.FilterReturn focus_upon_map (Gdk.XEvent gxevent, Gdk.Event event) + { + var xevent = (X.Event*)gxevent; + if (xevent.type == X.EventType.MapNotify) + { + var display = Gdk.x11_lookup_xdisplay (xevent.xmap.display); + var xwin = xevent.xmap.window; + var win = Gdk.X11Window.foreign_new_for_display (display, xwin); + if (win != null && !xevent.xmap.override_redirect) + { + /* Check to see if this window is our onboard window, since we don't want to focus it. */ + X.Window keyboard_xid = 0; + if (main_window.menubar.keyboard_window != null) + keyboard_xid = Gdk.X11Window.get_xid (main_window.menubar.keyboard_window.get_window ()); + + if (xwin != keyboard_xid && win.get_type_hint() != Gdk.WindowTypeHint.NOTIFICATION) + { + win.focus (Gdk.CURRENT_TIME); + + /* Make sure to keep keyboard above */ + if (main_window.menubar.keyboard_window != null) + main_window.menubar.keyboard_window.get_window ().raise (); + } + } + } + else if (xevent.type == X.EventType.UnmapNotify) + { + // Since we aren't keeping track of focus (for example, we don't + // track the Z stack of windows) like a normal WM would, when we + // decide here where to return focus after another window unmaps, + // we don't have much to go on. X will tell us if we should take + // focus back. (I could not find an obvious way to determine this, + // but checking if the X input focus is RevertTo.None seems + // reliable.) + + X.Window xwin; + int revert_to; + xevent.xunmap.display.get_input_focus (out xwin, out revert_to); + + if (revert_to == X.RevertTo.None) + { + main_window.get_window ().focus (Gdk.CURRENT_TIME); + + /* Make sure to keep keyboard above */ + if (main_window.menubar.keyboard_window != null) + main_window.menubar.keyboard_window.get_window ().raise (); + } + } + return Gdk.FilterReturn.CONTINUE; + } + + private void start_fake_wm () + { + /* We want new windows (e.g. the shutdown dialog) to gain focus. + We don't really need anything more than that (don't need alt-tab + since any dialog should be "modal" or at least dealt with before + continuing even if not actually marked as modal) */ + var root = Gdk.get_default_root_window (); + root.set_events (root.get_events () | Gdk.EventMask.SUBSTRUCTURE_MASK); + root.add_filter (focus_upon_map); + } + + private static Cairo.XlibSurface? create_root_surface (Gdk.Screen screen) + { + var visual = screen.get_system_visual (); + + unowned X.Display display = Gdk.X11Display.get_xdisplay (screen.get_display ()); + + var pixmap = X.CreatePixmap (display, + Gdk.X11Window.get_xid (screen.get_root_window ()), + screen.get_width (), + screen.get_height (), + visual.get_depth ()); + + /* Convert into a Cairo surface */ + var surface = new Cairo.XlibSurface (display, + pixmap, + Gdk.X11Visual.get_xvisual (visual), + screen.get_width (), screen.get_height ()); + + return surface; + } + + private static void refresh_background (Gdk.Screen screen, Cairo.XlibSurface surface) + { + Gdk.flush (); + + unowned X.Display display = Gdk.X11Display.get_xdisplay (screen.get_display ()); + + /* Ensure Cairo has actually finished its drawing */ + surface.flush (); + /* Use this pixmap for the background */ + X.SetWindowBackgroundPixmap (display, + Gdk.X11Window.get_xid (screen.get_root_window ()), + surface.get_drawable ()); + + X.ClearWindow (display, Gdk.X11Window.get_xid (screen.get_root_window ())); + } + + private static void log_cb (string? log_domain, LogLevelFlags log_level, string message) + { + string prefix; + switch (log_level & LogLevelFlags.LEVEL_MASK) + { + case LogLevelFlags.LEVEL_ERROR: + prefix = "ERROR:"; + break; + case LogLevelFlags.LEVEL_CRITICAL: + prefix = "CRITICAL:"; + break; + case LogLevelFlags.LEVEL_WARNING: + prefix = "WARNING:"; + break; + case LogLevelFlags.LEVEL_MESSAGE: + prefix = "MESSAGE:"; + break; + case LogLevelFlags.LEVEL_INFO: + prefix = "INFO:"; + break; + case LogLevelFlags.LEVEL_DEBUG: + prefix = "DEBUG:"; + break; + default: + prefix = "LOG:"; + break; + } + + stderr.printf ("[%+.2fs] %s %s\n", log_timer.elapsed (), prefix, message); + } + + public static int main (string[] args) + { + /* Protect memory from being paged to disk, as we deal with passwords */ + Posix.mlockall (Posix.MCL_CURRENT | Posix.MCL_FUTURE); + + /* Disable the stupid global menubar */ + Environment.unset_variable ("UBUNTU_MENUPROXY"); + + /* Initialize i18n */ + Intl.setlocale (LocaleCategory.ALL, ""); + Intl.bindtextdomain (Config.GETTEXT_PACKAGE, Config.LOCALEDIR); + Intl.bind_textdomain_codeset (Config.GETTEXT_PACKAGE, "UTF-8"); + Intl.textdomain (Config.GETTEXT_PACKAGE); + + /* Set up the accessibility stack, in case the user needs it for screen reading etc. */ + Environment.set_variable ("GTK_MODULES", "atk-bridge", false); + + Pid atspi_pid = 0; + Pid upstart_pid = 0; + + try + { + string[] argv; + + Shell.parse_argv ("/usr/lib/at-spi2-core/at-spi-bus-launcher --launch-immediately", out argv); + Process.spawn_async (null, + argv, + null, + SpawnFlags.SEARCH_PATH, + null, + out atspi_pid); + } + catch (Error e) + { + warning ("Error starting the at-spi registry: %s", e.message); + } + + Gtk.init (ref args); + Ido.init (); + + log_timer = new Timer (); + Log.set_default_handler (log_cb); + + debug ("Starting unity-greeter %s UID=%d LANG=%s", Config.VERSION, (int) Posix.getuid (), Environment.get_variable ("LANG")); + + /* Set the cursor to not be the crap default */ + debug ("Setting cursor"); + Gdk.get_default_root_window ().set_cursor (new Gdk.Cursor (Gdk.CursorType.LEFT_PTR)); + + bool do_show_version = false; + bool do_test_mode = false; + OptionEntry versionOption = { "version", 'v', 0, OptionArg.NONE, ref do_show_version, + /* Help string for command line --version flag */ + N_("Show release version"), null }; + OptionEntry testOption = { "test-mode", 0, 0, OptionArg.NONE, ref do_test_mode, + /* Help string for command line --test-mode flag */ + N_("Run in test mode"), null }; + OptionEntry nullOption = { null }; + OptionEntry[] options = { versionOption, testOption, nullOption }; + + debug ("Loading command line options"); + var c = new OptionContext (/* Arguments and description for --help text */ + _("- Unity Greeter")); + c.add_main_entries (options, Config.GETTEXT_PACKAGE); + c.add_group (Gtk.get_option_group (true)); + try + { + c.parse (ref args); + } + catch (Error e) + { + stderr.printf ("%s\n", e.message); + stderr.printf (/* Text printed out when an unknown command-line argument provided */ + _("Run '%s --help' to see a full list of available command line options."), args[0]); + stderr.printf ("\n"); + return Posix.EXIT_FAILURE; + } + if (do_show_version) + { + /* Note, not translated so can be easily parsed */ + stderr.printf ("unity-greeter %s\n", Config.VERSION); + return Posix.EXIT_SUCCESS; + } + + if (do_test_mode) + debug ("Running in test mode"); + + /* Set GTK+ settings */ + debug ("Setting GTK+ settings"); + var settings = Gtk.Settings.get_default (); + var value = UGSettings.get_string (UGSettings.KEY_THEME_NAME); + if (value != "") + settings.set ("gtk-theme-name", value, null); + value = UGSettings.get_string (UGSettings.KEY_ICON_THEME_NAME); + if (value != "") + settings.set ("gtk-icon-theme-name", value, null); + value = UGSettings.get_string (UGSettings.KEY_FONT_NAME); + if (value != "") + settings.set ("gtk-font-name", value, null); + var double_value = UGSettings.get_double (UGSettings.KEY_XFT_DPI); + if (double_value != 0.0) + settings.set ("gtk-xft-dpi", (int) (1024 * double_value), null); + var boolean_value = UGSettings.get_boolean (UGSettings.KEY_XFT_ANTIALIAS); + settings.set ("gtk-xft-antialias", boolean_value, null); + value = UGSettings.get_string (UGSettings.KEY_XFT_HINTSTYLE); + if (value != "") + settings.set ("gtk-xft-hintstyle", value, null); + value = UGSettings.get_string (UGSettings.KEY_XFT_RGBA); + if (value != "") + settings.set ("gtk-xft-rgba", value, null); + + debug ("Creating Unity Greeter"); + var greeter = new UnityGreeter (do_test_mode); + + debug ("Showing greeter"); + greeter.show (); + + if (!do_test_mode) + { + /* Start the indicator services */ + try + { + string[] argv; + + Shell.parse_argv ("init --user --startup-event indicator-services-start", out argv); + Process.spawn_async (null, + argv, + null, + SpawnFlags.SEARCH_PATH, + null, + out upstart_pid); + } + catch (Error e) + { + warning ("Error starting Upstart for indicators: %s", e.message); + } + + /* Make nm-applet hide items the user does not have permissions to interact with */ + Environment.set_variable ("NM_APPLET_HIDE_POLICY_ITEMS", "1", true); + + try + { + Process.spawn_command_line_async ("nm-applet"); + } + catch (Error e) + { + warning ("Error starting nm-applet: %s", e.message); + } + } + + /* Setup a handler for TERM so we quit cleanly */ + GLib.Unix.signal_add(GLib.ProcessSignal.TERM, () => { + debug("Got a SIGTERM"); + Gtk.main_quit(); + return true; + }); + + debug ("Starting main loop"); + Gtk.main (); + + debug ("Cleaning up"); + + if (upstart_pid != 0) + { + Posix.kill (upstart_pid, Posix.SIGTERM); + int status; + Posix.waitpid (upstart_pid, out status, 0); + if (Process.if_exited (status)) + debug ("Upstart exited with return value %d", Process.exit_status (status)); + else + debug ("Upstart terminated with signal %d", Process.term_sig (status)); + upstart_pid = 0; + } + + if (atspi_pid != 0) + { + Posix.kill (atspi_pid, Posix.SIGKILL); + int status; + Posix.waitpid (atspi_pid, out status, 0); + if (Process.if_exited (status)) + debug ("AT-SPI exited with return value %d", Process.exit_status (status)); + else + debug ("AT-SPI terminated with signal %d", Process.term_sig (status)); + atspi_pid = 0; + } + + debug ("Exiting"); + + return Posix.EXIT_SUCCESS; + } +} + +[DBus (name="org.gnome.SessionManager.EndSessionDialog")] +public class DialogDBusInterface : Object +{ + public signal void open_dialog (uint32 type); + public signal void close_dialog (); + + public void open (uint32 type, uint32 timestamp, uint32 seconds_to_stay_open, ObjectPath[] inhibitor_object_paths) + { + open_dialog (type); + } + + public void close () + { + close_dialog (); + } +} diff --git a/src/user-list.vala b/src/user-list.vala new file mode 100644 index 0000000..5f2bceb --- /dev/null +++ b/src/user-list.vala @@ -0,0 +1,1603 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +int remote_server_field_sort_function (RemoteServerField? item1, RemoteServerField? item2) +{ + string[] sorted_fields = { "domain", "username", "email", "password" }; + foreach (var field in sorted_fields) + { + if (item1.type == field) + return -1; + if (item2.type == field) + return 1; + } + + return (item1.type < item2.type) ? -1 : 0; +} + +public class UserList : GreeterList +{ + private bool _offer_guest = false; + public bool offer_guest + { + get { return _offer_guest; } + set + { + _offer_guest = value; + if (value) + add_user ("*guest", _("Guest Session")); + else + remove_entry ("*guest"); + } + } + + private Gdk.Pixbuf message_pixbuf; + + private uint change_background_timeout = 0; + + private uint remote_login_service_watch; + private RemoteLoginService remote_login_service; + private List<RemoteServer?> remote_directory_server_list = new List<RemoteServer?> (); + private List<RemoteServer?> remote_login_server_list = new List<RemoteServer?> (); + private HashTable<string, Gtk.Widget> current_remote_fields; + private string currently_browsing_server_url; + private string currently_browsing_server_email; + private EmailAutocompleter remote_server_email_field_autocompleter; + + /* User to authenticate against */ + private string ?authenticate_user = null; + + private bool show_hidden_users_ = false; + public bool show_hidden_users + { + set + { + show_hidden_users_ = value; + + if (UnityGreeter.singleton.test_mode) + { + if (value) + add_user ("hidden", "Hidden User", null, false, false, null); + else + remove_entry ("hidden"); + return; + } + + var hidden_users = UGSettings.get_strv (UGSettings.KEY_HIDDEN_USERS); + if (!value) + { + foreach (var username in hidden_users) + remove_entry (username); + return; + } + + var users = LightDM.UserList.get_instance (); + foreach (var user in users.users) + { + foreach (var username in hidden_users) + { + if (user.name == username) + { + debug ("Showing hidden user %s", username); + user_added_cb (user); + } + } + } + } + + get + { + return show_hidden_users_; + } + } + + private string _default_session = "ubuntu"; + public string default_session + { + get + { + return _default_session; + } + set + { + _default_session = value; + if (selected_entry != null) + selected_entry.set_options_image (get_badge ()); + } + } + + private string? _session = null; + public string? session + { + get + { + return _session; + } + set + { + _session = value; + if (selected_entry != null) + selected_entry.set_options_image (get_badge ()); + } + } + + public UserList (Background bg, MenuBar mb) + { + Object (background: bg, menubar: mb); + } + + construct + { + menubar.notify["high-contrast"].connect (() => { change_background (); }); + entry_displayed_start.connect (() => { change_background (); }); + entry_displayed_done.connect (() => { change_background (); }); + + try + { + message_pixbuf = new Gdk.Pixbuf.from_file (Path.build_filename (Config.PKGDATADIR, "message.png", null)); + } + catch (Error e) + { + debug ("Error loading message image: %s", e.message); + } + + fill_list (); + + entry_selected.connect (entry_selected_cb); + + connect_to_lightdm (); + + if (!UnityGreeter.singleton.test_mode && + UnityGreeter.singleton.show_remote_login_hint ()) + remote_login_service_watch = Bus.watch_name (BusType.SESSION, + "com.canonical.RemoteLogin", + BusNameWatcherFlags.AUTO_START, + on_remote_login_service_appeared, + on_remote_login_service_vanished); + + } + + private void remove_remote_servers () + { + remote_directory_server_list = new List<RemoteServer?> (); + remote_login_server_list = new List<RemoteServer?> (); + remove_entries_with_prefix ("*remote"); + } + + private void remove_remote_login_servers () + { + remote_login_server_list = new List<RemoteServer?> (); + remove_entries_with_prefix ("*remote_login"); + + /* If we have no entries at all, we should show manual */ + if (!always_show_manual) + add_manual_entry (); + } + + private async void query_directory_servers () + { + try + { + RemoteServer[] server_list; + yield remote_login_service.get_servers (out server_list); + set_remote_directory_servers (server_list); + } + catch (IOError e) + { + debug ("Calling GetServers on com.canonical.RemoteLogin dbus service failed. Error: %s", e.message); + remove_remote_servers (); + } + } + + private string user_list_name_for_remote_directory_server (RemoteServer remote_server) + { + return "*remote_directory*" + remote_server.url; + } + + private string username_from_remote_server_fields(RemoteServer remote_server) + { + var username = ""; + foreach (var f in remote_server.fields) + { + if (f.type == "username" && f.default_value != null) + { + username = f.default_value.get_string (); + break; + } + } + return username; + } + + private string user_list_name_for_remote_login_server (RemoteServer remote_server) + { + var username = username_from_remote_server_fields (remote_server); + return "*remote_login*" + remote_server.url + "*" + username; + } + + private string url_from_remote_loding_server_list_name (string remote_server_list_name) + { + return remote_server_list_name.split ("*")[2]; + } + + private string username_from_remote_loding_server_list_name (string remote_server_list_name) + { + return remote_server_list_name.split ("*")[3]; + } + + private void set_remote_directory_servers (RemoteServer[] server_list) + { + /* Add new servers */ + foreach (var remote_server in server_list) + { + var list_name = user_list_name_for_remote_directory_server (remote_server); + if (find_entry (list_name) == null) + { + var e = new PromptBox (list_name); + e.label = remote_server.name; + e.respond.connect (remote_directory_respond_cb); + e.show_options.connect (show_remote_account_dialog); + add_entry (e); + + remote_directory_server_list.append (remote_server); + } + } + + /* Remove gone servers */ + unowned List<RemoteServer?> it = remote_directory_server_list; + while (it != null) + { + var remote_server = it.data; + var found = false; + for (int i = 0; !found && i < server_list.length; i++) + { + found = remote_server.url == server_list[i].url; + } + if (!found) + { + if (remote_server.url == currently_browsing_server_url) + { + /* The server we where "browsing" disappeared, so kill its children */ + remove_remote_login_servers (); + currently_browsing_server_url = ""; + currently_browsing_server_email = ""; + } + remove_entry (user_list_name_for_remote_directory_server (remote_server)); + unowned List<RemoteServer?> newIt = it.next; + remote_directory_server_list.delete_link (it); + it = newIt; + } + else + { + it = it.next; + } + } + + /* Remove manual option unless specified */ + if (remote_directory_server_list.length() > 0 && !always_show_manual) { + debug ("removing manual login since we have a remote login entry"); + remove_entry ("*other"); + } + } + + private PromptBox create_prompt_for_login_server (RemoteServer remote_server) + { + var e = new PromptBox (user_list_name_for_remote_login_server (remote_server)); + e.label = remote_server.name; + e.respond.connect (remote_login_respond_cb); + add_entry (e); + remote_login_server_list.append (remote_server); + + return e; + } + + private void remote_login_servers_updated (string url, string email_address, string data_type, RemoteServer[] server_list) + { + if (currently_browsing_server_url == url && currently_browsing_server_email == email_address) + { + /* Add new servers */ + foreach (var remote_server in server_list) + { + var list_name = user_list_name_for_remote_login_server (remote_server); + if (find_entry (list_name) == null) + create_prompt_for_login_server (remote_server); + } + + /* Remove gone servers */ + unowned List<RemoteServer?> it = remote_login_server_list; + while (it != null) + { + RemoteServer remote_server = it.data; + var found = false; + for (var i = 0; !found && i < server_list.length; i++) + found = remote_server.url == server_list[i].url; + if (!found) + { + remove_entry (user_list_name_for_remote_login_server (remote_server)); + unowned List<RemoteServer?> newIt = it.next; + remote_login_server_list.delete_link (it); + it = newIt; + } + else + { + it = it.next; + } + } + } + } + + private void remote_login_changed (string url, string email_address) + { + if (currently_browsing_server_url == url && currently_browsing_server_email == email_address) + { + /* Something happened and we are being asked for re-authentication by the remote-login-service */ + remove_remote_login_servers (); + currently_browsing_server_url = ""; + currently_browsing_server_email = ""; + + var directory_list_name = "*remote_directory*" + url; + set_active_entry (directory_list_name); + } + } + + private void on_remote_login_service_appeared (DBusConnection conn, string name) + { + Bus.get_proxy.begin<RemoteLoginService> (BusType.SESSION, + "com.canonical.RemoteLogin", + "/com/canonical/RemoteLogin", + 0, + null, + (obj, res) => { + try + { + remote_login_service = Bus.get_proxy.end<RemoteLoginService> (res); + remote_login_service.servers_updated.connect (set_remote_directory_servers); + remote_login_service.login_servers_updated.connect (remote_login_servers_updated); + remote_login_service.login_changed.connect (remote_login_changed); + query_directory_servers.begin (); + } + catch (IOError e) + { + debug ("Getting the com.canonical.RemoteLogin dbus service failed. Error: %s", e.message); + remove_remote_servers (); + remote_login_service = null; + } + } + ); + } + + private void on_remote_login_service_vanished (DBusConnection conn, string name) + { + remove_remote_servers (); + remote_login_service = null; + + /* provide a fallback manual login option */ + if (UnityGreeter.singleton.hide_users_hint ()) { + add_manual_entry(); + set_active_entry ("*other"); + } + } + + private async void remote_directory_respond_cb () + { + remove_remote_login_servers (); + currently_browsing_server_url = ""; + currently_browsing_server_email = ""; + + var password_field = current_remote_fields.get ("password") as DashEntry; + var email_field = current_remote_fields.get ("email") as Gtk.Entry; + if (password_field == null) + { + debug ("Something wrong happened in remote_directory_respond_cb. There was no password field"); + return; + } + if (email_field == null) + { + debug ("Something wrong happened in remote_directory_respond_cb. There was no email field"); + return; + } + + RemoteServer[] server_list = {}; + var email = email_field.text; + var email_valid = false; + try + { + /* Check email address is valid + * Using the html5 definition of a valid e-mail address + * http://www.w3.org/TR/html5/states-of-the-type-attribute.html#valid-e-mail-address */ + var re = new Regex ("[a-zA-Z0-9.!#$%&'\\*\\+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*"); + MatchInfo info; + email_valid = re.match_all (email, 0, out info); + email_valid = email_valid && info.get_match_count () > 0 && info.fetch (0) == email; + } + catch (RegexError e) + { + debug ("Calling email regex match failed. Error: %s", e.message); + } + + selected_entry.reset_messages (); + if (!email_valid) + { + will_clear = true; + show_message (_("Please enter a complete e-mail address"), true); + create_remote_fields_for_current_item.begin (remote_directory_server_list); + } + else + { + var login_success = false; + try + { + var url = url_from_remote_loding_server_list_name (selected_entry.id); + if (UnityGreeter.singleton.test_mode) + { + if (password_field.text == "password") + { + test_fill_remote_login_servers (out server_list); + login_success = true; + } + else if (password_field.text == "delay1") + { + test_fill_remote_login_servers (out server_list); + login_success = true; + Timeout.add (5000, () => { test_call_set_remote_directory_servers (); return false; }); + } + else if (password_field.text == "delay2") + { + test_fill_remote_login_servers (out server_list); + login_success = true; + Timeout.add (5000, () => { test_call_remote_login_servers_updated (); return false; }); + } + else if (password_field.text == "delay3") + { + test_fill_remote_login_servers (out server_list); + login_success = true; + Timeout.add (5000, () => { remote_login_changed (currently_browsing_server_url, currently_browsing_server_email); return false; }); + } + else if (password_field.text == "duplicate") + { + test_fill_remote_login_servers_duplicate_entries (out server_list); + login_success = true; + } + } + else + { + string data_type; + bool allowcache = true; + // If we had an error and are retrying the same user and server, do not use the cache on R-L-S + if (selected_entry.has_errors && currently_browsing_server_email == email && currently_browsing_server_url == url) + allowcache = false; + yield remote_login_service.get_servers_for_login (url, email, password_field.text, allowcache, out login_success, out data_type, out server_list); + } + currently_browsing_server_url = url; + currently_browsing_server_email = email; + } + catch (IOError e) + { + debug ("Calling get_servers in com.canonical.RemoteLogin dbus service failed. Error: %s", e.message); + } + + if (login_success) + { + password_field.did_respond = false; + if (server_list.length == 0) + show_remote_account_dialog (); + else + { + var last_used_server_list_name = ""; + foreach (var remote_server in server_list) + { + var e = create_prompt_for_login_server (remote_server); + if (remote_server.last_used_server) + last_used_server_list_name = e.id; + } + if (last_used_server_list_name != "") + set_active_entry (last_used_server_list_name); + else + set_active_first_entry_with_prefix ("*remote_login"); + } + } + else + { + will_clear = true; + show_message (_("Incorrect e-mail address or password"), true); + create_remote_fields_for_current_item.begin (remote_directory_server_list); + } + } + } + + private void remote_login_respond_cb () + { + sensitive = false; + will_clear = true; + greeter_authenticating_user = selected_entry.id; + if (UnityGreeter.singleton.test_mode) + { + Gtk.Entry field = current_remote_fields.get ("password") as Gtk.Entry; + test_is_authenticated = field.text == "password"; + if (field.text == "delay") + Timeout.add (5000, () => { authentication_complete_cb (); return false; }); + else + authentication_complete_cb (); + } + else + { + UnityGreeter.singleton.authenticate_remote (get_lightdm_session (), null); + remote_login_service.set_last_used_server.begin (currently_browsing_server_url, url_from_remote_loding_server_list_name (selected_entry.id)); + } + } + + private void show_remote_account_dialog () + { + var dialog = new Gtk.MessageDialog (null, 0, Gtk.MessageType.OTHER, Gtk.ButtonsType.NONE, ""); + dialog.set_position (Gtk.WindowPosition.CENTER_ALWAYS); + dialog.secondary_text = _("If you have an account on an RDP or Citrix server, Remote Login lets you run applications from that server."); + // For 12.10 we still don't support Citrix + dialog.secondary_text = _("If you have an account on an RDP server, Remote Login lets you run applications from that server."); + if (offer_guest) + { + dialog.add_button (_("Cancel"), 0); + var b = dialog.add_button (_("Set Up…"), 1); + b.grab_focus (); + dialog.text = _("You need an Ubuntu Remote Login account to use this service. Would you like to set up an account now?"); + } + else + { + dialog.add_button (_("OK"), 0); + dialog.text = _("You need an Ubuntu Remote Login account to use this service. Visit uccs.canonical.com to set up an account."); + } + + dialog.show_all (); + dialog.response.connect ((id) => + { + if (id == 1) + { + var config_session = "uccsconfigure"; + if (is_supported_remote_session (config_session)) + { + greeter_authenticating_user = selected_entry.id; + UnityGreeter.singleton.authenticate_remote (config_session, null); + } + } + dialog.destroy (); + }); + dialog.run (); + } + + private bool change_background_timeout_cb () + { + string? new_background_file = null; + if (menubar.high_contrast || !UGSettings.get_boolean (UGSettings.KEY_DRAW_USER_BACKGROUNDS)) + new_background_file = null; + else if (selected_entry is UserPromptBox) + new_background_file = (selected_entry as UserPromptBox).background; + + background.current_background = new_background_file; + + change_background_timeout = 0; + return false; + } + + private void change_background () + { + if (background.current_background != null) + { + if (change_background_timeout == 0) + change_background_timeout = Idle.add (change_background_timeout_cb); + } + else + change_background_timeout_cb (); + } + + protected static int user_list_compare_entry (PromptBox a, PromptBox b) + { + if (a.id.has_prefix ("*remote_directory") && !b.id.has_prefix ("*remote_directory")) + return 1; + if (a.id.has_prefix ("*remote_login") && !b.id.has_prefix ("*remote_login")) + return 1; + + /* Fall back to default behaviour of the GreeterList sorter */ + return GreeterList.compare_entry (a, b); + } + + protected override void insert_entry (PromptBox entry) + { + entries.insert_sorted (entry, user_list_compare_entry); + } + + protected override void setup_prompt_box (bool fade = true) + { + base.setup_prompt_box (fade); + var userbox = selected_entry as UserPromptBox; + if (userbox != null) + selected_entry.set_is_active (userbox.is_active); + } + + private void entry_selected_cb (string? username) + { + UnityGreeter.singleton.set_state ("last-user", username); + if (selected_entry is UserPromptBox) + session = (selected_entry as UserPromptBox).session; + else + session = null; + selected_entry.clear (); + + /* Reset this variable so it can be freed */ + remote_server_email_field_autocompleter = null; + + start_authentication (); + } + + protected override void start_authentication () + { + sensitive = true; + greeter_authenticating_user = ""; + if (selected_entry.id.has_prefix ("*remote_directory")) + { + prompted = true; + create_remote_fields_for_current_item.begin (remote_directory_server_list); + } + else if (selected_entry.id.has_prefix ("*remote_login")) + { + prompted = true; + create_remote_fields_for_current_item.begin (remote_login_server_list); + } + else + base.start_authentication (); + } + + private async void create_remote_fields_for_current_item (List<RemoteServer?> server_list) + { + current_remote_fields = new HashTable<string, Gtk.Widget> (str_hash, str_equal); + var url = url_from_remote_loding_server_list_name (selected_entry.id); + var username = username_from_remote_loding_server_list_name (selected_entry.id); + + foreach (var remote_server in server_list) + { + var remote_username = username_from_remote_server_fields (remote_server); + if (remote_server.url == url && (username == null || username == remote_username)) + { + if (selected_entry.id.has_prefix ("*remote_login")) + { + if (!is_supported_remote_session (remote_server.type)) + { + show_message (_("Server type not supported."), true); + } + } + + var fields = new List<RemoteServerField?> (); + foreach (var field in remote_server.fields) + fields.append (field); + fields.sort (remote_server_field_sort_function); + foreach (var field in fields) + { + Gtk.Widget? widget = null; + var default_value = ""; + if (field.default_value != null && field.default_value.is_of_type (VariantType.STRING)) + default_value = field.default_value.get_string (); + if (field.type == "username") + { + var entry = add_prompt (_("Username:")); + entry.text = default_value; + widget = entry; + } + else if (field.type == "password") + { + var entry = add_prompt (_("Password:"), true); + entry.text = default_value; + widget = entry; + } + else if (field.type == "domain") + { + string[] domainsArray = {}; + if (field.properties != null && field.properties.contains ("domains") && field.properties.get ("domains").is_of_type (VariantType.ARRAY)) + domainsArray = field.properties.get ("domains").dup_strv (); + var domains = new GenericArray<string> (); + for (var i = 0; i < domainsArray.length; i++) + domains.add (domainsArray[i]); + + var read_only = field.properties != null && + field.properties.contains ("read-only") && + field.properties.get ("read-only").is_of_type (VariantType.BOOLEAN) && + field.properties.get ("read-only").get_boolean (); + if (domains.length == 0 || (domains.length == 1 && (domains[0] == default_value || default_value.length == 0))) + { + var prompt = add_prompt (_("Domain:")); + prompt.text = domains.length == 1 ? domains[0] : default_value; + prompt.sensitive = !read_only; + widget = prompt; + } + else + { + if (default_value.length > 0) + { + /* Make sure the domain list contains the default value */ + var found = false; + for (var i = 0; !found && i < domains.length; i++) + found = default_value == domains[i]; + + if (!found) + domains.add (default_value); + } + + /* Sort domains alphabetically */ + domains.sort (strcmp); + var combo = add_combo (domains, read_only); + + if (default_value.length > 0) + { + if (read_only) + { + for (var i = 0; i < domains.length; i++) + { + if (default_value == domains[i]) + { + combo.active = i; + break; + } + } + } + else + { + var entry = combo.get_child () as Gtk.Entry; + entry.text = default_value; + } + } + + widget = combo; + } + } + else if (field.type == "email") + { + string[] email_domains; + try + { + if (UnityGreeter.singleton.test_mode) + email_domains = { "canonical.com", "ubuntu.org", "candy.com", "urban.net" }; + else + yield remote_login_service.get_cached_domains_for_server (url, out email_domains); + } + catch (IOError e) + { + email_domains.resize (0); + debug ("Calling get_cached_domains_for_server in com.canonical.RemoteLogin dbus service failed. Error: %s", e.message); + } + + var entry = add_prompt (_("Email address:")); + entry.text = default_value; + widget = entry; + if (email_domains.length > 0) + remote_server_email_field_autocompleter = new EmailAutocompleter (entry, email_domains); + } + else + { + debug ("Found field of type %s, don't know what to do with it", field.type); + continue; + } + current_remote_fields.insert (field.type, widget); + } + break; + } + } + } + + public override void focus_prompt () + { + if (selected_entry.id.has_prefix ("*remote_login")) + { + var url = url_from_remote_loding_server_list_name(selected_entry.id); + foreach (var remote_server in remote_login_server_list) + { + if (remote_server.url == url) + { + if (!is_supported_remote_session (remote_server.type)) + { + selected_entry.sensitive = false; + return; + } + } + } + } + + base.focus_prompt (); + } + + public override void show_authenticated (bool successful = true) + { + if (successful) + { + /* 'Log In' here is the button for logging in. */ + selected_entry.add_button (_("Log In"), + _("Login as %s").printf (selected_entry.label)); + } + else + { + selected_entry.add_button (_("Retry"), + _("Retry as %s").printf (selected_entry.label)); + } + + if (mode != Mode.SCROLLING) + selected_entry.show_prompts (); + + focus_prompt (); + redraw_greeter_box (); + } + + public void add_user (string name, string label, string? background = null, bool is_active = false, bool has_messages = false, string? session = null) + { + var e = find_entry (name) as UserPromptBox; + if (e == null) + { + e = new UserPromptBox (name); + e.respond.connect (prompt_box_respond_cb); + e.login.connect (prompt_box_login_cb); + e.show_options.connect (prompt_box_show_options_cb); + e.label = label; /* Do this before adding for sorting purposes */ + add_entry (e); + } + e.background = background; + e.is_active = is_active; + e.session = session; + e.label = label; + e.set_show_message_icon (has_messages); + e.set_is_active (is_active); + + /* Remove manual option when have users */ + if (have_entries () && !always_show_manual) + remove_entry ("*other"); + } + + protected override void add_manual_entry () + { + var text = manual_name; + if (text == null) + text = _("Login"); + add_user ("*other", text); + } + + protected void prompt_box_respond_cb (string[] responses) + { + selected_entry.sensitive = false; + will_clear = true; + unacknowledged_messages = false; + + foreach (var response in responses) + { + if (UnityGreeter.singleton.test_mode) + test_respond (response); + else + UnityGreeter.singleton.respond (response); + } + } + + private void prompt_box_login_cb () + { + debug ("Start session for %s", selected_entry.id); + + unacknowledged_messages = false; + var is_authenticated = false; + if (UnityGreeter.singleton.test_mode) + is_authenticated = test_is_authenticated; + else + is_authenticated = UnityGreeter.singleton.is_authenticated(); + + /* Finish authentication (again) or restart it */ + if (is_authenticated) + authentication_complete_cb (); + else + { + selected_entry.clear (); + start_authentication (); + } + } + + private void prompt_box_show_options_cb () + { + var session_chooser = new SessionList (background, menubar, session, default_session); + session_chooser.session_clicked.connect (session_clicked_cb); + UnityGreeter.singleton.push_list (session_chooser); + } + + private void session_clicked_cb (string session) + { + this.session = session; + UnityGreeter.singleton.pop_list (); + } + + private bool should_show_session_badge () + { + if (UnityGreeter.singleton.test_mode) + return get_selected_id () != "no-badge"; + else + return LightDM.get_sessions ().length () > 1; + } + + private Gdk.Pixbuf? get_badge () + { + if (selected_entry is UserPromptBox) + { + if (!should_show_session_badge ()) + return null; + else if (session == null) + return SessionList.get_badge (default_session); + else + return SessionList.get_badge (session); + } + else + { + if (selected_entry.id.has_prefix ("*remote_directory")) + return SessionList.get_badge ("remote-login"); + else + return null; + } + } + + private bool is_supported_remote_session (string session_internal_name) + { + if (UnityGreeter.singleton.test_mode) + return session_internal_name == "rdp"; + + var found = false; + foreach (var session in LightDM.get_remote_sessions ()) + { + if (session.key == session_internal_name) + { + found = true; + break; + } + } + return found; + } + + protected override string get_lightdm_session () + { + if (selected_entry.id.has_prefix ("*remote_login")) + { + var url = url_from_remote_loding_server_list_name (selected_entry.id); + unowned List<RemoteServer?> it = remote_login_server_list; + + var answer = ""; + while (answer == "" && it != null) + { + RemoteServer remote_server = it.data; + if (remote_server.url == url) + answer = remote_server.type; + it = it.next; + } + + if (is_supported_remote_session (answer)) + return answer; + else + return ""; + } + else + return session; + } + + private void fill_list () + { + if (UnityGreeter.singleton.test_mode) + test_fill_list (); + else + { + default_session = UnityGreeter.singleton.default_session_hint (); + always_show_manual = UnityGreeter.singleton.show_manual_login_hint (); + if (!UnityGreeter.singleton.hide_users_hint ()) + { + var users = LightDM.UserList.get_instance (); + users.user_added.connect (user_added_cb); + users.user_changed.connect (user_added_cb); + users.user_removed.connect (user_removed_cb); + foreach (var user in users.users) + user_added_cb (user); + } + + if (UnityGreeter.singleton.has_guest_account_hint ()) + { + debug ("Adding guest account entry"); + offer_guest = true; + } + + /* If we have no entries at all, we should show manual */ + if (!have_entries ()) + add_manual_entry (); + + var last_user = UnityGreeter.singleton.get_state ("last-user"); + if (UnityGreeter.singleton.select_user_hint () != null) + set_active_entry (UnityGreeter.singleton.select_user_hint ()); + else if (last_user != null) + set_active_entry (last_user); + } + } + + private void user_added_cb (LightDM.User user) + { + debug ("Adding/updating user %s (%s)", user.name, user.real_name); + + if (!show_hidden_users) + { + var hidden_users = UGSettings.get_strv (UGSettings.KEY_HIDDEN_USERS); + foreach (var username in hidden_users) + if (username == user.name) + return; + } + + var label = user.real_name; + if (user.real_name == "") + label = user.name; + + add_user (user.name, label, user.background, user.logged_in, user.has_messages, user.session); + } + + private void user_removed_cb (LightDM.User user) + { + debug ("Removing user %s", user.name); + remove_entry (user.name); + } + + protected override void show_prompt_cb (string text, LightDM.PromptType type) + { + if (selected_entry.id.has_prefix ("*remote_login")) + { + if (text == "remote login:") + { + Gtk.Entry field = current_remote_fields.get ("username") as Gtk.Entry; + var answer = field != null ? field.text : ""; + UnityGreeter.singleton.respond (answer); + } + else if (text == "password:") + { + Gtk.Entry field = current_remote_fields.get ("password") as Gtk.Entry; + var answer = field != null ? field.text : ""; + UnityGreeter.singleton.respond (answer); + } + else if (text == "remote host:") + { + var answer = url_from_remote_loding_server_list_name (selected_entry.id); + UnityGreeter.singleton.respond (answer); + } + else if (text == "domain:") + { + Gtk.Entry field = current_remote_fields.get ("domain") as Gtk.Entry; + var answer = field != null ? field.text : ""; + UnityGreeter.singleton.respond (answer); + } + } + else + base.show_prompt_cb (text, type); + } + + /* A lot of test code below here */ + + private struct TestEntry + { + string username; + string real_name; + string? background; + bool is_active; + bool has_messages; + string? session; + } + + private const TestEntry[] test_entries = + { + { "has-password", "Has Password", "*" }, + { "different-prompt", "Different Prompt", "*" }, + { "no-password", "No Password", "*" }, + { "change-password", "Change Password", "*" }, + { "auth-error", "Auth Error", "*" }, + { "two-factor", "Two Factor", "*" }, + { "two-prompts", "Two Prompts", "*" }, + { "info-prompt", "Info Prompt", "*" }, + { "long-info-prompt", "Long Info Prompt", "*" }, + { "wide-info-prompt", "Wide Info Prompt", "*" }, + { "multi-info-prompt", "Multi Info Prompt", "*" }, + { "very-very-long-name", "Long name (far far too long to fit)", "*" }, + { "long-name-and-messages", "Long name and messages (too long to fit)", "*", false, true }, + { "active", "Active Account", "*", true }, + { "has-messages", "Has Messages", "*", false, true }, + { "gnome", "GNOME", "*", false, false, "gnome" }, + { "locked", "Locked Account", "*" }, + { "color-background", "Color Background", "#dd4814" }, + { "white-background", "White Background", "#ffffff" }, + { "black-background", "Black Background", "#000000" }, + { "no-background", "No Background", null }, + { "unicode", "가나다라마", "*" }, + { "no-response", "No Response", "*" }, + { "no-badge", "No Badge", "*" }, + { "messages-after-login", "Messages After Login", "*" }, + { "" } + }; + private List<string> test_backgrounds; + private int n_test_entries = 0; + private bool test_prompted_sso = false; + private string test_two_prompts_first = null; + private bool test_request_new_password = false; + private string? test_new_password = null; + + private void test_fill_list () + { + test_backgrounds = new List<string> (); + try + { + var dir = Dir.open ("/usr/share/backgrounds/"); + while (true) + { + var bg = dir.read_name (); + if (bg == null) + break; + test_backgrounds.append ("/usr/share/backgrounds/" + bg); + } + } + catch (FileError e) + { + } + + if (!UnityGreeter.singleton.hide_users_hint()) + while (add_test_entry ()); + + /* add a manual entry if the list of entries is empty initially */ + if (n_test_entries <= 0) + { + add_manual_entry(); + set_active_entry ("*other"); + n_test_entries++; + } + + offer_guest = UnityGreeter.singleton.has_guest_account_hint(); + always_show_manual = UnityGreeter.singleton.show_manual_login_hint(); + + key_press_event.connect (test_key_press_cb); + + if (UnityGreeter.singleton.show_remote_login_hint()) + Timeout.add (1000, () => + { + RemoteServer[] test_server_list = {}; + RemoteServer remote_server = RemoteServer (); + remote_server.type = "uccs"; + remote_server.name = "Remote Login"; + remote_server.url = "http://crazyurl.com"; + remote_server.last_used_server = false; + remote_server.fields = {}; + RemoteServerField field1 = RemoteServerField (); + field1.type = "email"; + RemoteServerField field2 = RemoteServerField (); + field2.type = "password"; + remote_server.fields = {field1, field2}; + + test_server_list += remote_server; + set_remote_directory_servers (test_server_list); + + return false; + }); + + var last_user = UnityGreeter.singleton.get_state ("last-user"); + if (last_user != null) + set_active_entry (last_user); + + } + + private void test_call_set_remote_directory_servers () + { + RemoteServer[] test_server_list = {}; + RemoteServer remote_server = RemoteServer (); + remote_server.type = "uccs"; + remote_server.name = "Corporate Remote Login"; + remote_server.url = "http://internalcompayserver.com"; + remote_server.last_used_server = false; + remote_server.fields = {}; + RemoteServerField field1 = RemoteServerField (); + field1.type = "email"; + RemoteServerField field2 = RemoteServerField (); + field2.type = "password"; + remote_server.fields = {field1, field2}; + + test_server_list += remote_server; + set_remote_directory_servers (test_server_list); + } + + private void test_call_remote_login_servers_updated () + { + RemoteServer[] server_list = {}; + RemoteServer remote_server1 = RemoteServer (); + remote_server1.type = "rdp"; + remote_server1.name = "Cool RDP server"; + remote_server1.url = "http://coolrdpserver.com"; + remote_server1.last_used_server = false; + remote_server1.fields = {}; + RemoteServerField field1 = RemoteServerField (); + field1.type = "username"; + RemoteServerField field2 = RemoteServerField (); + field2.type = "password"; + RemoteServerField field3 = RemoteServerField (); + field3.type = "domain"; + remote_server1.fields = {field1, field2, field3}; + + RemoteServer remote_server2 = RemoteServer (); + remote_server2.type = "rdp"; + remote_server2.name = "MegaCool RDP server"; + remote_server2.url = "http://megacoolrdpserver.com"; + remote_server2.last_used_server = false; + remote_server2.fields = {}; + RemoteServerField field21 = RemoteServerField (); + field21.type = "username"; + RemoteServerField field22 = RemoteServerField (); + field22.type = "password"; + remote_server2.fields = {field21, field22}; + + server_list.resize (2); + server_list[0] = remote_server1; + server_list[1] = remote_server2; + + remote_login_servers_updated (currently_browsing_server_url, currently_browsing_server_email, "", server_list); + } + + private void test_fill_remote_login_servers (out RemoteServer[] server_list) + { + string[] domains = { "SCANNERS", "PRINTERS", "ROUTERS" }; + + server_list = {}; + RemoteServer remote_server1 = RemoteServer (); + remote_server1.type = "rdp"; + remote_server1.name = "Cool RDP server"; + remote_server1.url = "http://coolrdpserver.com"; + remote_server1.last_used_server = false; + remote_server1.fields = {}; + RemoteServerField field1 = RemoteServerField (); + field1.type = "username"; + RemoteServerField field2 = RemoteServerField (); + field2.type = "password"; + RemoteServerField field3 = RemoteServerField (); + field3.type = "domain"; + remote_server1.fields = {field1, field2, field3}; + + RemoteServer remote_server2 = RemoteServer (); + remote_server2.type = "rdp"; + remote_server2.name = "RDP server with default username, and editable domain"; + remote_server2.url = "http://rdpdefaultusername.com"; + remote_server2.last_used_server = false; + remote_server2.fields = {}; + RemoteServerField field21 = RemoteServerField (); + field21.type = "username"; + field21.default_value = new Variant.string ("alowl"); + RemoteServerField field22 = RemoteServerField (); + field22.type = "password"; + RemoteServerField field23 = RemoteServerField (); + field23.type = "domain"; + field23.default_value = new Variant.string ("PRINTERS"); + field23.properties = new HashTable<string, Variant> (str_hash, str_equal); + field23.properties["domains"] = domains; + remote_server2.fields = {field21, field22, field23}; + + RemoteServer remote_server3 = RemoteServer (); + remote_server3.type = "rdp"; + remote_server3.name = "RDP server with default username, and non editable domain"; + remote_server3.url = "http://rdpdefaultusername2.com"; + remote_server3.last_used_server = true; + remote_server3.fields = {}; + RemoteServerField field31 = RemoteServerField (); + field31.type = "username"; + field31.default_value = new Variant.string ("lwola"); + RemoteServerField field32 = RemoteServerField (); + field32.type = "password"; + RemoteServerField field33 = RemoteServerField (); + field33.type = "domain"; + field33.default_value = new Variant.string ("PRINTERS"); + field33.properties = new HashTable<string, Variant> (str_hash, str_equal); + field33.properties["domains"] = domains; + field33.properties["read-only"] = true; + + remote_server3.fields = {field31, field32, field33}; + + RemoteServer remote_server4 = RemoteServer (); + remote_server4.type = "notsupported"; + remote_server4.name = "Not supported server"; + remote_server4.url = "http://notsupportedserver.com"; + remote_server4.fields = {}; + RemoteServerField field41 = RemoteServerField (); + field41.type = "username"; + RemoteServerField field42 = RemoteServerField (); + field42.type = "password"; + RemoteServerField field43 = RemoteServerField (); + field43.type = "domain"; + + remote_server4.fields = {field41, field42, field43}; + + server_list.resize (4); + server_list[0] = remote_server1; + server_list[1] = remote_server2; + server_list[2] = remote_server3; + server_list[3] = remote_server4; + } + + private void test_fill_remote_login_servers_duplicate_entries (out RemoteServer[] server_list) + { + /* Create two remote servers with same url but different username and domain. */ + server_list = {}; + + RemoteServer remote_server2 = RemoteServer (); + remote_server2.type = "rdp"; + remote_server2.name = "RDP server with default username, and editable domain"; + remote_server2.url = "http://rdpdefaultusername.com"; + remote_server2.last_used_server = false; + remote_server2.fields = {}; + RemoteServerField field21 = RemoteServerField (); + field21.type = "username"; + field21.default_value = new Variant.string ("alowl1"); + RemoteServerField field22 = RemoteServerField (); + field22.type = "password"; + field22.default_value = new Variant.string ("duplicate1"); + RemoteServerField field23 = RemoteServerField (); + field23.type = "domain"; + field23.default_value = new Variant.string ("SCANNERS"); + remote_server2.fields = {field21, field22, field23}; + + RemoteServer remote_server5 = RemoteServer (); + remote_server5.type = "rdp"; + remote_server5.name = "RDP server with default username, and editable domain"; + remote_server5.url = "http://rdpdefaultusername.com"; + remote_server5.last_used_server = false; + remote_server5.fields = {}; + RemoteServerField field51 = RemoteServerField (); + field51.type = "username"; + field51.default_value = new Variant.string ("alowl2"); + RemoteServerField field52 = RemoteServerField (); + field52.type = "password"; + field52.default_value = new Variant.string ("duplicate2"); + RemoteServerField field53 = RemoteServerField (); + field53.type = "domain"; + field53.default_value = new Variant.string ("PRINTERS"); + remote_server5.fields = {field51, field52, field53}; + + server_list.resize (2); + server_list[0] = remote_server2; + server_list[1] = remote_server5; + } + + private bool test_key_press_cb (Gdk.EventKey event) + { + if ((event.state & Gdk.ModifierType.CONTROL_MASK) == 0) + return false; + + switch (event.keyval) + { + case Gdk.Key.plus: + add_test_entry (); + break; + case Gdk.Key.minus: + remove_test_entry (); + break; + case Gdk.Key.@0: + while (remove_test_entry ()); + offer_guest = false; + break; + case Gdk.Key.equal: + while (add_test_entry ()); + offer_guest = true; + break; + case Gdk.Key.g: + offer_guest = false; + break; + case Gdk.Key.G: + offer_guest = true; + break; + case Gdk.Key.m: + always_show_manual = false; + break; + case Gdk.Key.M: + always_show_manual = true; + break; + } + + return false; + } + + private bool add_test_entry () + { + var e = test_entries[n_test_entries]; + if (e.username == "") + return false; + + var background = e.background; + if (background == "*") + { + var background_index = 0; + for (var i = 0; i < n_test_entries; i++) + { + if (test_entries[i].background == "*") + background_index++; + } + if (test_backgrounds.length () > 0) + background = test_backgrounds.nth_data (background_index % test_backgrounds.length ()); + } + add_user (e.username, e.real_name, background, e.is_active, e.has_messages, e.session); + n_test_entries++; + + return true; + } + + private bool remove_test_entry () + { + if (n_test_entries == 0) + return false; + + remove_entry (test_entries[n_test_entries - 1].username); + n_test_entries--; + + return true; + } + + private void test_respond (string text) + { + debug ("response %s", text); + switch (get_selected_id ()) + { + case "*other": + if (test_username == null) + { + debug ("username=%s", text); + test_username = text; + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + } + else + { + test_is_authenticated = text == "password"; + authentication_complete_cb (); + } + break; + case "two-factor": + if (!test_prompted_sso) + { + if (text == "password") + { + debug ("prompt otp"); + test_prompted_sso = true; + show_prompt_cb ("OTP:", LightDM.PromptType.QUESTION); + } + else + { + test_is_authenticated = false; + authentication_complete_cb (); + } + } + else + { + test_is_authenticated = text == "otp"; + authentication_complete_cb (); + } + break; + case "two-prompts": + if (test_two_prompts_first == null) + test_two_prompts_first = text; + else + { + test_is_authenticated = test_two_prompts_first == "blue" && text == "password"; + authentication_complete_cb (); + } + break; + case "change-password": + if (test_new_password != null) + { + test_is_authenticated = text == test_new_password; + authentication_complete_cb (); + } + else if (test_request_new_password) + { + test_new_password = text; + show_prompt_cb ("Retype new UNIX password: ", LightDM.PromptType.SECRET); + } + else + { + if (text != "password") + { + test_is_authenticated = false; + authentication_complete_cb (); + } + else + { + test_request_new_password = true; + show_message_cb ("You are required to change your password immediately (root enforced)", LightDM.MessageType.ERROR); + show_prompt_cb ("Enter new UNIX password: ", LightDM.PromptType.SECRET); + } + } + break; + case "no-response": + break; + case "locked": + test_is_authenticated = false; + show_message_cb ("Account is locked", LightDM.MessageType.ERROR); + authentication_complete_cb (); + break; + case "messages-after-login": + test_is_authenticated = text == "password"; + if (test_is_authenticated) + show_message_cb ("Congratulations on logging in!", LightDM.MessageType.INFO); + authentication_complete_cb (); + break; + default: + test_is_authenticated = text == "password"; + authentication_complete_cb (); + break; + } + } + + protected override void test_start_authentication () + { + test_username = null; + test_is_authenticated = false; + test_prompted_sso = false; + test_two_prompts_first = null; + test_request_new_password = false; + test_new_password = null; + + switch (get_selected_id ()) + { + case "*other": + if (authenticate_user != null) + { + test_username = authenticate_user; + authenticate_user = null; + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + } + else + show_prompt_cb ("Username:", LightDM.PromptType.QUESTION); + break; + case "*guest": + test_is_authenticated = true; + authentication_complete_cb (); + break; + case "different-prompt": + show_prompt_cb ("Secret word", LightDM.PromptType.SECRET); + break; + case "no-password": + test_is_authenticated = true; + authentication_complete_cb (); + break; + case "auth-error": + show_message_cb ("Authentication Error", LightDM.MessageType.ERROR); + test_is_authenticated = false; + authentication_complete_cb (); + break; + case "info-prompt": + show_message_cb ("Welcome to Unity Greeter", LightDM.MessageType.INFO); + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + break; + case "long-info-prompt": + show_message_cb ("Welcome to Unity Greeter\n\nWe like to annoy you with long messages.\nLike this one\n\nThis is the last line of a multiple line message.", LightDM.MessageType.INFO); + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + break; + case "wide-info-prompt": + show_message_cb ("Welcome to Unity Greeter, the greeteriest greeter that ever did appear in these fine lands", LightDM.MessageType.INFO); + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + break; + case "multi-info-prompt": + show_message_cb ("Welcome to Unity Greeter", LightDM.MessageType.INFO); + show_message_cb ("This is an error", LightDM.MessageType.ERROR); + show_message_cb ("You should have seen three messages", LightDM.MessageType.INFO); + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + break; + case "two-prompts": + show_prompt_cb ("Favorite Color (blue):", LightDM.PromptType.QUESTION); + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + break; + default: + show_prompt_cb ("Password:", LightDM.PromptType.SECRET); + break; + } + } +} diff --git a/src/user-prompt-box.vala b/src/user-prompt-box.vala new file mode 100644 index 0000000..9b285da --- /dev/null +++ b/src/user-prompt-box.vala @@ -0,0 +1,36 @@ +/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*- + * + * Copyright (C) 2011,2012 Canonical Ltd + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * 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: Robert Ancell <robert.ancell@canonical.com> + * Michael Terry <michael.terry@canonical.com> + */ + +public class UserPromptBox : PromptBox +{ + /* Background for this user */ + public string background; + + /* Default session for this user */ + public string session; + + /* True if should be marked as active */ + public bool is_active; + + public UserPromptBox (string name) + { + Object (id: name); + } +} |