Merge lp:~mterry/unity-greeter/entry-arrow into lp:unity-greeter

[Michael Terry]

Adjust size and mechanics of entry progression arrow to avoid using the entry icon API (which conflicts with the default GTK caps lock icon usage).

=== modified file 'src/dash-entry.vala'
--- src/dash-entry.vala	2012-10-01 16:18:18 +0000
+++ src/dash-entry.vala	2012-10-19 18:34:19 +0000
@@ -21,10 +21,6 @@
 [CCode (cheader_filename = "gtk/gtk.h")]
 extern bool gtk_style_context_lookup_color (Gtk.StyleContext ctx, string color_name, out Gdk.RGBA color);
 
-/* Vala's vapi for gtk3 is broken for get_icon_area (it forgets the out keyword) */
-[CCode (cheader_filename = "gtk/gtk.h")]
-extern void gtk_entry_get_icon_area (Gtk.Entry entry, Gtk.EntryIconPosition icon_pos, out Gdk.Rectangle icon_area);
-
 public class DashEntry : Gtk.Entry, Fadable
 {
     public static string font = "Ubuntu 14";
@@ -47,32 +43,59 @@
                 set_state_flags (Gtk.StateFlags.ACTIVE, false);
             else
                 unset_state_flags (Gtk.StateFlags.ACTIVE);
-            update_arrow ();
+            queue_draw ();
         }
     }
 
     private static const string NO_BORDER_CLASS = "unity-greeter-no-border";
 
     protected FadeTracker fade_tracker { get; protected set; }
-    private Gdk.Rectangle icon_area;
+    private static Gdk.Window arrow_win;
+    private static Gdk.Pixbuf arrow_pixbuf;
 
     construct
     {
         fade_tracker = new FadeTracker (this);
 
-        notify["can-respond"].connect (update_arrow);
-        changed.connect (update_arrow);
-        icon_press.connect (icon_press_cb);
+        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 style_ctx = get_style_context ();
         var no_border_provider = new Gtk.CssProvider ();
         try
         {
@@ -112,27 +135,44 @@
         /* Draw activity spinner if we need to */
         if (did_respond)
             draw_spinner (c);
+        else if (get_text_length () > 0)
+            draw_arrow (c);
 
         return false;
     }
 
     private void draw_spinner (Cairo.Context c)
     {
-        Gtk.Allocation allocation;
-        get_allocation (out allocation);
-        int spinner_side = allocation.height / 2;
-        int margin = (allocation.height - spinner_side) / 2;
+        c.save ();
 
         var style_ctx = get_style_context ();
-        style_ctx.render_activity (c,
-                                   allocation.width - spinner_side - margin,
-                                   margin,
-                                   spinner_side,
-                                   spinner_side);
+        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);
@@ -149,6 +189,8 @@
         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 ()
@@ -165,33 +207,93 @@
         }
     }
 
-    private void icon_press_cb ()
-    {
-        activate ();
-    }
-
-    private void update_arrow ()
-    {
-        show_arrow (get_text_length () != 0);
-    }
-
-    protected void show_arrow (bool visible)
-    {
-        if (visible && can_respond && !did_respond)
-        {
-            var file = File.new_for_path (Path.build_filename (Config.PKGDATADIR, "arrow_right.png", null));
-            var icon = new FileIcon (file);
-            set_icon_from_gicon (Gtk.EntryIconPosition.SECONDARY, icon);
-            set_icon_activatable (Gtk.EntryIconPosition.SECONDARY, true);
-
-            /* Save icon area for later use by spinner.  Save it here instead of
-             * calling it each draw because GtkEntry will return 0 width areas
-             * if we hide the icon. */
-            gtk_entry_get_icon_area (this, Gtk.EntryIconPosition.SECONDARY, out icon_area);
-        }
-        else
-        {
-            set_icon_from_gicon (Gtk.EntryIconPosition.SECONDARY, null);
-        }
+    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.set_user_data (this);
+    }
+
+    public override void unrealize ()
+    {
+        arrow_win.destroy ();
+        arrow_win = null;
+        base.unrealize ();
+    }
+
+    public override void map ()
+    {
+        base.map ();
+        arrow_win.show ();
+    }
+
+    public override void unmap ()
+    {
+        arrow_win.hide ();
+        base.unmap ();
     }
 }