Revert "userWidget.js: Fix updating the image when the user avatar changes."

This reverts commit 347c39c.

The texture cache properly drops the image when the underlying file
changes, but the theme context itself has created its own cogl
resource and caches it also. We can monitor the texture cache there.

Author: mtwebster

js/ui/userWidget.js

@@ -14,101 +14,86 @@ const Params = imports.misc.params;
 var AVATAR_ICON_SIZE = 64;
 
 var Avatar = GObject.registerClass(
-class Avatar extends Clutter.Actor {
+class Avatar extends St.Bin {
     _init(user, params) {
         let themeContext = St.ThemeContext.get_for_stage(global.stage);
         params = Params.parse(params, {
             styleClass: 'user-icon',
             reactive: true,
+            track_hover: true,
             iconSize: AVATAR_ICON_SIZE,
         });
 
         super._init({
-            layout_manager: new Clutter.BinLayout(),
+            style_class: params.styleClass,
             reactive: params.reactive,
             width: params.iconSize * themeContext.scaleFactor,
             height: params.iconSize * themeContext.scaleFactor,
         });
 
-        this._styleClass = params.styleClass;
+        this.connect('notify::hover', this._onHoverChanged.bind(this));
+
+        this.set_important(true);
         this._iconSize = params.iconSize;
         this._user = user;
-        this._iconFile = null;
-        this._child = null;
 
+        this.bind_property('reactive', this, 'track-hover',
+            GObject.BindingFlags.SYNC_CREATE);
         this.bind_property('reactive', this, 'can-focus',
             GObject.BindingFlags.SYNC_CREATE);
 
         // Monitor the scaling factor to make sure we recreate the avatar when needed.
         this._scaleFactorChangeId =
             themeContext.connect('notify::scale-factor', this.update.bind(this));
 
-        // Monitor for changes to the icon file on disk
-        this._textureCache = St.TextureCache.get_default();
-        this._textureFileChangedId =
-            this._textureCache.connect('texture-file-changed', this._onTextureFileChanged.bind(this));
-
         this.connect('destroy', this._onDestroy.bind(this));
     }
 
     _onHoverChanged() {
-        if (!this._child)
-            return;
-
-        if (this._child.hover) {
-            if (this._iconFile) {
+        if (this.hover) {
+            if (this.child) {
+                this.child.add_style_class_name('highlighted');
+            }
+            else {
                 let effect = new Clutter.BrightnessContrastEffect();
                 effect.set_brightness(0.2);
                 effect.set_contrast(0.3);
-                this._child.add_effect(effect);
-            } else {
-                this._child.add_style_class_name('highlighted');
+                this.add_effect(effect);
             }
-            this._child.add_accessible_state(Atk.StateType.FOCUSED);
+            this.add_accessible_state(Atk.StateType.FOCUSED);
         } else {
-            if (this._iconFile) {
-                this._child.clear_effects();
-            } else {
-                this._child.remove_style_class_name('highlighted');
+            if (this.child) {
+                this.child.remove_style_class_name('highlighted');
             }
-            this._child.remove_accessible_state(Atk.StateType.FOCUSED);
+            else {
+                this.clear_effects();
+            }
+            this.remove_accessible_state(Atk.StateType.FOCUSED);
         }
     }
 
-    _onStyleChanged() {
-        let node = this._child.get_theme_node();
+    vfunc_style_changed() {
+        super.vfunc_style_changed();
+
+        let node = this.get_theme_node();
         let [found, iconSize] = node.lookup_length('icon-size', false);
 
         if (!found)
             return;
 
         let themeContext = St.ThemeContext.get_for_stage(global.stage);
 
-        // node.lookup_length() returns a scaled value, but we need unscaled
-        let newIconSize = iconSize / themeContext.scaleFactor;
-
-        if (newIconSize !== this._iconSize) {
-            this._iconSize = newIconSize;
-            this.update();
-        }
+        // node.lookup_length() returns a scaled value, but we
+        // need unscaled
+        this._iconSize = iconSize / themeContext.scaleFactor;
+        this.update();
     }
 
     _onDestroy() {
         if (this._scaleFactorChangeId) {
             let themeContext = St.ThemeContext.get_for_stage(global.stage);
             themeContext.disconnect(this._scaleFactorChangeId);
-            this._scaleFactorChangeId = 0;
-        }
-
-        if (this._textureFileChangedId) {
-            this._textureCache.disconnect(this._textureFileChangedId);
-            this._textureFileChangedId = 0;
-        }
-    }
-
-    _onTextureFileChanged(cache, file) {
-        if (this._iconFile && file.get_path() === this._iconFile) {
-            this.update();
+            delete this._scaleFactorChangeId;
         }
     }
 
@@ -129,49 +114,24 @@ class Avatar extends Clutter.Actor {
                 iconFile = null;
         }
 
-        this._iconFile = iconFile;
-
         let { scaleFactor } = St.ThemeContext.get_for_stage(global.stage);
         this.set_size(
             this._iconSize * scaleFactor,
             this._iconSize * scaleFactor);
 
-        // Remove old child
-        if (this._child) {
-            this._child.destroy();
-            this._child = null;
-        }
-
-        let size = this._iconSize * scaleFactor;
-
         if (iconFile) {
-            this._child = new St.Bin({
-                style_class: `${this._styleClass} user-avatar`,
-                reactive: this.reactive,
-                track_hover: this.reactive,
-                width: size,
-                height: size,
-                style: `background-image: url("${iconFile}"); background-size: cover;`,
-            });
+            this.child = null;
+            this.add_style_class_name('user-avatar');
+            this.style = `
+                background-image: url("${iconFile}");
+                background-size: cover;`;
         } else {
-            this._child = new St.Bin({
-                style_class: this._styleClass,
-                reactive: this.reactive,
-                track_hover: this.reactive,
-                width: size,
-                height: size,
-                child: new St.Icon({
-                    icon_name: 'xsi-avatar-default-symbolic',
-                    icon_size: this._iconSize,
-                }),
+            this.style = null;
+            this.child = new St.Icon({
+                icon_name: 'xsi-avatar-default-symbolic',
+                icon_size: this._iconSize,
             });
         }
-
-        this._child.set_important(true);
-        this._child.connect('notify::hover', this._onHoverChanged.bind(this));
-        this._child.connect('style-changed', this._onStyleChanged.bind(this));
-
-        this.add_child(this._child);
     }
 });
 
@@ -195,7 +155,7 @@ class UserWidget extends St.BoxLayout {
 
         this._avatar = new Avatar(user);
         this._avatar.x_align = Clutter.ActorAlign.CENTER;
-        this.add_child(this._avatar);
+        this.add(this._avatar, { x_fill: false });
 
         this._label = new St.Label({ style_class: 'user-widget-label' });
         this._label.y_align = Clutter.ActorAlign.CENTER;