fixup gsk

These are the equivalents of the linear gradient apis.

NEWS

@@ -1,3 +1,67 @@
+Overview of Changes in GTK 3.99.2
+=================================
+
+* GtkEntry:
+ - Fix issues with Emoji insertion
+ - Fix issues with dnd
+ - Set correct hotspot for dnd icon
+
+* GtkPasswordEntry:
+ - Use non-pageable memory
+
+* GtkSearchEntry:
+ - Don't handle forwarded events twice
+
+* GtkTextView:
+ - Fix dnd
+ - Improve undo state tracking
+
+* GtkRevealer:
+ - Fix clipping issues in the swing transitions
+
+* GL renderer:
+ - Fix clipping with projective transforms
+ - Use linear interpolation for offscreen rendering
+   with non-axis-aligned transforms
+ - Fix texture caching to avoid size mismatches
+
+* CSS:
+ - Allow more than 64 selectors per rule
+
+* API cleanup:
+ - Make filter and sorter constructors return exact
+   types
+
+* Demos:
+ - Bug fixes and cosmetic improvements
+ - Add a Shadertoy demo
+
+* Build:
+ - Fix Vulkan dependency checking
+ - Make sysprof truly optional
+
+* Translation updates:
+ Basque
+ Catalan
+ Croatian
+ Czech
+ Danish
+ French
+ Galician
+ German
+ Hungarian
+ Indonesian
+ Kazakh
+ Lithuanian
+ Persian
+ Polish
+ Slovak
+ Slovenian
+ Spanish
+ Turkish
+ Ukrainian
+
+
 Overview of Changes in GTK 3.99.1
 =================================
 

config.h.meson

@@ -69,6 +69,9 @@
 /* Define to 1 if you have the `mkstemp' function. */
 #mesondefine HAVE_MKSTEMP
 
+/* Define to 1 if you have the `mlock` function. */
+#mesondefine HAVE_MLOCK
+
 /* Define to 1 if you have a working `mmap' system call. */
 #mesondefine HAVE_MMAP
 

demos/gtk-demo/alienplanet.glsl

@@ -0,0 +1,345 @@
+// Originally from: https://www.shadertoy.com/view/wsjBD3
+// License CC0: A battered alien planet
+//  Been experimenting with space inspired shaders
+
+#define PI  3.141592654
+#define TAU (2.0*PI)
+
+#define TOLERANCE       0.00001
+#define MAX_ITER        65
+#define MIN_DISTANCE    0.01
+#define MAX_DISTANCE    9.0
+
+const vec3  skyCol1       = vec3(0.35, 0.45, 0.6);
+const vec3  skyCol2       = vec3(0.4, 0.7, 1.0);
+const vec3  skyCol3       = pow(skyCol1, vec3(0.25));
+const vec3  sunCol1       = vec3(1.0,0.6,0.4);
+const vec3  sunCol2       = vec3(1.0,0.9,0.7);
+const vec3  smallSunCol1  = vec3(1.0,0.5,0.25)*0.5;
+const vec3  smallSunCol2  = vec3(1.0,0.5,0.25)*0.5;
+const vec3  mountainColor = 1.0*sqrt(vec3(0.95, 0.65, 0.45));
+const float cellWidth     = 1.0;
+const vec4  planet        = vec4(80.0, -20.0, 100.0, 50.0)*1000.0;
+
+void rot(inout vec2 p, float a) {
+  float c = cos(a);
+  float s = sin(a);
+  p = vec2(p.x*c + p.y*s, -p.x*s + p.y*c);
+}
+
+vec2 mod2(inout vec2 p, vec2 size) {
+  vec2 c = floor((p + size*0.5)/size);
+  p = mod(p + size*0.5,size) - size*0.5;
+  return c;
+}
+
+float circle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float egg(vec2 p, float ra, float rb) {
+  const float k = sqrt(3.0);
+  p.x = abs(p.x);
+  float r = ra - rb;
+  return ((p.y<0.0)       ? length(vec2(p.x,  p.y    )) - r :
+          (k*(p.x+r)<p.y) ? length(vec2(p.x,  p.y-k*r)) :
+                              length(vec2(p.x+r,p.y    )) - 2.0*r) - rb;
+}
+
+vec2 hash(vec2 p) {
+  p = vec2(dot (p, vec2 (127.1, 311.7)), dot (p, vec2 (269.5, 183.3)));
+  return -1. + 2.*fract (sin (p)*43758.5453123);
+}
+
+vec2 raySphere(vec3 ro, vec3 rd, vec4 sphere) {
+  vec3 center = sphere.xyz;
+  float radius = sphere.w;
+  vec3 m = ro - center.xyz;
+  float b = dot(m, rd);
+  float c = dot(m, m) - radius*radius;
+  if(c > 0.0 && b > 0.0) return vec2(-1.0, -1.0);
+  float discr = b * b - c;
+  if(discr < 0.0) return vec2(-1.0);
+  float normalMultiplier = 1.0;
+  float s = sqrt(discr);
+  float t0 = -b - s;
+  float t1 = -b + s;;
+  return vec2(t0, t1);
+}
+
+float noise1(vec2 p) {
+  vec2 n = mod2(p, vec2(cellWidth));
+  vec2 hh = hash(sqrt(2.0)*(n+1000.0));
+  hh.x *= hh.y;
+
+  float r = 0.225*cellWidth;
+
+  float d = circle(p, 2.0*r);
+
+  float h = hh.x*smoothstep(0.0, r, -d);
+
+  return h*0.25;
+}
+
+float noise2(vec2 p) {
+  vec2 n = mod2(p, vec2(cellWidth));
+  vec2 hh = hash(sqrt(2.0)*(n+1000.0));
+  hh.x *= hh.y;
+
+  rot(p, TAU*hh.y);
+  float r = 0.45*cellWidth;
+
+//  float d = circle(p, 1.0*r);
+  float d = egg(p, 0.75*r, 0.5*r*abs(hh.y));
+
+  float h = (hh.x)*smoothstep(0.0, r, -2.0*d);
+
+  return h*0.275;
+}
+
+
+float height(vec2 p, float dd, int mx) {
+  const float aa   = 0.45;
+  const float ff   = 2.03;
+  const float tt   = 1.2;
+  const float oo   = 3.93;
+  const float near = 0.25;
+  const float far  = 0.65;
+
+  float a = 1.0;
+  float o = 0.2;
+  float s = 0.0;
+  float d = 0.0;
+
+  int i = 0;
+
+  for (; i < 4;++i) {
+    float nn = a*noise2(p);
+    s += nn;
+    d += abs(a);
+    p += o;
+    a *= aa;
+    p *= ff;
+    o *= oo;
+    rot(p, tt);
+  }
+
+  float lod = s/d;
+
+  float rdd = dd/MAX_DISTANCE;
+  mx = int(mix(float(4), float(mx), step(rdd, far)));
+
+  for (; i < mx; ++i) {
+    float nn = a*noise1(p);
+    s += nn;
+    d += abs(a);
+    p += o;
+    a *= aa;
+    p *= ff;
+    o *= oo;
+    rot(p, tt);
+  }
+
+  float hid = (s/d);
+
+  return mix(hid, lod, smoothstep(near, far, rdd));
+}
+
+float loheight(vec2 p, float d) {
+  return height(p, d, 0);
+}
+
+float height(vec2 p, float d) {
+  return height(p, d, 6);
+}
+
+float hiheight(vec2 p, float d) {
+  return height(p, d, 8);
+}
+
+vec3 normal(vec2 p, float d) {
+  vec2 eps = vec2(0.00125, 0.0);
+
+  vec3 n;
+
+  n.x = (hiheight(p - eps.xy, d) - hiheight(p + eps.xy, d));
+  n.y = 2.0*eps.x;
+  n.z = (hiheight(p - eps.yx, d) - hiheight(p + eps.yx, d));
+
+  return normalize(n);
+}
+
+const float stepLength[] = float[](0.9, 0.25);
+
+
+float march(vec3 ro, vec3 rd, out int max_iter) {
+  float dt = 0.1;
+  float d = MIN_DISTANCE;
+  int currentStep = 0;
+  float lastd = d;
+  for (int i = 0; i < MAX_ITER; ++i)
+  {
+    vec3 p = ro + d*rd;
+    float h = height(p.xz, d);
+
+    if (d > MAX_DISTANCE) {
+      max_iter = i;
+      return MAX_DISTANCE;
+    }
+
+    float hd = p.y - h;
+
+    if (hd < TOLERANCE) {
+      ++currentStep;
+      if (currentStep >= stepLength.length()) {
+        max_iter = i;
+        return d;
+      }
+
+      d = lastd;
+      continue;
+    }
+
+    float sl = stepLength[currentStep];
+
+    dt = max(hd, TOLERANCE)*sl + 0.0025*d;
+    lastd = d;
+    d += dt;
+  }
+
+  max_iter = MAX_ITER;
+  return MAX_DISTANCE;
+}
+
+vec3 sunDirection() {
+  return normalize(vec3(-0.5, 0.085, 1.0));
+}
+
+vec3 smallSunDirection() {
+  return normalize(vec3(-0.2, -0.05, 1.0));
+}
+
+float psin(float f) {
+  return 0.5 + 0.5*sin(f);
+}
+
+vec3 skyColor(vec3 ro, vec3 rd) {
+  vec3 sunDir = sunDirection();
+  vec3 smallSunDir = smallSunDirection();
+
+  float sunDot = max(dot(rd, sunDir), 0.0);
+  float smallSunDot = max(dot(rd, smallSunDir), 0.0);
+
+  float angle = atan(rd.y, length(rd.xz))*2.0/PI;
+
+  vec3 skyCol = mix(mix(skyCol1, skyCol2, max(0.0, angle)), skyCol3, clamp(-angle*2.0, 0.0, 1.0));
+
+  vec3 sunCol = 0.5*sunCol1*pow(sunDot, 20.0) + 8.0*sunCol2*pow(sunDot, 2000.0);
+  vec3 smallSunCol = 0.5*smallSunCol1*pow(smallSunDot, 200.0) + 8.0*smallSunCol2*pow(smallSunDot, 20000.0);
+
+  vec3 dust = pow(sunCol2*mountainColor, vec3(1.75))*smoothstep(0.05, -0.1, rd.y)*0.5;
+
+  vec2 si = raySphere(ro, rd, planet);
+
+  vec3 planetSurface = ro + si.x*rd;
+  vec3 planetNormal = normalize(planetSurface - planet.xyz);
+  float planetDiff = max(dot(planetNormal, sunDir), 0.0);
+  float planetBorder = max(dot(planetNormal, -rd), 0.0);
+  float planetLat = (planetSurface.x+planetSurface.y)*0.0005;
+  vec3 planetCol = mix(1.3*vec3(0.9, 0.8, 0.7), 0.3*vec3(0.9, 0.8, 0.7), pow(psin(planetLat+1.0)*psin(sqrt(2.0)*planetLat+2.0)*psin(sqrt(3.5)*planetLat+3.0), 0.5));
+
+  vec3 final = vec3(0.0);
+
+  final += step(0.0, si.x)*pow(planetDiff, 0.75)*planetCol*smoothstep(-0.075, 0.0, rd.y)*smoothstep(0.0, 0.1, planetBorder);
+
+  final += skyCol + sunCol + smallSunCol + dust;
+
+  return final;
+}
+
+vec3 getColor(vec3 ro, vec3 rd) {
+  int max_iter = 0;
+  vec3 skyCol = skyColor(ro, rd);
+  vec3 col = vec3(0);
+
+  float d = march(ro, rd, max_iter);
+
+  if (d < MAX_DISTANCE)   {
+    vec3 sunDir = sunDirection();
+    vec3 osunDir = sunDir*vec3(-1.0, .0, -1.0);
+    vec3 p = ro + d*rd;
+
+    vec3 normal = normal(p.xz, d);
+
+    float amb = 0.2;
+
+    float dif1 = max(0.0, dot(sunDir, normal));
+    vec3 shd1 = sunCol2*mix(amb, 1.0, pow(dif1, 0.75));
+
+    float dif2 = max(0.0, dot(osunDir, normal));
+    vec3 shd2 = sunCol1*mix(amb, 1.0, pow(dif2, 0.75));
+
+    vec3 ref = reflect(rd, normal);
+    vec3 rcol = skyColor(p, ref);
+
+    col = mountainColor*amb*skyCol3;
+    col += mix(shd1, shd2, -0.5)*mountainColor;
+    float fre = max(dot(normal, -rd), 0.0);
+    fre = pow(1.0 - fre, 5.0);
+    col += rcol*fre*0.5;
+    col += (1.0*p.y);
+    col = tanh(col);
+    col = mix(col, skyCol, smoothstep(0.5*MAX_DISTANCE, 1.0*MAX_DISTANCE, d));
+
+  } else {
+    col = skyCol;
+  }
+
+//  col += vec3(1.1, 0.0, 0.0)* smoothstep(0.25, 1.0,(float(max_iter)/float(MAX_ITER)));
+  return col;
+}
+
+vec3 getSample1(vec2 p, float time) {
+  float off = 0.5*iTime;
+
+  vec3 ro  = vec3(0.5, 1.0-0.25, -2.0 + off);
+  vec3 la  = ro + vec3(0.0, -0.30,  2.0);
+
+  vec3 ww = normalize(la - ro);
+  vec3 uu = normalize(cross(vec3(0.0,1.0,0.0), ww));
+  vec3 vv = normalize(cross(ww, uu));
+  vec3 rd = normalize(p.x*uu + p.y*vv + 2.0*ww);
+
+  vec3 col = getColor(ro, rd)  ;
+
+  return col;
+}
+
+vec3 getSample2(vec2 p, float time) {
+  p.y-=time*0.25;
+  float h = height(p, 0.0);
+  vec3 n = normal(p, 0.0);
+
+  vec3 lp = vec3(10.0, -1.2, 0.0);
+
+  vec3 ld = normalize(vec3(p.x, h, p.y)- lp);
+
+  float d = max(dot(ld, n), 0.0);
+
+  vec3 col = vec3(0.0);
+
+  col = vec3(1.0)*(h+0.1);
+  col += vec3(1.5)*pow(d, 0.75);
+
+  return col;
+}
+
+void mainImage(out vec4 fragColor, vec2 fragCoord) {
+  vec2 q = fragCoord.xy/iResolution.xy;
+  vec2 p = -1.0 + 2.0*q;
+  p.x *= iResolution.x/iResolution.y;
+
+  vec3 col = getSample1(p, iTime);
+
+  fragColor = vec4(col, 1.0);
+}

demos/gtk-demo/application.c

@@ -472,11 +472,11 @@ static void
 surface_state_changed (GtkWidget *widget)
 {
   DemoApplicationWindow *window = (DemoApplicationWindow *)widget;
-  GdkSurfaceState new_state;
+  GdkToplevelState new_state;
 
   new_state = gdk_toplevel_get_state (GDK_TOPLEVEL (gtk_native_get_surface (GTK_NATIVE (widget))));
-  window->maximized = (new_state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
-  window->fullscreen = (new_state & GDK_SURFACE_STATE_FULLSCREEN) != 0;
+  window->maximized = (new_state & GDK_TOPLEVEL_STATE_MAXIMIZED) != 0;
+  window->fullscreen = (new_state & GDK_TOPLEVEL_STATE_FULLSCREEN) != 0;
 }
 
 static void

demos/gtk-demo/cogs.glsl

@@ -0,0 +1,224 @@
+// Originally from: https://www.shadertoy.com/view/3ljyDD
+// License CC0: Hexagonal tiling + cog wheels
+//  Nothing fancy, just hexagonal tiling + cog wheels
+
+#define PI      3.141592654
+#define TAU     (2.0*PI)
+#define MROT(a) mat2(cos(a), sin(a), -sin(a), cos(a))
+
+float hash(in vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,58.233))) * 13758.5453);
+}
+
+float pcos(float a) {
+  return 0.5 + 0.5*cos(a);
+}
+
+void rot(inout vec2 p, float a) {
+  float c = cos(a);
+  float s = sin(a);
+  p = vec2(c*p.x + s*p.y, -s*p.x + c*p.y);
+}
+
+float modPolar(inout vec2 p, float repetitions) {
+  float angle = 2.0*PI/repetitions;
+  float a = atan(p.y, p.x) + angle/2.;
+  float r = length(p);
+  float c = floor(a/angle);
+  a = mod(a,angle) - angle/2.;
+  p = vec2(cos(a), sin(a))*r;
+  // For an odd number of repetitions, fix cell index of the cell in -x direction
+  // (cell index would be e.g. -5 and 5 in the two halves of the cell):
+  if (abs(c) >= (repetitions/2.0)) c = abs(c);
+  return c;
+}
+
+float pmin(float a, float b, float k) {
+  float h = clamp( 0.5+0.5*(b-a)/k, 0.0, 1.0 );
+  return mix( b, a, h ) - k*h*(1.0-h);
+}
+
+const vec2 sz       = vec2(1.0, sqrt(3.0));
+const vec2 hsz      = 0.5*sz;
+const float smallCount = 16.0;
+
+vec2 hextile(inout vec2 p) {
+  // See Art of Code: Hexagonal Tiling Explained!
+  // https://www.youtube.com/watch?v=VmrIDyYiJBA
+
+  vec2 p1 = mod(p, sz)-hsz;
+  vec2 p2 = mod(p - hsz*1.0, sz)-hsz;
+  vec2 p3 = mix(p2, p1, vec2(length(p1) < length(p2)));
+  vec2 n = p3 - p;
+  p = p3;
+
+  return n;
+}
+
+float circle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float box(vec2 p, vec2 b) {
+  vec2 d = abs(p)-b;
+  return length(max(d,0.0)) + min(max(d.x,d.y),0.0);
+}
+
+float unevenCapsule(vec2 p, float r1, float r2, float h) {
+  p.x = abs(p.x);
+  float b = (r1-r2)/h;
+  float a = sqrt(1.0-b*b);
+  float k = dot(p,vec2(-b,a));
+  if( k < 0.0 ) return length(p) - r1;
+  if( k > a*h ) return length(p-vec2(0.0,h)) - r2;
+  return dot(p, vec2(a,b) ) - r1;
+}
+
+float cogwheel(vec2 p, float innerRadius, float outerRadius, float cogs, float holes) {
+  float cogWidth  = 0.25*innerRadius*TAU/cogs;
+
+  float d0 = circle(p, innerRadius);
+
+  vec2 icp = p;
+  modPolar(icp, holes);
+  icp -= vec2(innerRadius*0.55, 0.0);
+  float d1 = circle(icp, innerRadius*0.25);
+
+  vec2 cp = p;
+  modPolar(cp, cogs);
+  cp -= vec2(innerRadius, 0.0);
+  float d2 = unevenCapsule(cp.yx, cogWidth, cogWidth*0.75, (outerRadius-innerRadius));
+
+  float d3 = circle(p, innerRadius*0.20);
+
+  float d = 1E6;
+  d = min(d, d0);
+  d = pmin(d, d2, 0.5*cogWidth);
+  d = min(d, d2);
+  d = max(d, -d1);
+  d = max(d, -d3);
+
+  return d;
+}
+
+float ccell1(vec2 p, float r) {
+  float d = 1E6;
+  const float bigCount = 60.0;
+
+  vec2 cp0 = p;
+  rot(cp0, -iTime*TAU/bigCount);
+  float d0 = cogwheel(cp0, 0.36, 0.38, bigCount, 5.0);
+
+  vec2 cp1 = p;
+  float nm = modPolar(cp1, 6.0);
+
+  cp1 -= vec2(0.5, 0.0);
+  rot(cp1, 0.2+TAU*nm/2.0 + iTime*TAU/smallCount);
+  float d1 = cogwheel(cp1, 0.11, 0.125, smallCount, 5.0);
+
+  d = min(d, d0);
+  d = min(d, d1);
+  return d;
+}
+
+float ccell2(vec2 p, float r) {
+  float d = 1E6;
+  vec2 cp0 = p;
+  float nm = modPolar(cp0, 6.0);
+  vec2 cp1 = cp0;
+  const float off = 0.275;
+  const float count = smallCount + 2.0;
+  cp0 -= vec2(off, 0.0);
+  rot(cp0, 0.+TAU*nm/2.0 - iTime*TAU/count);
+  float d0 = cogwheel(cp0, 0.09, 0.105, count, 5.0);
+
+
+  cp1 -= vec2(0.5, 0.0);
+  rot(cp1, 0.2+TAU*nm/2.0 + iTime*TAU/smallCount);
+  float d1 = cogwheel(cp1, 0.11, 0.125, smallCount, 5.0);
+
+  float l = length(p);
+  float d2 = l - (off+0.055);
+  float d3 = d2 + 0.020;;
+
+  vec2 tp0 = p;
+  modPolar(tp0, 60.0);
+  tp0.x -= off;
+  float d4 = box(tp0, vec2(0.0125, 0.005));
+
+  float ctime = -(iTime*0.05 + r)*TAU;
+
+  vec2 tp1 = p;
+  rot(tp1, ctime*12.0);
+  tp1.x -= 0.13;
+  float d5 = box(tp1, vec2(0.125, 0.005));
+
+  vec2 tp2 = p;
+  rot(tp2, ctime);
+  tp2.x -= 0.13*0.5;
+  float d6 = box(tp2, vec2(0.125*0.5, 0.0075));
+
+  float d7 = l - 0.025;
+  float d8 = l - 0.0125;
+
+  d = min(d, d0);
+  d = min(d, d1);
+  d = min(d, d2);
+  d = max(d, -d3);
+  d = min(d, d4);
+  d = min(d, d5);
+  d = min(d, d6);
+  d = min(d, d7);
+  d = max(d, -d8);
+
+  return d;
+}
+
+float df(vec2 p, float scale, inout vec2 nn) {
+  p /= scale;
+  nn = hextile(p);
+  nn = round(nn);
+  float r = hash(nn);
+
+  float d;;
+
+  if (r < 0.5) {
+    d = ccell1(p, r);
+  } else {
+    d = ccell2(p, r);
+  }
+
+  return d*scale;
+}
+
+vec3 postProcess(vec3 col, vec2 q)  {
+  //col = saturate(col);
+  col=pow(clamp(col,0.0,1.0),vec3(0.75));
+  col=col*0.6+0.4*col*col*(3.0-2.0*col);  // contrast
+  col=mix(col, vec3(dot(col, vec3(0.33))), -0.4);  // satuation
+  col*=0.5+0.5*pow(19.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.7);  // vigneting
+  return col;
+}
+
+void mainImage(out vec4 fragColor, vec2 fragCoord) {
+  vec2 q = fragCoord/iResolution.xy;
+  vec2 p = -1.0 + 2.0*q;
+  p.x *= iResolution.x/iResolution.y;
+  float tm = iTime*0.1;
+  p += vec2(cos(tm), sin(tm*sqrt(0.5)));
+  float z = mix(0.5, 1.0, pcos(tm*sqrt(0.3)));
+  float aa = 4.0 / iResolution.y;
+
+  vec2 nn = vec2(0.0);
+  float d = df(p, z, nn);
+
+  vec3 col = vec3(160.0)/vec3(255.0);
+  vec3 baseCol = vec3(0.3);
+  vec4 logoCol = vec4(baseCol, 1.0)*smoothstep(-aa, 0.0, -d);
+  col = mix(col, logoCol.xyz, pow(logoCol.w, 8.0));
+  col += 0.4*pow(abs(sin(20.0*d)), 0.6);
+
+  col = postProcess(col, q);
+
+  fragColor = vec4(col, 1.0);
+}

demos/gtk-demo/constraints.c

@@ -254,15 +254,11 @@ do_constraints (GtkWidget *do_widget)
 
  if (!window)
    {
-     GtkWidget *header, *box, *grid, *button;
+     GtkWidget *box, *grid;
 
      window = gtk_window_new ();
      gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget));
      gtk_window_set_title (GTK_WINDOW (window), "Constraints");
-
-     header = gtk_header_bar_new ();
-     gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
-     gtk_window_set_titlebar (GTK_WINDOW (window), header);
      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
@@ -272,12 +268,6 @@ do_constraints (GtkWidget *do_widget)
      gtk_widget_set_hexpand (grid, TRUE);
      gtk_widget_set_vexpand (grid, TRUE);
      gtk_box_append (GTK_BOX (box), grid);
-
-     button = gtk_button_new_with_label ("Close");
-     gtk_box_append (GTK_BOX (box), button);
-     gtk_widget_set_hexpand (grid, TRUE);
-     g_signal_connect_swapped (button, "clicked",
-                               G_CALLBACK (gtk_window_destroy), window);
    }
 
  if (!gtk_widget_get_visible (window))

demos/gtk-demo/constraints2.c

@@ -210,15 +210,11 @@ do_constraints2 (GtkWidget *do_widget)
 
  if (!window)
    {
-     GtkWidget *header, *box, *grid, *button;
+     GtkWidget *box, *grid;
 
      window = gtk_window_new ();
      gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget));
      gtk_window_set_title (GTK_WINDOW (window), "Constraints");
-
-     header = gtk_header_bar_new ();
-     gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
-     gtk_window_set_titlebar (GTK_WINDOW (window), header);
      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
@@ -228,12 +224,6 @@ do_constraints2 (GtkWidget *do_widget)
      gtk_widget_set_hexpand (grid, TRUE);
      gtk_widget_set_vexpand (grid, TRUE);
      gtk_box_append (GTK_BOX (box), grid);
-
-     button = gtk_button_new_with_label ("Close");
-     gtk_box_append (GTK_BOX (box), button);
-     gtk_widget_set_hexpand (grid, TRUE);
-     g_signal_connect_swapped (button, "clicked",
-                               G_CALLBACK (gtk_window_destroy), window);
    }
 
  if (!gtk_widget_get_visible (window))

demos/gtk-demo/constraints3.c

@@ -130,15 +130,11 @@ do_constraints3 (GtkWidget *do_widget)
 
  if (!window)
    {
-     GtkWidget *header, *box, *grid, *button;
+     GtkWidget *box, *grid;
 
      window = gtk_window_new ();
      gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget));
      gtk_window_set_title (GTK_WINDOW (window), "Constraints");
-
-     header = gtk_header_bar_new ();
-     gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
-     gtk_window_set_titlebar (GTK_WINDOW (window), header);
      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
@@ -148,12 +144,6 @@ do_constraints3 (GtkWidget *do_widget)
      gtk_widget_set_hexpand (grid, TRUE);
      gtk_widget_set_vexpand (grid, TRUE);
      gtk_box_append (GTK_BOX (box), grid);
-
-     button = gtk_button_new_with_label ("Close");
-     gtk_box_append (GTK_BOX (box), button);
-     gtk_widget_set_hexpand (grid, TRUE);
-     g_signal_connect_swapped (button, "clicked",
-                               G_CALLBACK (gtk_window_destroy), window);
    }
 
  if (!gtk_widget_get_visible (window))

demos/gtk-demo/demo.gresource.xml

@@ -121,6 +121,15 @@
     <file>gtkgears.c</file>
     <file>gtkgears.h</file>
   </gresource>
+  <gresource prefix="/shadertoy">
+    <file>gtkshadertoy.c</file>
+    <file>gtkshadertoy.h</file>
+    <file>alienplanet.glsl</file>
+    <file>mandelbrot.glsl</file>
+    <file>neon.glsl</file>
+    <file>cogs.glsl</file>
+    <file>glowingstars.glsl</file>
+  </gresource>
   <gresource prefix="/iconscroll">
     <file>iconscroll.ui</file>
   </gresource>
@@ -249,6 +258,7 @@
     <file>pagesetup.c</file>
     <file>paintable.c</file>
     <file>paintable_animated.c</file>
+    <file>paintable_emblem.c</file>
     <file>paintable_mediastream.c</file>
     <file>panes.c</file>
     <file>password_entry.c</file>
@@ -260,6 +270,7 @@
     <file>scale.c</file>
     <file>search_entry.c</file>
     <file>search_entry2.c</file>
+    <file>shadertoy.c</file>
     <file>shortcuts.c</file>
     <file>shortcut_triggers.c</file>
     <file>sizegroup.c</file>

demos/gtk-demo/four_point_transform.c

@@ -63,11 +63,15 @@ unit_to (graphene_point3d_t *p1,
   graphene_matrix_multiply (&s, &u, m);
 }
 
-/* Make a 4x4 matrix that maps
+/* Compute a 4x4 matrix m that maps
  * p1 -> q1
  * p2 -> q2
  * p3 -> q3
  * p4 -> q4
+ *
+ * This is not in general possible, because projective
+ * transforms preserve coplanarity. But in the cases we
+ * care about here, both sets of points are always coplanar.
  */
 void
 perspective_3d (graphene_point3d_t *p1,

demos/gtk-demo/glowingstars.glsl

@@ -0,0 +1,174 @@
+// Originally from: https://www.shadertoy.com/view/ttBcRV
+// License CC0: Flying through glowing stars
+//  The result of playing around trying to improve an old shader
+
+#define PI              3.141592654
+#define TAU             (2.0*PI)
+#define TIME            iTime
+#define RESOLUTION      iResolution
+
+#define LESS(a,b,c)     mix(a,b,step(0.,c))
+#define SABS(x,k)       LESS((.5/(k))*(x)*(x)+(k)*.5,abs(x),abs(x)-(k))
+
+#define MROT(a) mat2(cos(a), sin(a), -sin(a), cos(a))
+
+vec3 hsv2rgb(vec3 c) {
+  const vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+float hash(in vec3 co) {
+  return fract(sin(dot(co, vec3(12.9898,58.233, 12.9898+58.233))) * 13758.5453);
+}
+
+float starn(vec2 p, float r, int n, float m) {
+  // From IQ: https://www.shadertoy.com/view/3tSGDy
+  // https://iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm
+
+  // Minor tweak to use SABS over abs to smooth inner corners
+  // SABS: https://www.shadertoy.com/view/Ws2SDK
+
+  // next 4 lines can be precomputed for a given shape
+  float an = 3.141593/float(n);
+  float en = 3.141593/m;  // m is between 2 and n
+  vec2  acs = vec2(cos(an),sin(an));
+  vec2  ecs = vec2(cos(en),sin(en)); // ecs=vec2(0,1) for regular polygon,
+
+  float bn = mod(atan(p.x,p.y),2.0*an) - an;
+  p = length(p)*vec2(cos(bn),SABS(sin(bn), 0.15));
+  p -= r*acs;
+  p += ecs*clamp( -dot(p,ecs), 0.0, r*acs.y/ecs.y);
+  return length(p)*sign(p.x);
+}
+
+vec4 alphaBlend(vec4 back, vec4 front) {
+  vec3 xyz = mix(back.xyz*back.w, front.xyz, front.w);
+  float w = mix(back.w, 1.0, front.w);
+  return vec4(xyz, w);
+}
+
+void rot(inout vec2 p, float a) {
+  float c = cos(a);
+  float s = sin(a);
+  p = vec2(c*p.x + s*p.y, -s*p.x + c*p.y);
+}
+
+vec3 offset(float z) {
+  float a = z;
+  vec2 p = -0.075*(vec2(cos(a), sin(a*sqrt(2.0))) + vec2(cos(a*sqrt(0.75)), sin(a*sqrt(0.5))));
+  return vec3(p, z);
+}
+
+vec3 doffset(float z) {
+  float eps = 0.05;
+  return 0.5*(offset(z + eps) - offset(z - eps))/eps;
+}
+
+vec3 ddoffset(float z) {
+  float eps = 0.05;
+  return 0.5*(doffset(z + eps) - doffset(z - eps))/eps;
+}
+
+vec4 planeCol(vec3 ro, vec3 rd, float n, vec3 pp) {
+  const float s = 0.5;
+
+  vec2 p = pp.xy;
+  float z = pp.z;
+  vec2 dpy = dFdy(p);
+  float aa = length(dpy);
+
+  p -= (1.0+5.0*(pp.z - ro.z))*offset(z).xy;
+
+  p *= s;
+  float r = hash(vec3(floor(p+0.5), n));
+  p = fract(p+0.5)-0.5;
+  rot(p, ((TAU*r+n)*0.25));
+  float d = starn(p, 0.20, 3 + 2*int(3.0*r), 3.0);
+  d -= 0.06;
+  d/=s;
+
+  float ds = -d+0.03;
+  vec3 cols = hsv2rgb(vec3(337.0/360.0+0.1*sin(n*0.3), 0.8, 0.54+0.2*sin(n*0.3)));
+  float ts = 1.0 - smoothstep(-aa, 0.0, ds);
+  vec4 cs =  vec4(cols, ts*0.93);
+
+  float db = abs(d) - (0.06);
+  db = abs(db) - 0.03;
+  db = abs(db) - 0.00;
+  db = max(db, -d+0.03);
+    vec3 colb = vec3(1.0, 0.7, 0.5);
+  float tb = exp(-(db)*30.0*(1.0 - 10.0*aa));
+  vec4 cb = vec4(1.5*colb, tb);
+
+  vec4 ct = alphaBlend(cs, cb);
+
+  return ct;
+}
+
+vec3 color(vec3 ww, vec3 uu, vec3 vv, vec3 ro, vec2 p) {
+  vec3 rd = normalize(p.x*uu + p.y*vv + (2.0-tanh(length(p)))*ww);
+
+  vec4 col = vec4(vec3(0.0), 1.0);
+
+  const float planeDist = 1.0;
+  const int furthest = 6;
+  const int fadeFrom = furthest-3;
+
+  float nz = floor(ro.z / planeDist);
+
+  for (int i = furthest; i >= 1; --i) {
+    float pz = planeDist*nz + planeDist*float(i);
+
+    float pd = (pz - ro.z)/rd.z;
+
+    if (pd > 0.0) {
+      vec3 pp = ro + rd*pd;
+
+      vec4 pcol = planeCol(ro, rd, nz+float(i), pp);
+      float fadeIn = 1.0-smoothstep(planeDist*float(fadeFrom), planeDist*float(furthest), pp.z-ro.z);
+      pcol.xyz *= sqrt(fadeIn);
+
+      col = alphaBlend(col, pcol);
+    }
+  }
+
+  return col.xyz*col.w;
+}
+
+vec3 postProcess(vec3 col, vec2 q)  {
+  col=pow(clamp(col,0.0,1.0),vec3(0.75));
+  col=col*0.6+0.4*col*col*(3.0-2.0*col);
+  col=mix(col, vec3(dot(col, vec3(0.33))), -0.4);
+  col*=0.5+0.5*pow(19.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.7);
+  return col;
+}
+
+vec3 effect(vec2 p, vec2 q) {
+  float tm = TIME*0.65;
+
+  vec3 ro   = offset(tm);
+  vec3 dro  = doffset(tm);
+  vec3 ddro = ddoffset(tm);
+
+  vec3 ww = normalize(dro);
+  vec3 uu = normalize(cross(vec3(0.0,1.0,0.0)+1.5*ddro, ww));
+  vec3 vv = normalize(cross(ww, uu));
+
+  vec3 col = color(ww, uu, vv, ro, p);
+  col = postProcess(col, q);
+
+  const float fadeIn = 2.0;
+
+  return col*smoothstep(0.0, fadeIn, TIME);
+}
+
+void mainImage(out vec4 fragColor, vec2 fragCoord) {
+  vec2 q = fragCoord/RESOLUTION.xy;
+  vec2 p = -1. + 2. * q;
+  p.x *= RESOLUTION.x/RESOLUTION.y;
+
+  vec3 col = effect(p, q);
+
+  fragColor = vec4(col, 1.0);
+}

demos/gtk-demo/gtkshadertoy.c

@@ -0,0 +1,524 @@
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <epoxy/gl.h>
+
+#include "gtkshadertoy.h"
+
+const char *default_image_shader =
+  "void mainImage(out vec4 fragColor, in vec2 fragCoord) {\n"
+  "    // Normalized pixel coordinates (from 0 to 1)\n"
+  "    vec2 uv = fragCoord/iResolution.xy;\n"
+  "\n"
+  "   // Time varying pixel color\n"
+  "    vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));\n"
+  "\n"
+  "    if (distance(iMouse.xy, fragCoord.xy) <= 10.0) {\n"
+  "        col = vec3(0.0);\n"
+  "    }\n"
+  "\n"
+  "    // Output to screen\n"
+  "    fragColor = vec4(col,1.0);\n"
+  "}\n";
+
+const char *shadertoy_vertex_shader =
+  "#version 150 core\n"
+  "\n"
+  "uniform vec3 iResolution;\n"
+  "\n"
+  "in vec2 position;\n"
+  "out vec2 fragCoord;\n"
+  "\n"
+  "void main() {\n"
+  "    gl_Position = vec4(position, 0.0, 1.0);\n"
+  "\n"
+  "    // Convert from OpenGL coordinate system (with origin in center\n"
+  "    // of screen) to Shadertoy/texture coordinate system (with origin\n"
+  "    // in lower left corner)\n"
+  "    fragCoord = (gl_Position.xy + vec2(1.0)) / vec2(2.0) * iResolution.xy;\n"
+  "}\n";
+
+const char *fragment_prefix =
+  "#version 150 core\n"
+  "\n"
+  "uniform vec3      iResolution;           // viewport resolution (in pixels)\n"
+  "uniform float     iTime;                 // shader playback time (in seconds)\n"
+  "uniform float     iTimeDelta;            // render time (in seconds)\n"
+  "uniform int       iFrame;                // shader playback frame\n"
+  "uniform float     iChannelTime[4];       // channel playback time (in seconds)\n"
+  "uniform vec3      iChannelResolution[4]; // channel resolution (in pixels)\n"
+  "uniform vec4      iMouse;                // mouse pixel coords. xy: current (if MLB down), zw: click\n"
+  "uniform sampler2D iChannel0;\n"
+  "uniform sampler2D iChannel1;\n"
+  "uniform sampler2D iChannel2;\n"
+  "uniform sampler2D iChannel3;\n"
+  "uniform vec4      iDate;                 // (year, month, day, time in seconds)\n"
+  "uniform float     iSampleRate;           // sound sample rate (i.e., 44100)\n"
+  "\n"
+  "in vec2 fragCoord;\n"
+  "out vec4 fragColor;\n";
+
+
+// Fragment shader suffix
+const char *fragment_suffix =
+  "    void main() {\n"
+  "        mainImage(fragColor, fragCoord);\n"
+  "    }\n";
+
+typedef struct {
+  char *image_shader;
+  gboolean image_shader_dirty;
+
+  gboolean error_set;
+
+  /* Vertex buffers */
+  GLuint vao;
+  GLuint buffer;
+
+  /* Active program */
+  GLuint program;
+
+  /* Location of uniforms for program */
+  GLuint resolution_location;
+  GLuint time_location;
+  GLuint timedelta_location;
+  GLuint frame_location;
+  GLuint mouse_location;
+
+  /* Current uniform values */
+  float resolution[3];
+  float time;
+  float timedelta;
+  float mouse[4];
+  int frame;
+
+  /* Animation data */
+  gint64 first_frame_time;
+  gint64 first_frame;
+  guint tick;
+} GtkShadertoyPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (GtkShadertoy, gtk_shadertoy, GTK_TYPE_GL_AREA)
+
+static gboolean gtk_shadertoy_render        (GtkGLArea     *area,
+                                             GdkGLContext  *context);
+static void     gtk_shadertoy_reshape       (GtkGLArea     *area,
+                                             int            width,
+                                             int            height);
+static void     gtk_shadertoy_realize       (GtkWidget     *widget);
+static void     gtk_shadertoy_unrealize     (GtkWidget     *widget);
+static gboolean gtk_shadertoy_tick          (GtkWidget     *widget,
+                                             GdkFrameClock *frame_clock,
+                                             gpointer       user_data);
+
+GtkWidget *
+gtk_shadertoy_new (void)
+{
+  return g_object_new (gtk_shadertoy_get_type (), NULL);
+}
+
+static void
+drag_begin_cb (GtkGestureDrag *drag,
+               double          x,
+               double          y,
+               gpointer        user_data)
+{
+  GtkShadertoy *shadertoy = GTK_SHADERTOY (user_data);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+  int height = gtk_widget_get_height (GTK_WIDGET (shadertoy));
+  int scale = gtk_widget_get_scale_factor (GTK_WIDGET (shadertoy));
+
+ priv->mouse[0] = x * scale;
+ priv->mouse[1] = (height - y) * scale;
+ priv->mouse[2] = priv->mouse[0];
+ priv->mouse[3] = priv->mouse[1];
+}
+
+static void
+drag_update_cb (GtkGestureDrag *drag,
+                double          dx,
+                double          dy,
+                gpointer        user_data)
+{
+  GtkShadertoy *shadertoy = GTK_SHADERTOY (user_data);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+  int width = gtk_widget_get_width (GTK_WIDGET (shadertoy));
+  int height = gtk_widget_get_height (GTK_WIDGET (shadertoy));
+  int scale = gtk_widget_get_scale_factor (GTK_WIDGET (shadertoy));
+  double x, y;
+
+  gtk_gesture_drag_get_start_point (drag, &x, &y);
+  x += dx;
+  y += dy;
+
+  if (x >= 0 && x < width &&
+      y >= 0 && y < height)
+    {
+      priv->mouse[0] = x * scale;
+      priv->mouse[1] = (height - y) * scale;
+    }
+}
+
+static void
+drag_end_cb (GtkGestureDrag *drag,
+             gdouble         dx,
+             gdouble         dy,
+             gpointer        user_data)
+{
+  GtkShadertoy *shadertoy = GTK_SHADERTOY (user_data);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+
+  priv->mouse[2] = -priv->mouse[2];
+  priv->mouse[3] = -priv->mouse[3];
+}
+
+static void
+gtk_shadertoy_init (GtkShadertoy *shadertoy)
+{
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+  GtkGesture *drag;
+
+  priv->image_shader = g_strdup (default_image_shader);
+  priv->tick = gtk_widget_add_tick_callback (GTK_WIDGET (shadertoy), gtk_shadertoy_tick, shadertoy, NULL);
+
+  drag = gtk_gesture_drag_new ();
+  gtk_widget_add_controller (GTK_WIDGET (shadertoy), GTK_EVENT_CONTROLLER (drag));
+  g_signal_connect (drag, "drag-begin", (GCallback)drag_begin_cb, shadertoy);
+  g_signal_connect (drag, "drag-update", (GCallback)drag_update_cb, shadertoy);
+  g_signal_connect (drag, "drag-end", (GCallback)drag_end_cb, shadertoy);
+}
+
+static void
+gtk_shadertoy_finalize (GObject *obj)
+{
+  GtkShadertoy *shadertoy = GTK_SHADERTOY (obj);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+
+  gtk_widget_remove_tick_callback (GTK_WIDGET (shadertoy), priv->tick);
+  g_free (priv->image_shader);
+
+  G_OBJECT_CLASS (gtk_shadertoy_parent_class)->finalize (obj);
+}
+
+static void
+gtk_shadertoy_class_init (GtkShadertoyClass *klass)
+{
+  GTK_GL_AREA_CLASS (klass)->render = gtk_shadertoy_render;
+  GTK_GL_AREA_CLASS (klass)->resize = gtk_shadertoy_reshape;
+
+  GTK_WIDGET_CLASS (klass)->realize = gtk_shadertoy_realize;
+  GTK_WIDGET_CLASS (klass)->unrealize = gtk_shadertoy_unrealize;
+
+  G_OBJECT_CLASS (klass)->finalize = gtk_shadertoy_finalize;
+}
+
+/* new window size or exposure */
+static void
+gtk_shadertoy_reshape (GtkGLArea *area, int width, int height)
+{
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private ((GtkShadertoy *) area);
+
+  priv->resolution[0] = width;
+  priv->resolution[1] = height;
+  priv->resolution[2] = 1.0; /* screen aspect ratio */
+
+  /* Set the viewport */
+  glViewport (0, 0, (GLint) width, (GLint) height);
+}
+
+static GLuint
+create_shader (int         type,
+               const char *src,
+               GError    **error)
+{
+  GLuint shader;
+  int status;
+
+  shader = glCreateShader (type);
+  glShaderSource (shader, 1, &src, NULL);
+  glCompileShader (shader);
+
+  glGetShaderiv (shader, GL_COMPILE_STATUS, &status);
+  if (status == GL_FALSE)
+    {
+      int log_len;
+      char *buffer;
+
+      glGetShaderiv (shader, GL_INFO_LOG_LENGTH, &log_len);
+
+      buffer = g_malloc (log_len + 1);
+      glGetShaderInfoLog (shader, log_len, NULL, buffer);
+
+      g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_COMPILATION_FAILED,
+                   "Compile failure in %s shader:\n%s",
+                   type == GL_VERTEX_SHADER ? "vertex" : "fragment",
+                   buffer);
+
+      g_free (buffer);
+
+      glDeleteShader (shader);
+
+      return 0;
+    }
+
+  return shader;
+}
+
+static gboolean
+init_shaders (GtkShadertoy *shadertoy,
+              const char *vertex_source,
+              const char *fragment_source,
+              GError **error)
+{
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+  GLuint vertex, fragment;
+  GLuint program = 0;
+  int status;
+  gboolean res = TRUE;
+
+  vertex = create_shader (GL_VERTEX_SHADER, vertex_source, error);
+  if (vertex == 0)
+    return FALSE;
+
+  fragment = create_shader (GL_FRAGMENT_SHADER, fragment_source, error);
+  if (fragment == 0)
+    {
+      glDeleteShader (vertex);
+      return FALSE;
+    }
+
+  program = glCreateProgram ();
+  glAttachShader (program, vertex);
+  glAttachShader (program, fragment);
+
+  glLinkProgram (program);
+
+  glGetProgramiv (program, GL_LINK_STATUS, &status);
+  if (status == GL_FALSE)
+    {
+      int log_len;
+      char *buffer;
+
+      glGetProgramiv (program, GL_INFO_LOG_LENGTH, &log_len);
+
+      buffer = g_malloc (log_len + 1);
+      glGetProgramInfoLog (program, log_len, NULL, buffer);
+
+      g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_LINK_FAILED,
+                   "Linking failure:\n%s", buffer);
+      res = FALSE;
+
+      g_free (buffer);
+
+      glDeleteProgram (program);
+
+      goto out;
+    }
+
+  if (priv->program != 0)
+    glDeleteProgram (priv->program);
+
+  priv->program = program;
+  priv->resolution_location = glGetUniformLocation (program, "iResolution");
+  priv->time_location = glGetUniformLocation (program, "iTime");
+  priv->timedelta_location = glGetUniformLocation (program, "iTimeDelta");
+  priv->frame_location = glGetUniformLocation (program, "iFrame");
+  priv->mouse_location = glGetUniformLocation (program, "iMouse");
+
+  glDetachShader (program, vertex);
+  glDetachShader (program, fragment);
+
+out:
+  /* These are now owned by the program and can be deleted */
+  glDeleteShader (vertex);
+  glDeleteShader (fragment);
+
+  return res;
+}
+
+static void
+gtk_shadertoy_realize_shader (GtkShadertoy *shadertoy)
+{
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+  char *fragment_shader;
+  GError *error = NULL;
+
+  fragment_shader = g_strconcat (fragment_prefix, priv->image_shader, fragment_suffix, NULL);
+  if (!init_shaders (shadertoy, shadertoy_vertex_shader, fragment_shader, &error))
+    {
+      priv->error_set = TRUE;
+      gtk_gl_area_set_error (GTK_GL_AREA (shadertoy), error);
+      g_error_free (error);
+    }
+  g_free (fragment_shader);
+
+  /* Start new shader at time zero */
+  priv->first_frame_time = 0;
+  priv->first_frame = 0;
+
+  priv->image_shader_dirty = FALSE;
+}
+
+static gboolean
+gtk_shadertoy_render (GtkGLArea    *area,
+                      GdkGLContext *context)
+{
+  GtkShadertoy *shadertoy = GTK_SHADERTOY (area);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+
+  if (gtk_gl_area_get_error (area) != NULL)
+    return FALSE;
+
+  if (priv->image_shader_dirty)
+    gtk_shadertoy_realize_shader (shadertoy);
+
+  /* Clear the viewport */
+  glClearColor (0.0, 0.0, 0.0, 1.0);
+  glClear (GL_COLOR_BUFFER_BIT);
+
+  glUseProgram (priv->program);
+
+  /* Update uniforms */
+  if (priv->resolution_location != -1)
+    glUniform3fv (priv->resolution_location, 1, priv->resolution);
+  if (priv->time_location != -1)
+    glUniform1f (priv->time_location, priv->time);
+  if (priv->timedelta_location != -1)
+    glUniform1f (priv->timedelta_location, priv->timedelta);
+  if (priv->frame_location != -1)
+    glUniform1i (priv->frame_location, priv->frame);
+  if (priv->mouse_location != -1)
+    glUniform4fv (priv->mouse_location, 1, priv->mouse);
+
+  /* Use the vertices in our buffer */
+  glBindBuffer (GL_ARRAY_BUFFER, priv->buffer);
+  glEnableVertexAttribArray (0);
+  glVertexAttribPointer (0, 4, GL_FLOAT, GL_FALSE, 0, 0);
+
+  glDrawArrays (GL_TRIANGLES, 0, 6);
+
+  /* We finished using the buffers and program */
+  glDisableVertexAttribArray (0);
+  glBindBuffer (GL_ARRAY_BUFFER, 0);
+  glUseProgram (0);
+
+  /* Flush the contents of the pipeline */
+  glFlush ();
+
+  return TRUE;
+}
+
+const char *
+gtk_shadertoy_get_image_shader (GtkShadertoy *shadertoy)
+{
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+
+  return priv->image_shader;
+}
+
+void
+gtk_shadertoy_set_image_shader (GtkShadertoy *shadertoy,
+                                const char   *shader)
+{
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+
+  g_free (priv->image_shader);
+  priv->image_shader = g_strdup (shader);
+
+  /* Don't override error we didn't set it ourselves */
+  if (priv->error_set)
+    {
+      gtk_gl_area_set_error (GTK_GL_AREA (shadertoy), NULL);
+      priv->error_set = FALSE;
+    }
+  priv->image_shader_dirty = TRUE;
+}
+
+static void
+gtk_shadertoy_realize (GtkWidget *widget)
+{
+  GtkGLArea *glarea = GTK_GL_AREA (widget);
+  GtkShadertoy *shadertoy = GTK_SHADERTOY (widget);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+
+  /* Draw two triangles across whole screen */
+  const GLfloat vertex_data[] = {
+    -1.0f, -1.0f, 0.f, 1.f,
+    -1.0f,  1.0f, 0.f, 1.f,
+    1.0f,  1.0f, 0.f, 1.f,
+
+    -1.0f, -1.0f, 0.f, 1.f,
+    1.0f,  1.0f, 0.f, 1.f,
+    1.0f, -1.0f, 0.f, 1.f,
+  };
+
+  GTK_WIDGET_CLASS (gtk_shadertoy_parent_class)->realize (widget);
+
+  gtk_gl_area_make_current (glarea);
+  if (gtk_gl_area_get_error (glarea) != NULL)
+    return;
+
+  glGenVertexArrays (1, &priv->vao);
+  glBindVertexArray (priv->vao);
+
+  glGenBuffers (1, &priv->buffer);
+  glBindBuffer (GL_ARRAY_BUFFER, priv->buffer);
+  glBufferData (GL_ARRAY_BUFFER, sizeof (vertex_data), vertex_data, GL_STATIC_DRAW);
+  glBindBuffer (GL_ARRAY_BUFFER, 0);
+
+  gtk_shadertoy_realize_shader (shadertoy);
+}
+
+static void
+gtk_shadertoy_unrealize (GtkWidget *widget)
+{
+  GtkGLArea *glarea = GTK_GL_AREA (widget);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private ((GtkShadertoy *) widget);
+
+  gtk_gl_area_make_current (glarea);
+  if (gtk_gl_area_get_error (glarea) == NULL)
+    {
+      if (priv->buffer != 0)
+        glDeleteBuffers (1, &priv->buffer);
+
+      if (priv->vao != 0)
+        glDeleteVertexArrays (1, &priv->vao);
+
+      if (priv->program != 0)
+        glDeleteProgram (priv->program);
+    }
+
+  GTK_WIDGET_CLASS (gtk_shadertoy_parent_class)->unrealize (widget);
+}
+
+static gboolean
+gtk_shadertoy_tick (GtkWidget     *widget,
+                    GdkFrameClock *frame_clock,
+                    gpointer       user_data)
+{
+  GtkShadertoy *shadertoy = GTK_SHADERTOY (widget);
+  GtkShadertoyPrivate *priv = gtk_shadertoy_get_instance_private (shadertoy);
+  gint64 frame_time;
+  gint64 frame;
+  float previous_time;
+
+  frame = gdk_frame_clock_get_frame_counter (frame_clock);
+  frame_time = gdk_frame_clock_get_frame_time (frame_clock);
+
+  if (priv->first_frame_time == 0)
+    {
+      priv->first_frame_time = frame_time;
+      priv->first_frame = frame;
+      previous_time = 0;
+    }
+  else
+    previous_time = priv->time;
+
+  priv->time = (frame_time - priv->first_frame_time) / 1000000.0f;
+  priv->frame = frame - priv->first_frame;
+  priv->timedelta = priv->time - previous_time;
+
+  gtk_widget_queue_draw (widget);
+
+  return G_SOURCE_CONTINUE;
+}

demos/gtk-demo/gtkshadertoy.h

@@ -0,0 +1,34 @@
+#ifndef __GTK_SHADERTOY_H__
+#define __GTK_SHADERTOY_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_SHADERTOY      (gtk_shadertoy_get_type ())
+#define GTK_SHADERTOY(inst)     (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
+                                 GTK_TYPE_SHADERTOY,                 \
+                                 GtkShadertoy))
+#define GTK_IS_SHADERTOY(inst)  (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
+                                 GTK_TYPE_SHADERTOY))
+
+typedef struct _GtkShadertoy GtkShadertoy;
+typedef struct _GtkShadertoyClass GtkShadertoyClass;
+
+struct _GtkShadertoy {
+  GtkGLArea parent;
+};
+
+struct _GtkShadertoyClass {
+  GtkGLAreaClass parent_class;
+};
+
+GType       gtk_shadertoy_get_type         (void) G_GNUC_CONST;
+GtkWidget  *gtk_shadertoy_new              (void);
+const char *gtk_shadertoy_get_image_shader (GtkShadertoy *shadertoy);
+void        gtk_shadertoy_set_image_shader (GtkShadertoy *shadertoy,
+                                            const char   *shader);
+
+G_END_DECLS
+
+#endif /* __GTK_SHADERTOY_H__ */

demos/gtk-demo/listview_settings.c

@@ -417,7 +417,7 @@ do_listview_settings (GtkWidget *do_widget)
       g_object_unref (selection);
 
       name_column = GTK_COLUMN_VIEW_COLUMN (gtk_builder_get_object (builder, "name_column"));
-      sorter = gtk_string_sorter_new (gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name"));
+      sorter = GTK_SORTER (gtk_string_sorter_new (gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name")));
       gtk_column_view_column_set_sorter (name_column, sorter);
       g_object_unref (sorter);
 

demos/gtk-demo/mandelbrot.glsl

@@ -0,0 +1,95 @@
+// Originally from: https://www.shadertoy.com/view/wdBfDK
+// License: CC0
+
+#define MANDELBROT_ZOOM_START 0.0
+#define MANDELBROT_ITER       240
+
+void pR(inout vec2 p, in float a) {
+  p = cos(a)*p + sin(a)*vec2(p.y, -p.x);
+}
+
+vec2 pMod2(inout vec2 p, in vec2 size) {
+  vec2 c = floor((p + size*0.5)/size);
+  p = mod(p + size*0.5,size) - size*0.5;
+  return c;
+}
+
+
+vec3 mandelbrot(float time, vec2 p, out float ii) {
+  vec3 col = vec3(0.0);
+
+  float ztime = (time - MANDELBROT_ZOOM_START)*step(MANDELBROT_ZOOM_START, time);
+
+  float zoo = 0.64 + 0.36*cos(.07*ztime);
+  float coa = cos(0.15*(1.0-zoo)*ztime);
+  float sia = sin(0.15*(1.0-zoo)*ztime);
+  zoo = pow(zoo,8.0);
+  vec2 xy = vec2( p.x*coa-p.y*sia, p.x*sia+p.y*coa);
+  vec2 c = vec2(-.745,.186) + xy*zoo;
+
+  const float B = 10.0;
+  float l = 0.0;
+  vec2 z  = vec2(0.0);
+
+  vec2 zc = vec2(1.0);
+
+  pR(zc, ztime);
+
+  float d = 1e20;
+
+  int i = 0;
+
+  for(int j = 0; j < MANDELBROT_ITER; ++j) {
+    float re2 = z.x*z.x;
+    float im2 = z.y*z.y;
+    float reim= z.x*z.y;
+
+    if(re2 + im2 > (B*B)) break;
+
+    z = vec2(re2 - im2, 2.0*reim) + c;
+
+    vec2 zm = z;
+    vec2 n = pMod2(zm, vec2(4));
+    vec2 pp = zm - zc;
+    float dd = dot(pp, pp);
+
+    d = min(d, dd);
+
+    l += 1.0;
+
+    i = j;
+  }
+
+  ii = float(i)/float(MANDELBROT_ITER);
+
+  float sl = l - log2(log2(dot(z,z))) + 4.0;
+
+  vec3 dc = vec3(pow(max(1.0 - d, 0.0), 20.0));
+  vec3 gc = 0.5 + 0.5*cos(3.0 + sl*0.15 + vec3(0.1,0.5,0.9));
+  return gc + dc*smoothstep(28.8, 29.0, ztime);
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+  float s = 2.0/iResolution.y;
+
+  vec2 o1 = vec2(1.0/8.0, 3.0/8.0)*s;
+  vec2 o2 = vec2(-3.0/8.0, 1.0/8.0)*s;
+
+  vec2 p = (-iResolution.xy + 2.0*fragCoord.xy)/iResolution.y;
+  float ii = 0.0;
+  vec3 col = mandelbrot(iTime, p+o1, ii);
+
+  // "smart" AA? Is that a good idea?
+  vec2 dii2 = vec2(dFdx(ii), dFdy(ii));
+  float dii = length(dii2);
+
+  if(abs(dii) > 0.01) {
+    col += mandelbrot(iTime, p-o1, ii);
+    col += mandelbrot(iTime, p+o2, ii);
+    col += mandelbrot(iTime, p-o2, ii);
+    col *=0.25;
+//    col = vec3(1.0, 0.0, 0.0);
+  }
+
+  fragColor = vec4(col, 1.0);
+}

demos/gtk-demo/meson.build

@@ -59,6 +59,7 @@ demos = files([
   'paint.c',
   'paintable.c',
   'paintable_animated.c',
+  'paintable_emblem.c',
   'paintable_mediastream.c',
   'panes.c',
   'password_entry.c',
@@ -70,6 +71,7 @@ demos = files([
   'scale.c',
   'search_entry.c',
   'search_entry2.c',
+  'shadertoy.c',
   'shortcuts.c',
   'shortcut_triggers.c',
   'sidebar.c',
@@ -98,6 +100,7 @@ extra_demo_sources = files(['main.c',
                             'gtkfishbowl.c',
                             'fontplane.c',
                             'gtkgears.c',
+                            'gtkshadertoy.c',
                             'puzzlepiece.c',
                             'bluroverlay.c',
                             'demoimage.c',

demos/gtk-demo/neon.glsl

@@ -0,0 +1,220 @@
+// Originally from: https://www.shadertoy.com/view/WlByzy
+// License CC0: Neonwave style road, sun and city
+//  The result of a bit of experimenting with neonwave style colors.
+
+#define PI          3.141592654
+#define TAU         (2.0*PI)
+
+#define TIME        iTime
+#define RESOLUTION  iResolution
+
+vec3 hsv2rgb(vec3 c) {
+  const vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+float hash(in float co) {
+  return fract(sin(co*12.9898) * 13758.5453);
+}
+
+float hash(in vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,58.233))) * 13758.5453);
+}
+
+float psin(float a) {
+  return 0.5 + 0.5*sin(a);
+}
+
+float mod1(inout float p, float size) {
+  float halfsize = size*0.5;
+  float c = floor((p + halfsize)/size);
+  p = mod(p + halfsize, size) - halfsize;
+  return c;
+}
+
+float circle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float box(vec2 p, vec2 b) {
+  vec2 d = abs(p)-b;
+  return length(max(d,0.0)) + min(max(d.x,d.y),0.0);
+}
+
+float planex(vec2 p, float w) {
+  return abs(p.y) - w;
+}
+
+float planey(vec2 p, float w) {
+  return abs(p.x) - w;
+}
+
+float pmin(float a, float b, float k) {
+  float h = clamp( 0.5+0.5*(b-a)/k, 0.0, 1.0 );
+  return mix( b, a, h ) - k*h*(1.0-h);
+}
+
+float pmax(float a, float b, float k) {
+  return -pmin(-a, -b, k);
+}
+
+float sun(vec2 p) {
+  const float ch = 0.0125;
+  vec2 sp = p;
+  vec2 cp = p;
+  mod1(cp.y, ch*6.0);
+
+  float d0 = circle(sp, 0.5);
+  float d1 = planex(cp, ch);
+  float d2 = p.y+ch*3.0;
+
+  float d = d0;
+  d = pmax(d, -max(d1, d2), ch*2.0);
+
+  return d;
+}
+
+float city(vec2 p) {
+  float sd = circle(p, 0.5);
+  float cd = 1E6;
+
+  const float count = 5.0;
+  const float width = 0.1;
+
+  for (float i = 0.0; i < count; ++i) {
+    vec2 pp = p;
+    pp.x += i*width/count;
+    float nn = mod1(pp.x, width);
+    float rr = hash(nn+sqrt(3.0)*i);
+    float dd = box(pp-vec2(0.0, -0.5), vec2(0.02, 0.35*(1.0-smoothstep(0.0, 5.0, abs(nn)))*rr+0.1));
+    cd = min(cd, dd);
+  }
+
+  return max(sd,cd);
+}
+vec3 sunEffect(vec2 p) {
+  float aa = 4.0 / RESOLUTION.y;
+
+  vec3 col = vec3(0.1);
+  vec3 skyCol1 = hsv2rgb(vec3(283.0/360.0, 0.83, 0.16));
+  vec3 skyCol2 = hsv2rgb(vec3(297.0/360.0, 0.79, 0.43));
+  col = mix(skyCol1, skyCol2, pow(clamp(0.5*(1.0+p.y+0.1*sin(4.0*p.x+TIME*0.5)), 0.0, 1.0), 4.0));
+
+  p.y -= 0.375;
+  float ds = sun(p);
+  float dc = city(p);
+
+  float dd = circle(p, 0.5);
+
+  vec3 sunCol = mix(vec3(1.0, 1.0, 0.0), vec3(1.0, 0.0, 1.0), clamp(0.5 - 1.0*p.y, 0.0, 1.0));
+  vec3 glareCol = sqrt(sunCol);
+  vec3 cityCol = sunCol*sunCol;
+
+  col += glareCol*(exp(-30.0*ds))*step(0.0, ds);
+
+
+  float t1 = smoothstep(0.0, 0.075, -dd);
+  float t2 = smoothstep(0.0, 0.3, -dd);
+  col = mix(col, sunCol, smoothstep(-aa, 0.0, -ds));
+  col = mix(col, glareCol, smoothstep(-aa, 0.0, -dc)*t1);
+  col += vec3(0.0, 0.25, 0.0)*(exp(-90.0*dc))*step(0.0, dc)*t2;
+
+//  col += 0.3*psin(d*400);
+
+  return col;
+}
+
+float ground(vec2 p) {
+  p.y += TIME*80.0;
+  p *= 0.075;
+  vec2 gp = p;
+  gp = fract(gp) - vec2(0.5);
+  float d0 = abs(gp.x);
+  float d1 = abs(gp.y);
+  float d2 = circle(gp, 0.05);
+
+  const float rw = 2.5;
+  const float sw = 0.0125;
+
+  vec2 rp = p;
+  mod1(rp.y, 12.0);
+  float d3 = abs(rp.x) - rw;
+  float d4 = abs(d3) - sw*2.0;
+  float d5 = box(rp, vec2(sw*2.0, 2.0));
+  vec2 sp = p;
+  mod1(sp.y, 4.0);
+  sp.x = abs(sp.x);
+  sp -= vec2(rw - 0.125, 0.0);
+  float d6 = box(sp, vec2(sw, 1.0));
+
+  float d = d0;
+  d = pmin(d, d1, 0.1);
+  d = max(d, -d3);
+  d = min(d, d4);
+  d = min(d, d5);
+  d = min(d, d6);
+
+  return d;
+}
+
+vec3 groundEffect(vec2 p) {
+  vec3 ro = vec3(0.0, 20.0, 0.0);
+  vec3 ww = normalize(vec3(0.0, -0.025, 1.0));
+  vec3 uu = normalize(cross(vec3(0.0,1.0,0.0), ww));
+  vec3 vv = normalize(cross(ww,uu));
+  vec3 rd = normalize(p.x*uu + p.y*vv + 2.5*ww);
+
+  float distg = (-9.0 - ro.y)/rd.y;
+
+  const vec3 shineCol = 0.75*vec3(0.5, 0.75, 1.0);
+  const vec3 gridCol = vec3(1.0);
+
+  vec3 col = vec3(0.0);
+  if (distg > 0.0) {
+    vec3 pg = ro + rd*distg;
+    float aa = length(dFdx(pg))*0.0002*RESOLUTION.x;
+
+    float dg = ground(pg.xz);
+
+    col = mix(col, gridCol, smoothstep(-aa, 0.0, -(dg+0.0175)));
+    col += shineCol*(exp(-10.0*clamp(dg, 0.0, 1.0)));
+    col = clamp(col, 0.0, 1.0);
+
+//    col += 0.3*psin(dg*100);
+    col *= pow(1.0-smoothstep(ro.y*3.0, 220.0+ro.y*2.0, distg), 2.0);
+  }
+
+  return col;
+}
+
+vec3 postProcess(vec3 col, vec2 q)  {
+  col = clamp(col,0.0,1.0);
+//  col=pow(col,vec3(0.75));
+  col=col*0.6+0.4*col*col*(3.0-2.0*col);
+  col=mix(col, vec3(dot(col, vec3(0.33))), -0.4);
+  col*=0.5+0.5*pow(19.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.7);
+  return col;
+}
+
+vec3 effect(vec2 p, vec2 q) {
+  vec3 col = vec3(0.0);
+
+  vec2 off = vec2(0.0, 0.0);
+
+  col += sunEffect(p+off);
+  col += groundEffect(p+off);
+
+  col = postProcess(col, q);
+  return col;
+}
+
+void mainImage(out vec4 fragColor, vec2 fragCoord) {
+  vec2 q = fragCoord/iResolution.xy;
+  vec2 p = -1. + 2. * q;
+  p.x *= RESOLUTION.x / RESOLUTION.y;
+
+  vec3 col = effect(p, q);
+
+  fragColor = vec4(col, 1.0);
+}

demos/gtk-demo/paintable.c

@@ -48,15 +48,17 @@ void
 gtk_nuclear_snapshot (GtkSnapshot *snapshot,
                       double       width,
                       double       height,
-                      double       rotation)
+                      double       rotation,
+                      gboolean     draw_background)
 {
 #define RADIUS 0.3
   cairo_t *cr;
   double size;
 
-  gtk_snapshot_append_color (snapshot,
-                             &(GdkRGBA) { 0.9, 0.75, 0.15, 1.0 },
-                             &GRAPHENE_RECT_INIT (0, 0, width, height));
+  if (draw_background)
+    gtk_snapshot_append_color (snapshot,
+                               &(GdkRGBA) { 0.9, 0.75, 0.15, 1.0 },
+                               &GRAPHENE_RECT_INIT (0, 0, width, height));
 
   size = MIN (width, height);
   cr = gtk_snapshot_append_cairo (snapshot,
@@ -93,7 +95,8 @@ gtk_nuclear_icon_snapshot (GdkPaintable *paintable,
 
   gtk_nuclear_snapshot (snapshot,
                         width, height,
-                        nuclear->rotation);
+                        nuclear->rotation,
+                        TRUE);
 }
 
 static GdkPaintableFlags
@@ -161,6 +164,7 @@ do_paintable (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Nuclear Icon");
       gtk_window_set_default_size (GTK_WINDOW (window), 300, 200);
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
       nuclear = gtk_nuclear_icon_new (0.0);
       image = gtk_image_new_from_paintable (nuclear);

demos/gtk-demo/paintable.h

@@ -6,10 +6,11 @@
 void            gtk_nuclear_snapshot           (GtkSnapshot     *snapshot,
                                                 double           width,
                                                 double           height,
-                                                double           rotation);
+                                                double           rotation,
+                                                gboolean         draw_background);
 
 GdkPaintable *  gtk_nuclear_icon_new            (double          rotation);
-GdkPaintable *  gtk_nuclear_animation_new       (void);
+GdkPaintable *  gtk_nuclear_animation_new       (gboolean        draw_background);
 GtkMediaStream *gtk_nuclear_media_stream_new    (void);
 
 #endif /* __PAINTABLE_H__ */

demos/gtk-demo/paintable_animated.c

@@ -33,6 +33,8 @@ struct _GtkNuclearAnimation
 {
   GObject parent_instance;
 
+  gboolean draw_background;
+
   /* This variable stores the progress of our animation.
    * We just count upwards until we hit MAX_PROGRESS and
    * then start from scratch.
@@ -64,7 +66,8 @@ gtk_nuclear_animation_snapshot (GdkPaintable *paintable,
   /* We call the function from the previous example here. */
   gtk_nuclear_snapshot (snapshot,
                         width, height,
-                        2 * G_PI * nuclear->progress / MAX_PROGRESS);
+                        2 * G_PI * nuclear->progress / MAX_PROGRESS,
+                        nuclear->draw_background);
 }
 
 static GdkPaintable *
@@ -175,9 +178,15 @@ gtk_nuclear_animation_init (GtkNuclearAnimation *nuclear)
 
 /* And finally, we add the simple constructor we declared in the header. */
 GdkPaintable *
-gtk_nuclear_animation_new (void)
+gtk_nuclear_animation_new (gboolean draw_background)
 {
-  return g_object_new (GTK_TYPE_NUCLEAR_ANIMATION, NULL);
+  GtkNuclearAnimation *nuclear;
+
+  nuclear = g_object_new (GTK_TYPE_NUCLEAR_ANIMATION, NULL);
+
+  nuclear->draw_background = draw_background;
+
+  return GDK_PAINTABLE (nuclear);
 }
 
 GtkWidget *
@@ -193,8 +202,9 @@ do_paintable_animated (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Nuclear Animation");
       gtk_window_set_default_size (GTK_WINDOW (window), 300, 200);
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
-      nuclear = gtk_nuclear_animation_new ();
+      nuclear = gtk_nuclear_animation_new (TRUE);
       image = gtk_image_new_from_paintable (nuclear);
       gtk_window_set_child (GTK_WINDOW (window), image);
       g_object_unref (nuclear);

demos/gtk-demo/paintable_emblem.c

@@ -0,0 +1,186 @@
+/* Paintable/Emblems
+ *
+ * This demo shows how GdkPaintable can be used to
+ * overlay an emblem on top of an icon. The emblem
+ * can either be another icon, or an arbitrary
+ * paintable.
+ */
+
+#include <gtk/gtk.h>
+
+#include "paintable.h"
+
+static GtkWidget *window = NULL;
+
+#define DEMO_TYPE_ICON (demo_icon_get_type ())
+G_DECLARE_FINAL_TYPE (DemoIcon, demo_icon, DEMO, ICON, GObject)
+
+struct _DemoIcon
+{
+  GObject parent_instance;
+
+  GdkPaintable *icon;
+  GdkPaintable *emblem;
+  GdkPaintableFlags flags;
+};
+
+struct _DemoIconClass
+{
+  GObjectClass parent_class;
+};
+
+void
+demo_icon_snapshot (GdkPaintable *paintable,
+                    GtkSnapshot  *snapshot,
+                    double        width,
+                    double        height)
+{
+  DemoIcon *self = DEMO_ICON (paintable);
+
+  gdk_paintable_snapshot (self->icon, snapshot, width, height);
+  gtk_snapshot_save (snapshot);
+  gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (0.5 * width, 0));
+  gdk_paintable_snapshot (self->emblem, snapshot, 0.5 * width, 0.5 * height);
+  gtk_snapshot_restore (snapshot);
+}
+
+static GdkPaintableFlags
+demo_icon_get_flags (GdkPaintable *paintable)
+{
+  DemoIcon *self = DEMO_ICON (paintable);
+
+  return self->flags;
+}
+
+static void
+demo_icon_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->snapshot = demo_icon_snapshot;
+  iface->get_flags = demo_icon_get_flags;
+}
+
+G_DEFINE_TYPE_WITH_CODE (DemoIcon, demo_icon, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                                demo_icon_paintable_init))
+
+static void
+demo_icon_dispose (GObject *object)
+{
+  DemoIcon *self = DEMO_ICON (object);
+
+  g_signal_handlers_disconnect_by_func (self->emblem,
+                                        gdk_paintable_invalidate_contents,
+                                        self);
+
+  g_clear_object (&self->icon);
+  g_clear_object (&self->emblem);
+
+  G_OBJECT_CLASS (demo_icon_parent_class)->dispose (object);
+}
+
+static void
+demo_icon_class_init (DemoIconClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = demo_icon_dispose;
+}
+
+static void
+demo_icon_init (DemoIcon *self)
+{
+  self->flags = GDK_PAINTABLE_STATIC_SIZE | GDK_PAINTABLE_STATIC_CONTENTS;
+}
+
+GdkPaintable *
+demo_icon_new_with_paintable (const char   *icon_name,
+                              GdkPaintable *emblem)
+{
+  GtkIconTheme *theme;
+  GtkIconPaintable *icon;
+  DemoIcon *self;
+
+  theme = gtk_icon_theme_get_for_display (gdk_display_get_default ());
+
+  icon = gtk_icon_theme_lookup_icon (theme,
+                                     icon_name, NULL,
+                                     128, 1,
+                                     GTK_TEXT_DIR_LTR, 0);
+
+  self = g_object_new (DEMO_TYPE_ICON, NULL);
+
+  self->icon = GDK_PAINTABLE (icon);
+  self->emblem = emblem;
+
+  if ((gdk_paintable_get_flags (emblem) & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
+    {
+      self->flags &= ~GDK_PAINTABLE_STATIC_CONTENTS;
+
+      g_signal_connect_swapped (emblem, "invalidate-contents",
+                                G_CALLBACK (gdk_paintable_invalidate_contents), self);
+    }
+
+  return GDK_PAINTABLE (self);
+}
+
+GdkPaintable *
+demo_icon_new (const char *icon_name,
+               const char *emblem_name)
+{
+  GtkIconTheme *theme;
+  GtkIconPaintable *emblem;
+
+  theme = gtk_icon_theme_get_for_display (gdk_display_get_default ());
+
+  emblem = gtk_icon_theme_lookup_icon (theme,
+                                       emblem_name, NULL,
+                                       128, 1,
+                                       GTK_TEXT_DIR_LTR, 0);
+
+  return GDK_PAINTABLE (demo_icon_new_with_paintable (icon_name,
+                                                      GDK_PAINTABLE (emblem)));
+}
+
+GtkWidget *
+do_paintable_emblem (GtkWidget *do_widget)
+{
+  GdkPaintable *icon;
+  GtkWidget *grid;
+  GtkWidget *image;
+
+  if (!window)
+    {
+      window = gtk_window_new ();
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Emblems");
+      gtk_window_set_default_size (GTK_WINDOW (window), 300, 200);
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      grid = gtk_grid_new ();
+
+      icon = demo_icon_new ("folder", "starred");
+      image = gtk_image_new_from_paintable (icon);
+      gtk_widget_set_hexpand (image, TRUE);
+      gtk_widget_set_vexpand (image, TRUE);
+      gtk_grid_attach (GTK_GRID (grid), image, 0, 0, 1, 1);
+
+      icon = demo_icon_new_with_paintable ("drive-multidisk",
+                                           gtk_nuclear_animation_new (FALSE));
+      image = gtk_image_new_from_paintable (icon);
+      gtk_widget_set_hexpand (image, TRUE);
+      gtk_widget_set_vexpand (image, TRUE);
+      gtk_grid_attach (GTK_GRID (grid), image, 1, 0, 1, 1);
+
+      gtk_window_set_child (GTK_WINDOW (window), grid);
+      g_object_unref (icon);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}
+

demos/gtk-demo/paintable_mediastream.c

@@ -74,7 +74,8 @@ gtk_nuclear_media_stream_snapshot (GdkPaintable *paintable,
   /* We call the function from the previous example here. */
   gtk_nuclear_snapshot (snapshot,
                         width, height,
-                        2 * G_PI * nuclear->progress / DURATION);
+                        2 * G_PI * nuclear->progress / DURATION,
+                        TRUE);
 }
 
 static GdkPaintable *

demos/gtk-demo/shadertoy.c

@@ -0,0 +1,201 @@
+/* OpenGL/Shadertoy
+ *
+ * Generate pixels using a custom fragment shader.
+ *
+ * The names of the uniforms are compatible with the shaders on shadertoy.com, so
+ * many of the shaders there work here too.
+ */
+#include <math.h>
+#include <gtk/gtk.h>
+#include <epoxy/gl.h>
+#include "gtkshadertoy.h"
+
+static GtkWidget *demo_window = NULL;
+static GtkWidget *shadertoy = NULL;
+static GtkTextBuffer *textbuffer = NULL;
+
+static void
+run (void)
+{
+  GtkTextIter start, end;
+  char *text;
+
+  gtk_text_buffer_get_bounds (textbuffer, &start, &end);
+  text = gtk_text_buffer_get_text (textbuffer, &start, &end, FALSE);
+
+  gtk_shadertoy_set_image_shader (GTK_SHADERTOY (shadertoy), text);
+  g_free (text);
+}
+
+static void
+run_clicked_cb (GtkWidget *button,
+                gpointer   user_data)
+{
+  run ();
+}
+
+static void
+load_clicked_cb (GtkWidget *button,
+                 gpointer   user_data)
+{
+  const char *path = user_data;
+  GBytes *initial_shader;
+
+  initial_shader = g_resources_lookup_data (path, 0, NULL);
+  gtk_text_buffer_set_text (textbuffer, g_bytes_get_data (initial_shader, NULL), -1);
+  g_bytes_unref (initial_shader);
+
+  run ();
+}
+
+static void
+clear_clicked_cb (GtkWidget *button,
+                  gpointer   user_data)
+{
+  gtk_text_buffer_set_text (textbuffer, "", 0);
+}
+
+static void
+close_window (GtkWidget *widget)
+{
+  /* Reset the state */
+  demo_window = NULL;
+  shadertoy = NULL;
+  textbuffer = NULL;
+}
+
+static GtkWidget *
+new_shadertoy (const char *path)
+{
+  GBytes *shader;
+  GtkWidget *toy;
+
+  toy = gtk_shadertoy_new ();
+  shader = g_resources_lookup_data (path, 0, NULL);
+  gtk_shadertoy_set_image_shader (GTK_SHADERTOY (toy),
+                                  g_bytes_get_data (shader, NULL));
+  g_bytes_unref (shader);
+
+  return toy;
+}
+
+static GtkWidget *
+new_button (const char *path)
+{
+  GtkWidget *button, *toy;
+
+  button = gtk_button_new ();
+  g_signal_connect (button, "clicked", G_CALLBACK (load_clicked_cb), (char *)path);
+
+  toy = new_shadertoy (path);
+  gtk_widget_set_size_request (toy, 64, 36);
+  gtk_button_set_child (GTK_BUTTON (button),  toy);
+
+  return button;
+}
+
+static GtkWidget *
+create_shadertoy_window (GtkWidget *do_widget)
+{
+  GtkWidget *window, *box, *hbox, *button, *textview, *sw, *aspect, *centerbox;
+
+  window = gtk_window_new ();
+  gtk_window_set_display (GTK_WINDOW (window),  gtk_widget_get_display (do_widget));
+  gtk_window_set_title (GTK_WINDOW (window), "Shadertoy");
+  gtk_window_set_default_size (GTK_WINDOW (window), 690, 740);
+  g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);
+
+  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
+  gtk_widget_set_margin_start (box, 12);
+  gtk_widget_set_margin_end (box, 12);
+  gtk_widget_set_margin_top (box, 12);
+  gtk_widget_set_margin_bottom (box, 12);
+  gtk_box_set_spacing (GTK_BOX (box), 6);
+  gtk_window_set_child (GTK_WINDOW (window), box);
+
+  aspect = gtk_aspect_frame_new (0.5, 0.5, 1.77777, FALSE);
+  gtk_widget_set_hexpand (aspect, TRUE);
+  gtk_widget_set_vexpand (aspect, TRUE);
+  gtk_box_append (GTK_BOX (box), aspect);
+
+  shadertoy = new_shadertoy ("/shadertoy/alienplanet.glsl");
+  gtk_aspect_frame_set_child (GTK_ASPECT_FRAME (aspect), shadertoy);
+
+  sw = gtk_scrolled_window_new ();
+  gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 250);
+  gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+  gtk_widget_set_hexpand (sw, TRUE);
+  gtk_box_append (GTK_BOX (box), sw);
+
+  textview = gtk_text_view_new ();
+  gtk_text_view_set_monospace (GTK_TEXT_VIEW (textview), TRUE);
+  g_object_set (textview,
+                "left-margin", 20,
+                "right-margin", 20,
+                "top-margin", 20,
+                "bottom-margin", 20,
+                NULL);
+  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), textview);
+
+  textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
+  gtk_text_buffer_set_text (textbuffer,
+                            gtk_shadertoy_get_image_shader (GTK_SHADERTOY (shadertoy)),
+                            -1);
+
+  centerbox = gtk_center_box_new ();
+  gtk_box_append (GTK_BOX (box), centerbox);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
+  gtk_box_set_spacing (GTK_BOX (hbox), 6);
+  gtk_center_box_set_start_widget (GTK_CENTER_BOX (centerbox), hbox);
+
+  button = gtk_button_new_from_icon_name ("view-refresh-symbolic");
+  gtk_widget_set_tooltip_text (button, "Restart the demo");
+  gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+  g_signal_connect (button, "clicked", G_CALLBACK (run_clicked_cb), NULL);
+  gtk_box_append (GTK_BOX (hbox), button);
+
+  button = gtk_button_new_from_icon_name ("edit-clear-all-symbolic");
+  gtk_widget_set_tooltip_text (button, "Clear the text view");
+  gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+  g_signal_connect (button, "clicked", G_CALLBACK (clear_clicked_cb), NULL);
+  gtk_box_append (GTK_BOX (hbox), button);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
+  gtk_box_set_spacing (GTK_BOX (hbox), 6);
+  gtk_center_box_set_end_widget (GTK_CENTER_BOX (centerbox), hbox);
+
+  button = new_button ("/shadertoy/alienplanet.glsl");
+  gtk_box_append (GTK_BOX (hbox), button);
+
+  button = new_button ("/shadertoy/mandelbrot.glsl");
+  gtk_box_append (GTK_BOX (hbox), button);
+
+  button = new_button ("/shadertoy/neon.glsl");
+  gtk_box_append (GTK_BOX (hbox), button);
+
+  button = new_button ("/shadertoy/cogs.glsl");
+  gtk_box_append (GTK_BOX (hbox), button);
+
+  button = new_button ("/shadertoy/glowingstars.glsl");
+  gtk_box_append (GTK_BOX (hbox), button);
+
+  return window;
+}
+
+GtkWidget *
+do_shadertoy (GtkWidget *do_widget)
+{
+  if (!demo_window)
+    demo_window = create_shadertoy_window (do_widget);
+
+  if (!gtk_widget_get_visible (demo_window))
+    gtk_widget_show (demo_window);
+  else
+    gtk_window_destroy (GTK_WINDOW (demo_window));
+
+  return demo_window;
+}

demos/gtk-demo/singular_value_decomposition.c

@@ -11,6 +11,20 @@
 
 #define MAX_ITERATION_COUNT 30
 
+/* Perform Householder reduction to bidiagonal form
+ *
+ * Input: Matrix A of size nrows x ncols
+ *
+ * Output: Matrices and vectors such that
+ * A = U*Bidiag(diagonal, superdiagonal)*Vt
+ *
+ * All matrices are allocated by the caller
+ *
+ * Sizes:
+ *  A, U: nrows x ncols
+ *  diagonal, superdiagonal: ncols
+ *  V: ncols x ncols
+ */
 static void
 householder_reduction (double *A,
                        int     nrows,
@@ -160,6 +174,20 @@ householder_reduction (double *A,
     }
 }
 
+/* Perform Givens reduction
+ *
+ * Input: Matrices such that
+ * A = U*Bidiag(diagonal,superdiagonal)*Vt
+ *
+ * Output: The same, with superdiagonal = 0
+ *
+ * All matrices are allocated by the caller
+ *
+ * Sizes:
+ *  U: nrows x ncols
+ *  diagonal, superdiagonal: ncols
+ *  V: ncols x ncols
+ */
 static int
 givens_reduction (int nrows,
                   int ncols,
@@ -298,6 +326,11 @@ givens_reduction (int nrows,
   return 0;
 }
 
+/* Given a singular value decomposition
+ * of an nrows x ncols matrix A = U*Diag(S)*Vt,
+ * sort the values of S by decreasing value,
+ * permuting V to match.
+ */
 static void
 sort_singular_values (int     nrows,
                       int     ncols,
@@ -339,6 +372,16 @@ sort_singular_values (int     nrows,
     }
 }
 
+/* Compute a singular value decomposition of A,
+ * A = U*Diag(S)*Vt
+ *
+ * All matrices are allocated by the caller
+ *
+ * Sizes:
+ *  A, U: nrows x ncols
+ *  S: ncols
+ *  V: ncols x ncols
+ */
 int
 singular_value_decomposition (double *A,
                               int     nrows,
@@ -364,6 +407,18 @@ singular_value_decomposition (double *A,
   return 0;
 }
 
+/*
+ * Given a singular value decomposition of A = U*Diag(S)*Vt,
+ * compute the best approximation x to A*x = B.
+ *
+ * All matrices are allocated by the caller
+ *
+ * Sizes:
+ *  U: nrows x ncols
+ *  S: ncols
+ *  V: ncols x ncols
+ *  B, x: ncols
+ */
 void
 singular_value_decomposition_solve (double *U,
                                     double *S,

demos/gtk-demo/sliding_puzzle.c

@@ -437,7 +437,7 @@ do_sliding_puzzle (GtkWidget *do_widget)
       choices = gtk_flow_box_new ();
       gtk_widget_add_css_class (choices, "view");
       add_choice (choices, puzzle);
-      add_choice (choices, gtk_nuclear_animation_new ());
+      add_choice (choices, gtk_nuclear_animation_new (TRUE));
       media = gtk_media_file_new_for_resource ("/images/gtk-logo.webm");
       gtk_media_stream_set_loop (media, TRUE);
       gtk_media_stream_set_muted (media, TRUE);

demos/gtk-demo/textview.c

@@ -142,7 +142,7 @@ insert_text (GtkTextView *view)
                                      32, 1,
                                      gtk_widget_get_direction (widget),
                                      0);
-  nuclear = gtk_nuclear_animation_new ();
+  nuclear = gtk_nuclear_animation_new (TRUE);
 
   /* get start of buffer; each insertion will revalidate the
    * iterator to point to just after the inserted text.

docs/reference/gdk/gdk4-sections.txt

@@ -171,8 +171,6 @@ gdk_rgba_get_type
 <FILE>gdksurface</FILE>
 GdkSurface
 GdkGravity
-GdkSurfaceEdge
-GdkSurfaceState
 gdk_surface_new_toplevel
 gdk_surface_new_popup
 gdk_surface_destroy
@@ -224,7 +222,7 @@ GDK_TYPE_SURFACE_TYPE
 GDK_TYPE_SURFACE_TYPE_HINT
 GDK_TYPE_WM_DECORATION
 GDK_TYPE_WM_FUNCTION
-GDK_TYPE_SURFACE_STATE
+GDK_TYPE_TOPLEVEL_STATE
 
 <SUBSECTION Private>
 gdk_surface_get_type
@@ -655,7 +653,9 @@ gdk_toplevel_size_get_type
 <FILE>gdktoplevel</FILE>
 <TITLE>GdkToplevel</TITLE>
 GdkToplevel
+GdkToplevelState
 GdkFullscreenMode
+GdkSurfaceEdge
 gdk_toplevel_present
 gdk_toplevel_minimize
 gdk_toplevel_lower

docs/reference/gtk/migrating-3to4.md

@@ -49,6 +49,15 @@ application, e.g.:
 G_ENABLE_DIAGNOSTIC=1 ./your-app
 ```
 
+### Do not use GTK-specific command line arguments
+
+GTK4 does not parse command line arguments any more. If you are using
+command line arguments like `--gtk-debug` you should use the `GTK_DEBUG`
+environment variable instead. If you are using `--g-fatal-warnings` for
+debugging purposes, you should use the `G_DEBUG` environment variable, as
+specified by the
+[GLib documentation](https://developer.gnome.org/glib/stable/glib-running.html).
+
 ### Do not use widget style properties
 
 Style properties do not exist in GTK 4. You should stop using them in
@@ -274,8 +283,8 @@ gdk_toplevel_begin_resize().
 
 ### The "iconified" window state has been renamed to "minimized"
 
-The %GDK_SURFACE_STATE_ICONIFIED value of the
-#GdkSurfaceState enumeration is now %GDK_SURFACE_STATE_MINIMIZED.
+The %GDK_TOPLEVEL_STATE_ICONIFIED value of the #GdkSurfaceState enumeration
+is now %GDK_TOPLEVEL_STATE_MINIMIZED in the #GdkToplevelState enumeration.
 
 The #GdkWindow functions <function>gdk_window_iconify()</function>
 and <function>gdk_window_deiconify()</function> have been renamed to

gdk/broadway/gdksurface-broadway.c

@@ -596,7 +596,7 @@ gdk_broadway_surface_layout_popup (GdkSurface     *surface,
 static void
 show_popup (GdkSurface *surface)
 {
-  gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+  gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
   gdk_broadway_surface_show (surface, FALSE);
   gdk_surface_invalidate_rect (surface, NULL);
 }
@@ -797,7 +797,7 @@ gdk_broadway_surface_maximize (GdkSurface *surface)
 
   impl->maximized = TRUE;
 
-  gdk_synthesize_surface_state (surface, 0, GDK_SURFACE_STATE_MAXIMIZED);
+  gdk_synthesize_surface_state (surface, 0, GDK_TOPLEVEL_STATE_MAXIMIZED);
 
   impl->pre_maximize_x = surface->x;
   impl->pre_maximize_y = surface->y;
@@ -827,7 +827,7 @@ gdk_broadway_surface_unmaximize (GdkSurface *surface)
 
   impl->maximized = FALSE;
 
-  gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_MAXIMIZED, 0);
+  gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_MAXIMIZED, 0);
 
   gdk_broadway_surface_move_resize (surface,
                                     impl->pre_maximize_x,
@@ -1513,7 +1513,7 @@ show_surface (GdkSurface *surface)
   was_mapped = GDK_SURFACE_IS_MAPPED (surface);
 
   if (!was_mapped)
-    gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+    gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
 
   gdk_broadway_surface_show (surface, FALSE);
 

gdk/gdkcontentserializer.c

@@ -681,7 +681,7 @@ string_serializer (GdkContentSerializer *serializer)
 
   g_output_stream_write_all_async (filter,
                                    text,
-                                   strlen (text) + 1,
+                                   strlen (text),
                                    gdk_content_serializer_get_priority (serializer),
                                    gdk_content_serializer_get_cancellable (serializer),
                                    string_serializer_finish,

gdk/gdksurface.c

@@ -462,7 +462,7 @@ gdk_surface_init (GdkSurface *surface)
 {
   /* 0-initialization is good for all other fields. */
 
-  surface->state = GDK_SURFACE_STATE_WITHDRAWN;
+  surface->state = GDK_TOPLEVEL_STATE_WITHDRAWN;
   surface->fullscreen_mode = GDK_FULLSCREEN_ON_CURRENT_MONITOR;
   surface->width = 1;
   surface->height = 1;
@@ -730,7 +730,7 @@ gdk_surface_set_property (GObject      *object,
     }
 }
 
-#define GDK_SURFACE_IS_STICKY(surface) (((surface)->state & GDK_SURFACE_STATE_STICKY))
+#define GDK_SURFACE_IS_STICKY(surface) (((surface)->state & GDK_TOPLEVEL_STATE_STICKY))
 
 static void
 gdk_surface_get_property (GObject    *object,
@@ -813,7 +813,7 @@ gdk_surface_new_toplevel (GdkDisplay *display)
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
   return gdk_surface_new (display, GDK_SURFACE_TOPLEVEL,
-                          NULL, 0, 0, 0, 0);
+                          NULL, 0, 0, 1, 1);
 }
 
 /**
@@ -935,7 +935,7 @@ _gdk_surface_destroy_hierarchy (GdkSurface *surface,
 
   _gdk_surface_clear_update_area (surface);
 
-  surface->state |= GDK_SURFACE_STATE_WITHDRAWN;
+  surface->state |= GDK_TOPLEVEL_STATE_WITHDRAWN;
   surface->destroyed = TRUE;
 
   surface_remove_from_pointer_info (surface, surface->display);
@@ -1686,7 +1686,7 @@ gdk_surface_hide (GdkSurface *surface)
   was_mapped = GDK_SURFACE_IS_MAPPED (surface);
 
   if (GDK_SURFACE_IS_MAPPED (surface))
-    gdk_synthesize_surface_state (surface, 0, GDK_SURFACE_STATE_WITHDRAWN);
+    gdk_synthesize_surface_state (surface, 0, GDK_TOPLEVEL_STATE_WITHDRAWN);
 
   if (was_mapped)
     {
@@ -2632,7 +2632,7 @@ gdk_surface_set_shadow_width (GdkSurface *surface,
 
 void
 gdk_surface_set_state (GdkSurface      *surface,
-                       GdkSurfaceState  new_state)
+                       GdkToplevelState new_state)
 {
   gboolean was_mapped, mapped;
   gboolean was_sticky, sticky;
@@ -2665,9 +2665,9 @@ gdk_surface_set_state (GdkSurface      *surface,
 }
 
 void
-gdk_synthesize_surface_state (GdkSurface     *surface,
-                              GdkSurfaceState unset_flags,
-                              GdkSurfaceState set_flags)
+gdk_synthesize_surface_state (GdkSurface       *surface,
+                              GdkToplevelState  unset_flags,
+                              GdkToplevelState  set_flags)
 {
   gdk_surface_set_state (surface, (surface->state | set_flags) & ~unset_flags);
 }

gdk/gdksurface.h

@@ -38,94 +38,6 @@
 
 G_BEGIN_DECLS
 
-/**
- * GdkSurfaceEdge:
- * @GDK_SURFACE_EDGE_NORTH_WEST: the top left corner.
- * @GDK_SURFACE_EDGE_NORTH: the top edge.
- * @GDK_SURFACE_EDGE_NORTH_EAST: the top right corner.
- * @GDK_SURFACE_EDGE_WEST: the left edge.
- * @GDK_SURFACE_EDGE_EAST: the right edge.
- * @GDK_SURFACE_EDGE_SOUTH_WEST: the lower left corner.
- * @GDK_SURFACE_EDGE_SOUTH: the lower edge.
- * @GDK_SURFACE_EDGE_SOUTH_EAST: the lower right corner.
- *
- * Determines a surface edge or corner.
- */
-typedef enum
-{
-  GDK_SURFACE_EDGE_NORTH_WEST,
-  GDK_SURFACE_EDGE_NORTH,
-  GDK_SURFACE_EDGE_NORTH_EAST,
-  GDK_SURFACE_EDGE_WEST,
-  GDK_SURFACE_EDGE_EAST,
-  GDK_SURFACE_EDGE_SOUTH_WEST,
-  GDK_SURFACE_EDGE_SOUTH,
-  GDK_SURFACE_EDGE_SOUTH_EAST
-} GdkSurfaceEdge;
-
-/**
- * GdkFullscreenMode:
- * @GDK_FULLSCREEN_ON_CURRENT_MONITOR: Fullscreen on current monitor only.
- * @GDK_FULLSCREEN_ON_ALL_MONITORS: Span across all monitors when fullscreen.
- *
- * Indicates which monitor (in a multi-head setup) a surface should span over
- * when in fullscreen mode.
- **/
-typedef enum
-{
-  GDK_FULLSCREEN_ON_CURRENT_MONITOR,
-  GDK_FULLSCREEN_ON_ALL_MONITORS
-} GdkFullscreenMode;
-
-/**
- * GdkSurfaceState:
- * @GDK_SURFACE_STATE_WITHDRAWN: the surface is not shown
- * @GDK_SURFACE_STATE_MINIMIZED: the surface is minimized
- * @GDK_SURFACE_STATE_MAXIMIZED: the surface is maximized
- * @GDK_SURFACE_STATE_STICKY: the surface is sticky
- * @GDK_SURFACE_STATE_FULLSCREEN: the surface is maximized without decorations
- * @GDK_SURFACE_STATE_ABOVE: the surface is kept above other surfaces
- * @GDK_SURFACE_STATE_BELOW: the surface is kept below other surfaces
- * @GDK_SURFACE_STATE_FOCUSED: the surface is presented as focused (with active decorations)
- * @GDK_SURFACE_STATE_TILED: the surface is in a tiled state
- * @GDK_SURFACE_STATE_TOP_TILED: whether the top edge is tiled
- * @GDK_SURFACE_STATE_TOP_RESIZABLE: whether the top edge is resizable
- * @GDK_SURFACE_STATE_RIGHT_TILED: whether the right edge is tiled
- * @GDK_SURFACE_STATE_RIGHT_RESIZABLE: whether the right edge is resizable
- * @GDK_SURFACE_STATE_BOTTOM_TILED: whether the bottom edge is tiled
- * @GDK_SURFACE_STATE_BOTTOM_RESIZABLE: whether the bottom edge is resizable
- * @GDK_SURFACE_STATE_LEFT_TILED: whether the left edge is tiled
- * @GDK_SURFACE_STATE_LEFT_RESIZABLE: whether the left edge is resizable
- *
- * Specifies the state of a toplevel surface.
- *
- * On platforms that support information about individual edges, the %GDK_SURFACE_STATE_TILED
- * state will be set whenever any of the individual tiled states is set. On platforms
- * that lack that support, the tiled state will give an indication of tiledness without
- * any of the per-edge states being set.
- */
-typedef enum
-{
-  GDK_SURFACE_STATE_WITHDRAWN        = 1 << 0,
-  GDK_SURFACE_STATE_MINIMIZED        = 1 << 1,
-  GDK_SURFACE_STATE_MAXIMIZED        = 1 << 2,
-  GDK_SURFACE_STATE_STICKY           = 1 << 3,
-  GDK_SURFACE_STATE_FULLSCREEN       = 1 << 4,
-  GDK_SURFACE_STATE_ABOVE            = 1 << 5,
-  GDK_SURFACE_STATE_BELOW            = 1 << 6,
-  GDK_SURFACE_STATE_FOCUSED          = 1 << 7,
-  GDK_SURFACE_STATE_TILED            = 1 << 8,
-  GDK_SURFACE_STATE_TOP_TILED        = 1 << 9,
-  GDK_SURFACE_STATE_TOP_RESIZABLE    = 1 << 10,
-  GDK_SURFACE_STATE_RIGHT_TILED      = 1 << 11,
-  GDK_SURFACE_STATE_RIGHT_RESIZABLE  = 1 << 12,
-  GDK_SURFACE_STATE_BOTTOM_TILED     = 1 << 13,
-  GDK_SURFACE_STATE_BOTTOM_RESIZABLE = 1 << 14,
-  GDK_SURFACE_STATE_LEFT_TILED       = 1 << 15,
-  GDK_SURFACE_STATE_LEFT_RESIZABLE   = 1 << 16
-} GdkSurfaceState;
-
-
 typedef struct _GdkSurfaceClass GdkSurfaceClass;
 
 #define GDK_TYPE_SURFACE              (gdk_surface_get_type ())

gdk/gdksurfaceprivate.h

@@ -23,6 +23,7 @@
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include "gdkenumtypes.h"
 #include "gdksurface.h"
+#include "gdktoplevel.h"
 
 G_BEGIN_DECLS
 
@@ -58,8 +59,8 @@ struct _GdkSurface
      more than we have to, but it represents the "true" damage. */
   cairo_region_t *active_update_area;
 
-  GdkSurfaceState old_state;
-  GdkSurfaceState state;
+  GdkToplevelState old_state;
+  GdkToplevelState state;
 
   guint8 resize_count;
 
@@ -172,11 +173,11 @@ struct _GdkSurfaceClass
 
 #define GDK_SURFACE_DESTROYED(d) (((GdkSurface *)(d))->destroyed)
 
-#define GDK_SURFACE_IS_MAPPED(surface) (((surface)->state & GDK_SURFACE_STATE_WITHDRAWN) == 0)
+#define GDK_SURFACE_IS_MAPPED(surface) (((surface)->state & GDK_TOPLEVEL_STATE_WITHDRAWN) == 0)
 
 
 void gdk_surface_set_state (GdkSurface      *surface,
-                            GdkSurfaceState  new_state);
+                            GdkToplevelState  new_state);
 
 GdkMonitor * gdk_surface_get_layout_monitor (GdkSurface      *surface,
                                              GdkPopupLayout  *layout,
@@ -282,8 +283,8 @@ GdkSurface *   gdk_surface_new_temp             (GdkDisplay    *display,
 void gdk_surface_destroy_notify       (GdkSurface *surface);
 
 void gdk_synthesize_surface_state (GdkSurface     *surface,
-                                   GdkSurfaceState unset_flags,
-                                   GdkSurfaceState set_flags);
+                                   GdkToplevelState unset_flags,
+                                   GdkToplevelState set_flags);
 
 void gdk_surface_get_root_coords (GdkSurface *surface,
                                   int         x,

gdk/gdktoplevel.c

@@ -118,7 +118,7 @@ gdk_toplevel_default_init (GdkToplevelInterface *iface)
       g_param_spec_flags ("state",
                           P_("State"),
                           P_("State"),
-                          GDK_TYPE_SURFACE_STATE, GDK_SURFACE_STATE_WITHDRAWN,
+                          GDK_TYPE_TOPLEVEL_STATE, GDK_TOPLEVEL_STATE_WITHDRAWN,
                           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
   g_object_interface_install_property (iface,
       g_param_spec_string ("title",
@@ -307,14 +307,14 @@ gdk_toplevel_focus (GdkToplevel *toplevel,
  * @toplevel: a #GdkToplevel
  *
  * Gets the bitwise OR of the currently active surface state flags,
- * from the #GdkSurfaceState enumeration.
+ * from the #GdkToplevelState enumeration.
  *
  * Returns: surface state bitfield
  */
-GdkSurfaceState
+GdkToplevelState
 gdk_toplevel_get_state (GdkToplevel *toplevel)
 {
-  GdkSurfaceState state;
+  GdkToplevelState state;
 
   g_return_val_if_fail (GDK_IS_TOPLEVEL (toplevel), 0);
 

gdk/gdktoplevel.h

@@ -30,6 +30,94 @@
 
 G_BEGIN_DECLS
 
+/**
+ * GdkSurfaceEdge:
+ * @GDK_SURFACE_EDGE_NORTH_WEST: the top left corner.
+ * @GDK_SURFACE_EDGE_NORTH: the top edge.
+ * @GDK_SURFACE_EDGE_NORTH_EAST: the top right corner.
+ * @GDK_SURFACE_EDGE_WEST: the left edge.
+ * @GDK_SURFACE_EDGE_EAST: the right edge.
+ * @GDK_SURFACE_EDGE_SOUTH_WEST: the lower left corner.
+ * @GDK_SURFACE_EDGE_SOUTH: the lower edge.
+ * @GDK_SURFACE_EDGE_SOUTH_EAST: the lower right corner.
+ *
+ * Determines a surface edge or corner.
+ */
+typedef enum
+{
+  GDK_SURFACE_EDGE_NORTH_WEST,
+  GDK_SURFACE_EDGE_NORTH,
+  GDK_SURFACE_EDGE_NORTH_EAST,
+  GDK_SURFACE_EDGE_WEST,
+  GDK_SURFACE_EDGE_EAST,
+  GDK_SURFACE_EDGE_SOUTH_WEST,
+  GDK_SURFACE_EDGE_SOUTH,
+  GDK_SURFACE_EDGE_SOUTH_EAST
+} GdkSurfaceEdge;
+
+/**
+ * GdkFullscreenMode:
+ * @GDK_FULLSCREEN_ON_CURRENT_MONITOR: Fullscreen on current monitor only.
+ * @GDK_FULLSCREEN_ON_ALL_MONITORS: Span across all monitors when fullscreen.
+ *
+ * Indicates which monitor (in a multi-head setup) a surface should span over
+ * when in fullscreen mode.
+ **/
+typedef enum
+{
+  GDK_FULLSCREEN_ON_CURRENT_MONITOR,
+  GDK_FULLSCREEN_ON_ALL_MONITORS
+} GdkFullscreenMode;
+
+/**
+ * GdkToplevelState:
+ * @GDK_TOPLEVEL_STATE_WITHDRAWN: the surface is not shown
+ * @GDK_TOPLEVEL_STATE_MINIMIZED: the surface is minimized
+ * @GDK_TOPLEVEL_STATE_MAXIMIZED: the surface is maximized
+ * @GDK_TOPLEVEL_STATE_STICKY: the surface is sticky
+ * @GDK_TOPLEVEL_STATE_FULLSCREEN: the surface is maximized without decorations
+ * @GDK_TOPLEVEL_STATE_ABOVE: the surface is kept above other surfaces
+ * @GDK_TOPLEVEL_STATE_BELOW: the surface is kept below other surfaces
+ * @GDK_TOPLEVEL_STATE_FOCUSED: the surface is presented as focused (with active decorations)
+ * @GDK_TOPLEVEL_STATE_TILED: the surface is in a tiled state
+ * @GDK_TOPLEVEL_STATE_TOP_TILED: whether the top edge is tiled
+ * @GDK_TOPLEVEL_STATE_TOP_RESIZABLE: whether the top edge is resizable
+ * @GDK_TOPLEVEL_STATE_RIGHT_TILED: whether the right edge is tiled
+ * @GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE: whether the right edge is resizable
+ * @GDK_TOPLEVEL_STATE_BOTTOM_TILED: whether the bottom edge is tiled
+ * @GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE: whether the bottom edge is resizable
+ * @GDK_TOPLEVEL_STATE_LEFT_TILED: whether the left edge is tiled
+ * @GDK_TOPLEVEL_STATE_LEFT_RESIZABLE: whether the left edge is resizable
+ *
+ * Specifies the state of a toplevel surface.
+ *
+ * On platforms that support information about individual edges, the %GDK_TOPLEVEL_STATE_TILED
+ * state will be set whenever any of the individual tiled states is set. On platforms
+ * that lack that support, the tiled state will give an indication of tiledness without
+ * any of the per-edge states being set.
+ */
+typedef enum
+{
+  GDK_TOPLEVEL_STATE_WITHDRAWN        = 1 << 0,
+  GDK_TOPLEVEL_STATE_MINIMIZED        = 1 << 1,
+  GDK_TOPLEVEL_STATE_MAXIMIZED        = 1 << 2,
+  GDK_TOPLEVEL_STATE_STICKY           = 1 << 3,
+  GDK_TOPLEVEL_STATE_FULLSCREEN       = 1 << 4,
+  GDK_TOPLEVEL_STATE_ABOVE            = 1 << 5,
+  GDK_TOPLEVEL_STATE_BELOW            = 1 << 6,
+  GDK_TOPLEVEL_STATE_FOCUSED          = 1 << 7,
+  GDK_TOPLEVEL_STATE_TILED            = 1 << 8,
+  GDK_TOPLEVEL_STATE_TOP_TILED        = 1 << 9,
+  GDK_TOPLEVEL_STATE_TOP_RESIZABLE    = 1 << 10,
+  GDK_TOPLEVEL_STATE_RIGHT_TILED      = 1 << 11,
+  GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE  = 1 << 12,
+  GDK_TOPLEVEL_STATE_BOTTOM_TILED     = 1 << 13,
+  GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE = 1 << 14,
+  GDK_TOPLEVEL_STATE_LEFT_TILED       = 1 << 15,
+  GDK_TOPLEVEL_STATE_LEFT_RESIZABLE   = 1 << 16
+} GdkToplevelState;
+
+
 #define GDK_TYPE_TOPLEVEL (gdk_toplevel_get_type ())
 
 GDK_AVAILABLE_IN_ALL
@@ -50,7 +138,7 @@ void            gdk_toplevel_focus              (GdkToplevel       *toplevel,
                                                  guint32            timestamp);
 
 GDK_AVAILABLE_IN_ALL
-GdkSurfaceState gdk_toplevel_get_state          (GdkToplevel       *toplevel);
+GdkToplevelState gdk_toplevel_get_state          (GdkToplevel       *toplevel);
 
 GDK_AVAILABLE_IN_ALL
 void            gdk_toplevel_set_title          (GdkToplevel       *toplevel,

gdk/gdkvulkancontext.c

@@ -324,13 +324,13 @@ gdk_vulkan_context_check_swapchain (GdkVulkanContext  *context,
 
   /*
    * Per https://www.khronos.org/registry/vulkan/specs/1.0-wsi_extensions/xhtml/vkspec.html#VkSurfaceCapabilitiesKHR
-   * the current extent may assume a special value, meaning that the extend should assume whatever
+   * the current extent may assume a special value, meaning that the extent should assume whatever
    * value the surface has.
    */
   if (capabilities.currentExtent.width == -1 || capabilities.currentExtent.height == -1)
     {
-      capabilities.currentExtent.width = gdk_surface_get_width (surface) * gdk_surface_get_scale_factor (surface);
-      capabilities.currentExtent.height = gdk_surface_get_height (surface) * gdk_surface_get_scale_factor (surface);
+      capabilities.currentExtent.width = MAX (1, gdk_surface_get_width (surface) * gdk_surface_get_scale_factor (surface));
+      capabilities.currentExtent.height = MAX (1, gdk_surface_get_height (surface) * gdk_surface_get_scale_factor (surface));
     }
 
   res = GDK_VK_CHECK (vkCreateSwapchainKHR, device,

gdk/macos/GdkMacosWindow.c

@@ -62,7 +62,7 @@
 
 -(void)windowDidMiniaturize:(NSNotification *)aNotification
 {
-  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_SURFACE_STATE_MINIMIZED);
+  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_TOPLEVEL_STATE_MINIMIZED);
 }
 
 -(void)windowDidDeminiaturize:(NSNotification *)aNotification
@@ -72,18 +72,18 @@
   else if (GDK_IS_MACOS_POPUP_SURFACE (gdk_surface))
     _gdk_macos_popup_surface_attach_to_parent (GDK_MACOS_POPUP_SURFACE (gdk_surface));
 
-  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), GDK_SURFACE_STATE_MINIMIZED, 0);
+  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), GDK_TOPLEVEL_STATE_MINIMIZED, 0);
 }
 
 -(void)windowDidBecomeKey:(NSNotification *)aNotification
 {
-  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_SURFACE_STATE_FOCUSED);
+  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_TOPLEVEL_STATE_FOCUSED);
   _gdk_macos_display_surface_became_key ([self gdkDisplay], gdk_surface);
 }
 
 -(void)windowDidResignKey:(NSNotification *)aNotification
 {
-  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), GDK_SURFACE_STATE_FOCUSED, 0);
+  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), GDK_TOPLEVEL_STATE_FOCUSED, 0);
   _gdk_macos_display_surface_resigned_key ([self gdkDisplay], gdk_surface);
 }
 
@@ -193,7 +193,7 @@
 {
   NSWindowStyleMask style_mask = [self styleMask];
 
-  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), GDK_SURFACE_STATE_MAXIMIZED, 0);
+  gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), GDK_TOPLEVEL_STATE_MAXIMIZED, 0);
 
   /* If we are using CSD, then we transitioned to an opaque
    * window while we were maximized. Now we need to drop that
@@ -206,7 +206,7 @@
 -(void)windowDidMove:(NSNotification *)aNotification
 {
   GdkSurface *surface = GDK_SURFACE (gdk_surface);
-  gboolean maximized = (surface->state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
+  gboolean maximized = (surface->state & GDK_TOPLEVEL_STATE_MAXIMIZED) != 0;
 
   /* In case the window is changed when maximized remove the maximized state */
   if (maximized && !inMaximizeTransition && !NSEqualRects (lastMaximizedFrame, [self frame]))
@@ -231,7 +231,7 @@
   display = gdk_surface_get_display (surface);
 
   content_rect = [self contentRectForFrameRect:[self frame]];
-  maximized = (surface->state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
+  maximized = (surface->state & GDK_TOPLEVEL_STATE_MAXIMIZED) != 0;
 
   /* see same in windowDidMove */
   if (maximized && !inMaximizeTransition && !NSEqualRects (lastMaximizedFrame, [self frame]))
@@ -627,7 +627,7 @@
 {
   NSRect screenFrame = [[self screen] visibleFrame];
   GdkMacosSurface *surface = gdk_surface;
-  gboolean maximized = GDK_SURFACE (surface)->state & GDK_SURFACE_STATE_MAXIMIZED;
+  gboolean maximized = GDK_SURFACE (surface)->state & GDK_TOPLEVEL_STATE_MAXIMIZED;
 
   if (!maximized)
     return screenFrame;
@@ -639,9 +639,9 @@
                 toFrame:(NSRect)newFrame
 {
   GdkMacosSurface *surface = gdk_surface;
-  GdkSurfaceState state = GDK_SURFACE (surface)->state;
+  GdkToplevelState state = GDK_SURFACE (surface)->state;
 
-  if (state & GDK_SURFACE_STATE_MAXIMIZED)
+  if (state & GDK_TOPLEVEL_STATE_MAXIMIZED)
     {
       lastMaximizedFrame = newFrame;
       [self windowDidUnmaximize];
@@ -649,7 +649,7 @@
   else
     {
       lastUnmaximizedFrame = [nsWindow frame];
-      gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_SURFACE_STATE_MAXIMIZED);
+      gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_TOPLEVEL_STATE_MAXIMIZED);
     }
 
   inMaximizeTransition = YES;
@@ -659,7 +659,7 @@
 
 -(void)windowDidEndLiveResize:(NSNotification *)aNotification
 {
-  gboolean maximized = GDK_SURFACE (gdk_surface)->state & GDK_SURFACE_STATE_MAXIMIZED;
+  gboolean maximized = GDK_SURFACE (gdk_surface)->state & GDK_TOPLEVEL_STATE_MAXIMIZED;
 
   inMaximizeTransition = NO;
 

gdk/macos/gdkmacossurface.c

@@ -650,7 +650,7 @@ _gdk_macos_surface_resize (GdkMacosSurface *self,
 void
 _gdk_macos_surface_update_fullscreen_state (GdkMacosSurface *self)
 {
-  GdkSurfaceState state;
+  GdkToplevelState state;
   gboolean is_fullscreen;
   gboolean was_fullscreen;
 
@@ -658,14 +658,14 @@ _gdk_macos_surface_update_fullscreen_state (GdkMacosSurface *self)
 
   state = GDK_SURFACE (self)->state;
   is_fullscreen = window_is_fullscreen (self);
-  was_fullscreen = (state & GDK_SURFACE_STATE_FULLSCREEN) != 0;
+  was_fullscreen = (state & GDK_TOPLEVEL_STATE_FULLSCREEN) != 0;
 
   if (is_fullscreen != was_fullscreen)
     {
       if (is_fullscreen)
-        gdk_synthesize_surface_state (GDK_SURFACE (self), 0, GDK_SURFACE_STATE_FULLSCREEN);
+        gdk_synthesize_surface_state (GDK_SURFACE (self), 0, GDK_TOPLEVEL_STATE_FULLSCREEN);
       else
-        gdk_synthesize_surface_state (GDK_SURFACE (self), GDK_SURFACE_STATE_FULLSCREEN, 0);
+        gdk_synthesize_surface_state (GDK_SURFACE (self), GDK_TOPLEVEL_STATE_FULLSCREEN, 0);
     }
 }
 
@@ -740,7 +740,7 @@ _gdk_macos_surface_show (GdkMacosSurface *self)
   was_mapped = GDK_SURFACE_IS_MAPPED (GDK_SURFACE (self));
 
   if (!was_mapped)
-    gdk_synthesize_surface_state (GDK_SURFACE (self), GDK_SURFACE_STATE_WITHDRAWN, 0);
+    gdk_synthesize_surface_state (GDK_SURFACE (self), GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
 
   _gdk_macos_display_clear_sorting (GDK_MACOS_DISPLAY (GDK_SURFACE (self)->display));
 

gdk/wayland/gdksurface-wayland.c

@@ -171,7 +171,7 @@ struct _GdkWaylandSurface
     struct {
       int width;
       int height;
-      GdkSurfaceState state;
+      GdkToplevelState state;
     } toplevel;
 
     struct {
@@ -353,7 +353,7 @@ _gdk_wayland_surface_save_size (GdkSurface *surface)
 {
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
 
-  if (surface->state & (GDK_SURFACE_STATE_FULLSCREEN | GDK_SURFACE_STATE_MAXIMIZED))
+  if (surface->state & (GDK_TOPLEVEL_STATE_FULLSCREEN | GDK_TOPLEVEL_STATE_MAXIMIZED))
     return;
 
   impl->saved_width = surface->width - impl->margin_left - impl->margin_right;
@@ -365,7 +365,7 @@ _gdk_wayland_surface_clear_saved_size (GdkSurface *surface)
 {
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
 
-  if (surface->state & (GDK_SURFACE_STATE_FULLSCREEN | GDK_SURFACE_STATE_MAXIMIZED))
+  if (surface->state & (GDK_TOPLEVEL_STATE_FULLSCREEN | GDK_TOPLEVEL_STATE_MAXIMIZED))
     return;
 
   impl->saved_width = -1;
@@ -1330,7 +1330,7 @@ gdk_wayland_surface_configure_toplevel (GdkSurface *surface)
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
   GdkWaylandDisplay *display_wayland =
     GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
-  GdkSurfaceState new_state;
+  GdkToplevelState new_state;
   int width, height;
   gboolean fixed_size;
   gboolean saved_size;
@@ -1339,9 +1339,9 @@ gdk_wayland_surface_configure_toplevel (GdkSurface *surface)
   impl->pending.toplevel.state = 0;
 
   fixed_size =
-    new_state & (GDK_SURFACE_STATE_MAXIMIZED |
-                 GDK_SURFACE_STATE_FULLSCREEN |
-                 GDK_SURFACE_STATE_TILED);
+    new_state & (GDK_TOPLEVEL_STATE_MAXIMIZED |
+                 GDK_TOPLEVEL_STATE_FULLSCREEN |
+                 GDK_TOPLEVEL_STATE_TILED);
 
   width = impl->pending.toplevel.width;
   height = impl->pending.toplevel.height;
@@ -1389,10 +1389,10 @@ gdk_wayland_surface_configure_toplevel (GdkSurface *surface)
   GDK_DISPLAY_NOTE (gdk_surface_get_display (surface), EVENTS,
             g_message ("configure, surface %p %dx%d,%s%s%s%s",
                        surface, width, height,
-                       (new_state & GDK_SURFACE_STATE_FULLSCREEN) ? " fullscreen" : "",
-                       (new_state & GDK_SURFACE_STATE_MAXIMIZED) ? " maximized" : "",
-                       (new_state & GDK_SURFACE_STATE_FOCUSED) ? " focused" : "",
-                       (new_state & GDK_SURFACE_STATE_TILED) ? " tiled" : ""));
+                       (new_state & GDK_TOPLEVEL_STATE_FULLSCREEN) ? " fullscreen" : "",
+                       (new_state & GDK_TOPLEVEL_STATE_MAXIMIZED) ? " maximized" : "",
+                       (new_state & GDK_TOPLEVEL_STATE_FOCUSED) ? " focused" : "",
+                       (new_state & GDK_TOPLEVEL_STATE_TILED) ? " tiled" : ""));
 
   gdk_surface_set_state (surface, new_state);
 
@@ -1511,7 +1511,7 @@ static void
 gdk_wayland_surface_handle_configure_toplevel (GdkSurface      *surface,
                                                int32_t          width,
                                                int32_t          height,
-                                               GdkSurfaceState  state)
+                                               GdkToplevelState  state)
 {
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
 
@@ -1558,7 +1558,7 @@ xdg_toplevel_configure (void                *data,
 {
   GdkSurface *surface = GDK_SURFACE (data);
   uint32_t *p;
-  GdkSurfaceState pending_state = 0;
+  GdkToplevelState pending_state = 0;
 
   wl_array_for_each (p, states)
     {
@@ -1567,13 +1567,13 @@ xdg_toplevel_configure (void                *data,
       switch (state)
         {
         case XDG_TOPLEVEL_STATE_FULLSCREEN:
-          pending_state |= GDK_SURFACE_STATE_FULLSCREEN;
+          pending_state |= GDK_TOPLEVEL_STATE_FULLSCREEN;
           break;
         case XDG_TOPLEVEL_STATE_MAXIMIZED:
-          pending_state |= GDK_SURFACE_STATE_MAXIMIZED;
+          pending_state |= GDK_TOPLEVEL_STATE_MAXIMIZED;
           break;
         case XDG_TOPLEVEL_STATE_ACTIVATED:
-          pending_state |= GDK_SURFACE_STATE_FOCUSED;
+          pending_state |= GDK_TOPLEVEL_STATE_FOCUSED;
           break;
         case XDG_TOPLEVEL_STATE_RESIZING:
           break;
@@ -1647,7 +1647,7 @@ zxdg_toplevel_v6_configure (void                    *data,
 {
   GdkSurface *surface = GDK_SURFACE (data);
   uint32_t *p;
-  GdkSurfaceState pending_state = 0;
+  GdkToplevelState pending_state = 0;
 
   wl_array_for_each (p, states)
     {
@@ -1656,13 +1656,13 @@ zxdg_toplevel_v6_configure (void                    *data,
       switch (state)
         {
         case ZXDG_TOPLEVEL_V6_STATE_FULLSCREEN:
-          pending_state |= GDK_SURFACE_STATE_FULLSCREEN;
+          pending_state |= GDK_TOPLEVEL_STATE_FULLSCREEN;
           break;
         case ZXDG_TOPLEVEL_V6_STATE_MAXIMIZED:
-          pending_state |= GDK_SURFACE_STATE_MAXIMIZED;
+          pending_state |= GDK_TOPLEVEL_STATE_MAXIMIZED;
           break;
         case ZXDG_TOPLEVEL_V6_STATE_ACTIVATED:
-          pending_state |= GDK_SURFACE_STATE_FOCUSED;
+          pending_state |= GDK_TOPLEVEL_STATE_FOCUSED;
           break;
         case ZXDG_TOPLEVEL_V6_STATE_RESIZING:
           break;
@@ -1771,16 +1771,16 @@ gdk_wayland_surface_create_xdg_toplevel (GdkSurface *surface)
   switch (display_wayland->shell_variant)
     {
     case GDK_WAYLAND_SHELL_VARIANT_XDG_SHELL:
-      if (surface->state & GDK_SURFACE_STATE_MAXIMIZED)
+      if (surface->state & GDK_TOPLEVEL_STATE_MAXIMIZED)
         xdg_toplevel_set_maximized (impl->display_server.xdg_toplevel);
-      if (surface->state & GDK_SURFACE_STATE_FULLSCREEN)
+      if (surface->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
         xdg_toplevel_set_fullscreen (impl->display_server.xdg_toplevel,
                                      impl->initial_fullscreen_output);
       break;
     case GDK_WAYLAND_SHELL_VARIANT_ZXDG_SHELL_V6:
-      if (surface->state & GDK_SURFACE_STATE_MAXIMIZED)
+      if (surface->state & GDK_TOPLEVEL_STATE_MAXIMIZED)
         zxdg_toplevel_v6_set_maximized (impl->display_server.zxdg_toplevel_v6);
-      if (surface->state & GDK_SURFACE_STATE_FULLSCREEN)
+      if (surface->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
         zxdg_toplevel_v6_set_fullscreen (impl->display_server.zxdg_toplevel_v6,
                                          impl->initial_fullscreen_output);
       break;
@@ -2975,7 +2975,7 @@ gdk_wayland_surface_map_popup (GdkSurface     *surface,
   impl->popup.unconstrained_height = height;
   impl->mapped = TRUE;
 
-  gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+  gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
 }
 
 static void
@@ -3245,7 +3245,7 @@ gtk_surface_configure (void                *data,
 {
   GdkSurface *surface = GDK_SURFACE (data);
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
-  GdkSurfaceState new_state = 0;
+  GdkToplevelState new_state = 0;
   uint32_t *p;
 
   wl_array_for_each (p, states)
@@ -3255,21 +3255,21 @@ gtk_surface_configure (void                *data,
       switch (state)
         {
         case GTK_SURFACE1_STATE_TILED:
-          new_state |= GDK_SURFACE_STATE_TILED;
+          new_state |= GDK_TOPLEVEL_STATE_TILED;
           break;
 
         /* Since v2 */
         case GTK_SURFACE1_STATE_TILED_TOP:
-          new_state |= (GDK_SURFACE_STATE_TILED | GDK_SURFACE_STATE_TOP_TILED);
+          new_state |= (GDK_TOPLEVEL_STATE_TILED | GDK_TOPLEVEL_STATE_TOP_TILED);
           break;
         case GTK_SURFACE1_STATE_TILED_RIGHT:
-          new_state |= (GDK_SURFACE_STATE_TILED | GDK_SURFACE_STATE_RIGHT_TILED);
+          new_state |= (GDK_TOPLEVEL_STATE_TILED | GDK_TOPLEVEL_STATE_RIGHT_TILED);
           break;
         case GTK_SURFACE1_STATE_TILED_BOTTOM:
-          new_state |= (GDK_SURFACE_STATE_TILED | GDK_SURFACE_STATE_BOTTOM_TILED);
+          new_state |= (GDK_TOPLEVEL_STATE_TILED | GDK_TOPLEVEL_STATE_BOTTOM_TILED);
           break;
         case GTK_SURFACE1_STATE_TILED_LEFT:
-          new_state |= (GDK_SURFACE_STATE_TILED | GDK_SURFACE_STATE_LEFT_TILED);
+          new_state |= (GDK_TOPLEVEL_STATE_TILED | GDK_TOPLEVEL_STATE_LEFT_TILED);
           break;
         default:
           /* Unknown state */
@@ -3287,7 +3287,7 @@ gtk_surface_configure_edges (void                *data,
 {
   GdkSurface *surface = GDK_SURFACE (data);
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
-  GdkSurfaceState new_state = 0;
+  GdkToplevelState new_state = 0;
   uint32_t *p;
 
   wl_array_for_each (p, edge_constraints)
@@ -3297,16 +3297,16 @@ gtk_surface_configure_edges (void                *data,
       switch (constraint)
         {
         case GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_TOP:
-          new_state |= GDK_SURFACE_STATE_TOP_RESIZABLE;
+          new_state |= GDK_TOPLEVEL_STATE_TOP_RESIZABLE;
           break;
         case GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_RIGHT:
-          new_state |= GDK_SURFACE_STATE_RIGHT_RESIZABLE;
+          new_state |= GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE;
           break;
         case GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_BOTTOM:
-          new_state |= GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
+          new_state |= GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;
           break;
         case GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_LEFT:
-          new_state |= GDK_SURFACE_STATE_LEFT_RESIZABLE;
+          new_state |= GDK_TOPLEVEL_STATE_LEFT_RESIZABLE;
           break;
         default:
           /* Unknown state */
@@ -3599,7 +3599,7 @@ gdk_wayland_surface_maximize (GdkSurface *surface)
     }
   else
     {
-      gdk_synthesize_surface_state (surface, 0, GDK_SURFACE_STATE_MAXIMIZED);
+      gdk_synthesize_surface_state (surface, 0, GDK_TOPLEVEL_STATE_MAXIMIZED);
     }
 }
 
@@ -3630,7 +3630,7 @@ gdk_wayland_surface_unmaximize (GdkSurface *surface)
     }
   else
     {
-      gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_MAXIMIZED, 0);
+      gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_MAXIMIZED, 0);
     }
 }
 
@@ -3667,7 +3667,7 @@ gdk_wayland_surface_fullscreen_on_monitor (GdkSurface *surface,
     }
   else
     {
-      gdk_synthesize_surface_state (surface, 0, GDK_SURFACE_STATE_FULLSCREEN);
+      gdk_synthesize_surface_state (surface, 0, GDK_TOPLEVEL_STATE_FULLSCREEN);
       impl->initial_fullscreen_output = output;
     }
 }
@@ -3705,7 +3705,7 @@ gdk_wayland_surface_fullscreen (GdkSurface *surface)
     }
   else
     {
-      gdk_synthesize_surface_state (surface, 0, GDK_SURFACE_STATE_FULLSCREEN);
+      gdk_synthesize_surface_state (surface, 0, GDK_TOPLEVEL_STATE_FULLSCREEN);
     }
 }
 
@@ -3738,7 +3738,7 @@ gdk_wayland_surface_unfullscreen (GdkSurface *surface)
     }
   else
     {
-      gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_FULLSCREEN, 0);
+      gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_FULLSCREEN, 0);
     }
 }
 
@@ -4732,7 +4732,7 @@ show_surface (GdkSurface *surface)
   was_mapped = GDK_SURFACE_IS_MAPPED (surface);
 
   if (!was_mapped)
-    gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+    gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
 
   gdk_wayland_surface_show (surface, FALSE);
 
@@ -4807,9 +4807,9 @@ gdk_wayland_toplevel_present (GdkToplevel       *toplevel,
 
   if (needs_reconfigure &&
       last_configure_serial == impl->last_configure_serial &&
-      !(surface->state & (GDK_SURFACE_STATE_MAXIMIZED |
-                          GDK_SURFACE_STATE_FULLSCREEN |
-                          GDK_SURFACE_STATE_TILED)))
+      !(surface->state & (GDK_TOPLEVEL_STATE_MAXIMIZED |
+                          GDK_TOPLEVEL_STATE_FULLSCREEN |
+                          GDK_TOPLEVEL_STATE_TILED)))
     configure_surface_geometry (surface);
 
   return TRUE;

gdk/win32/gdkevents-win32.c

@@ -311,7 +311,7 @@ low_level_keystroke_handler (WPARAM message,
 	  gboolean lshiftdown = GetKeyState (VK_LSHIFT) & 0x8000;
           gboolean rshiftdown = GetKeyState (VK_RSHIFT) & 0x8000;
           gboolean oneshiftdown = (lshiftdown || rshiftdown) && !(lshiftdown && rshiftdown);
-          gboolean maximized = gdk_toplevel_get_state (GDK_TOPLEVEL (toplevel)) & GDK_SURFACE_STATE_MAXIMIZED;
+          gboolean maximized = gdk_toplevel_get_state (GDK_TOPLEVEL (toplevel)) & GDK_TOPLEVEL_STATE_MAXIMIZED;
 
 	  switch (kbdhook->vkCode)
 	    {
@@ -983,9 +983,9 @@ show_window_recurse (GdkSurface *window, gboolean hide_window)
 	{
 	  if (!hide_window)
 	    {
-	      if (gdk_toplevel_get_state (GDK_TOPLEVEL (window)) & GDK_SURFACE_STATE_MINIMIZED)
+	      if (gdk_toplevel_get_state (GDK_TOPLEVEL (window)) & GDK_TOPLEVEL_STATE_MINIMIZED)
 		{
-		  if (gdk_toplevel_get_state (GDK_TOPLEVEL (window)) & GDK_SURFACE_STATE_MAXIMIZED)
+		  if (gdk_toplevel_get_state (GDK_TOPLEVEL (window)) & GDK_TOPLEVEL_STATE_MAXIMIZED)
 		    {
 		      GtkShowWindow (window, SW_SHOWMAXIMIZED);
 		    }
@@ -1590,7 +1590,7 @@ should_window_be_always_on_top (GdkSurface *window)
   DWORD exstyle;
 
   if (GDK_IS_DRAG_SURFACE (window) ||
-      (window->state & GDK_SURFACE_STATE_ABOVE))
+      (window->state & GDK_TOPLEVEL_STATE_ABOVE))
     return TRUE;
 
   exstyle = GetWindowLong (GDK_SURFACE_HWND (window), GWL_EXSTYLE);
@@ -3068,7 +3068,7 @@ gdk_event_translate (MSG *msg,
       /* Update window state */
       if (windowpos->flags & (SWP_STATECHANGED | SWP_SHOWWINDOW | SWP_HIDEWINDOW))
 	{
-	  GdkSurfaceState set_bits, unset_bits, old_state, new_state;
+	  GdkToplevelState set_bits, unset_bits, old_state, new_state;
 
 	  old_state = window->state;
 
@@ -3076,19 +3076,19 @@ gdk_event_translate (MSG *msg,
 	  unset_bits = 0;
 
 	  if (IsWindowVisible (msg->hwnd))
-	    unset_bits |= GDK_SURFACE_STATE_WITHDRAWN;
+	    unset_bits |= GDK_TOPLEVEL_STATE_WITHDRAWN;
 	  else
-	    set_bits |= GDK_SURFACE_STATE_WITHDRAWN;
+	    set_bits |= GDK_TOPLEVEL_STATE_WITHDRAWN;
 
 	  if (IsIconic (msg->hwnd))
-	    set_bits |= GDK_SURFACE_STATE_MINIMIZED;
+	    set_bits |= GDK_TOPLEVEL_STATE_MINIMIZED;
 	  else
-	    unset_bits |= GDK_SURFACE_STATE_MINIMIZED;
+	    unset_bits |= GDK_TOPLEVEL_STATE_MINIMIZED;
 
 	  if (IsZoomed (msg->hwnd))
-	    set_bits |= GDK_SURFACE_STATE_MAXIMIZED;
+	    set_bits |= GDK_TOPLEVEL_STATE_MAXIMIZED;
 	  else
-	    unset_bits |= GDK_SURFACE_STATE_MAXIMIZED;
+	    unset_bits |= GDK_TOPLEVEL_STATE_MAXIMIZED;
 
 	  gdk_synthesize_surface_state (window, unset_bits, set_bits);
 
@@ -3098,15 +3098,15 @@ gdk_event_translate (MSG *msg,
 	   * change the iconified state in all transient related windows,
 	   * as windows doesn't give icons for transient childrens.
 	   */
-	  if ((old_state & GDK_SURFACE_STATE_MINIMIZED) !=
-	      (new_state & GDK_SURFACE_STATE_MINIMIZED))
-	    do_show_window (window, (new_state & GDK_SURFACE_STATE_MINIMIZED));
+	  if ((old_state & GDK_TOPLEVEL_STATE_MINIMIZED) !=
+	      (new_state & GDK_TOPLEVEL_STATE_MINIMIZED))
+	    do_show_window (window, (new_state & GDK_TOPLEVEL_STATE_MINIMIZED));
 
 
 	  /* When un-minimizing, make sure we're stacked under any
 	     transient-type windows. */
-	  if (!(old_state & GDK_SURFACE_STATE_MINIMIZED) &&
-	      (new_state & GDK_SURFACE_STATE_MINIMIZED))
+	  if (!(old_state & GDK_TOPLEVEL_STATE_MINIMIZED) &&
+	      (new_state & GDK_TOPLEVEL_STATE_MINIMIZED))
             {
 	      ensure_stacking_on_unminimize (msg);
 	      restack_children (window);
@@ -3293,9 +3293,9 @@ gdk_event_translate (MSG *msg,
         }
 
       if (LOWORD (msg->wParam) == WA_INACTIVE)
-	gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_FOCUSED, 0);
+	gdk_synthesize_surface_state (window, GDK_TOPLEVEL_STATE_FOCUSED, 0);
       else
-	gdk_synthesize_surface_state (window, 0, GDK_SURFACE_STATE_FOCUSED);
+	gdk_synthesize_surface_state (window, 0, GDK_TOPLEVEL_STATE_FOCUSED);
 
       /* Bring any tablet contexts to the top of the overlap order when
        * one of our windows is activated.

gdk/win32/gdkmain-win32.c

@@ -262,7 +262,7 @@ _gdk_win32_drag_protocol_to_string (GdkDragProtocol protocol)
 }
 
 char *
-_gdk_win32_surface_state_to_string (GdkSurfaceState state)
+_gdk_win32_surface_state_to_string (GdkToplevelState state)
 {
   char buf[100];
   char *bufp = buf;
@@ -271,11 +271,11 @@ _gdk_win32_surface_state_to_string (GdkSurfaceState state)
   buf[0] = '\0';
 
 #define BIT(x)						\
-  if (state & GDK_SURFACE_STATE_ ## x)			\
+  if (state & GDK_TOPLEVEL_STATE_ ## x)			\
     (bufp += sprintf (bufp, "%s" #x, s), s = "|")
 
   /* For clarity, also show the complement of WITHDRAWN, i.e. "MAPPED" */
-  if (!(state & GDK_SURFACE_STATE_WITHDRAWN))
+  if (!(state & GDK_TOPLEVEL_STATE_WITHDRAWN))
     (bufp += sprintf (bufp, "MAPPED"), s = "|");
 
   BIT (WITHDRAWN);

gdk/win32/gdkprivate-win32.h

@@ -213,7 +213,7 @@ void   _gdk_win32_print_hpalette       (HPALETTE     hpal);
 void   _gdk_win32_print_dc             (HDC          hdc);
 
 char *_gdk_win32_drag_protocol_to_string (GdkDragProtocol protocol);
-char *_gdk_win32_surface_state_to_string (GdkSurfaceState state);
+char *_gdk_win32_surface_state_to_string (GdkToplevelState state);
 char *_gdk_win32_surface_style_to_string (LONG style);
 char *_gdk_win32_surface_exstyle_to_string (LONG style);
 char *_gdk_win32_surface_pos_bits_to_string (UINT flags);

gdk/win32/gdksurface-win32.c

@@ -804,21 +804,21 @@ show_window_internal (GdkSurface *window,
    */
   if (!unminimize &&
       !already_mapped &&
-      (window->state & GDK_SURFACE_STATE_MINIMIZED))
+      (window->state & GDK_TOPLEVEL_STATE_MINIMIZED))
     {
       GtkShowWindow (window, SW_SHOWMINNOACTIVE);
       return;
     }
 
   /* If asked to just show an iconified window, do nothing. */
-  if (!unminimize && (window->state & GDK_SURFACE_STATE_MINIMIZED))
+  if (!unminimize && (window->state & GDK_TOPLEVEL_STATE_MINIMIZED))
     return;
 
   /* If asked to unminimize an already noniconified window, do
    * nothing. (Especially, don't cause the window to rise and
    * activate. There are different calls for that.)
    */
-  if (unminimize && !(window->state & GDK_SURFACE_STATE_MINIMIZED))
+  if (unminimize && !(window->state & GDK_TOPLEVEL_STATE_MINIMIZED))
     return;
 
   /* If asked to show (but not raise) a window that is already
@@ -965,15 +965,15 @@ show_window_internal (GdkSurface *window,
     }
 
 
-  if (window->state & GDK_SURFACE_STATE_FULLSCREEN)
+  if (window->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
     {
       gdk_win32_surface_fullscreen (window);
     }
-  else if (window->state & GDK_SURFACE_STATE_MAXIMIZED)
+  else if (window->state & GDK_TOPLEVEL_STATE_MAXIMIZED)
     {
       GtkShowWindow (window, SW_MAXIMIZE);
     }
-  else if (window->state & GDK_SURFACE_STATE_MINIMIZED)
+  else if (window->state & GDK_TOPLEVEL_STATE_MINIMIZED)
     {
       GtkShowWindow (window, SW_RESTORE);
     }
@@ -995,13 +995,13 @@ show_window_internal (GdkSurface *window,
 
   /* Sync STATE_ABOVE to TOPMOST */
   if (!GDK_IS_DRAG_SURFACE (window) &&
-      (((window->state & GDK_SURFACE_STATE_ABOVE) &&
+      (((window->state & GDK_TOPLEVEL_STATE_ABOVE) &&
 	!(exstyle & WS_EX_TOPMOST)) ||
-       (!(window->state & GDK_SURFACE_STATE_ABOVE) &&
+       (!(window->state & GDK_TOPLEVEL_STATE_ABOVE) &&
 	(exstyle & WS_EX_TOPMOST))))
     {
       API_CALL (SetWindowPos, (GDK_SURFACE_HWND (window),
-			       (window->state & GDK_SURFACE_STATE_ABOVE)?HWND_TOPMOST:HWND_NOTOPMOST,
+			       (window->state & GDK_TOPLEVEL_STATE_ABOVE)?HWND_TOPMOST:HWND_NOTOPMOST,
 			       0, 0, 0, 0,
 			       SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOOWNERZORDER));
     }
@@ -1027,7 +1027,7 @@ gdk_win32_surface_hide (GdkSurface *window)
   if (GDK_SURFACE_IS_MAPPED (window))
     gdk_synthesize_surface_state (window,
 				 0,
-				 GDK_SURFACE_STATE_WITHDRAWN);
+				 GDK_TOPLEVEL_STATE_WITHDRAWN);
 
   _gdk_surface_clear_update_area (window);
 
@@ -1064,7 +1064,7 @@ gdk_win32_surface_do_move (GdkSurface *window,
   GDK_NOTE (MISC, g_print ("gdk_win32_surface_move: %p: %+d%+d\n",
                            GDK_SURFACE_HWND (window), x, y));
 
-  if (window->state & GDK_SURFACE_STATE_FULLSCREEN)
+  if (window->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
     return;
 
   impl = GDK_WIN32_SURFACE (window);
@@ -1103,7 +1103,7 @@ gdk_win32_surface_resize (GdkSurface *window,
   GDK_NOTE (MISC, g_print ("gdk_win32_surface_resize: %p: %dx%d\n",
                            GDK_SURFACE_HWND (window), width, height));
 
-  if (window->state & GDK_SURFACE_STATE_FULLSCREEN)
+  if (window->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
     return;
 
   get_outer_rect (window, width, height, &outer_rect);
@@ -1143,7 +1143,7 @@ gdk_win32_surface_do_move_resize (GdkSurface *window,
   if (height < 1)
     height = 1;
 
-  if (window->state & GDK_SURFACE_STATE_FULLSCREEN)
+  if (window->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
     return;
 
   GDK_NOTE (MISC, g_print ("gdk_win32_surface_move_resize: %p: %dx%d@%+d%+d\n",
@@ -1276,7 +1276,7 @@ static void
 show_popup (GdkSurface *surface)
 {
   gdk_win32_surface_raise (surface);
-  gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+  gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
   show_window_internal (surface, FALSE, FALSE);
   gdk_surface_invalidate_rect (surface, NULL);
 }
@@ -1828,7 +1828,7 @@ _gdk_win32_surface_update_style_bits (GdkSurface *window)
   HWND insert_after;
   UINT flags;
 
-  if (window->state & GDK_SURFACE_STATE_FULLSCREEN)
+  if (window->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
     return;
 
   old_style = GetWindowLong (GDK_SURFACE_HWND (window), GWL_STYLE);
@@ -2394,9 +2394,9 @@ _gdk_win32_surface_handle_aerosnap (GdkSurface            *window,
   GdkDisplay *display;
   GListModel *monitors;
   int n_monitors;
-  GdkSurfaceState surface_state = gdk_toplevel_get_state (GDK_TOPLEVEL (window));
-  gboolean minimized = surface_state & GDK_SURFACE_STATE_MINIMIZED;
-  gboolean maximized = surface_state & GDK_SURFACE_STATE_MAXIMIZED;
+  GdkToplevelState surface_state = gdk_toplevel_get_state (GDK_TOPLEVEL (window));
+  gboolean minimized = surface_state & GDK_TOPLEVEL_STATE_MINIMIZED;
+  gboolean maximized = surface_state & GDK_TOPLEVEL_STATE_MAXIMIZED;
   gboolean halfsnapped;
   GdkMonitor *monitor;
 
@@ -3432,7 +3432,7 @@ setup_drag_move_resize_context (GdkSurface                   *window,
   const char *cursor_name;
   GdkSurface *pointer_window;
   GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
-  gboolean maximized = gdk_toplevel_get_state (GDK_TOPLEVEL (window)) & GDK_SURFACE_STATE_MAXIMIZED;
+  gboolean maximized = gdk_toplevel_get_state (GDK_TOPLEVEL (window)) & GDK_TOPLEVEL_STATE_MAXIMIZED;
   int root_x, root_y;
 
   gdk_win32_surface_get_root_coords (window, x, y, &root_x, &root_y);
@@ -4162,7 +4162,7 @@ gdk_win32_surface_minimize (GdkSurface *window)
     {
       gdk_synthesize_surface_state (window,
                                     0,
-                                    GDK_SURFACE_STATE_MINIMIZED);
+                                    GDK_TOPLEVEL_STATE_MINIMIZED);
     }
 }
 
@@ -4184,7 +4184,7 @@ gdk_win32_surface_maximize (GdkSurface *window)
   else
     gdk_synthesize_surface_state (window,
 				 0,
-				 GDK_SURFACE_STATE_MAXIMIZED);
+				 GDK_TOPLEVEL_STATE_MAXIMIZED);
 }
 
 static void
@@ -4205,7 +4205,7 @@ gdk_win32_surface_unmaximize (GdkSurface *window)
     GtkShowWindow (window, SW_RESTORE);
   else
     gdk_synthesize_surface_state (window,
-				 GDK_SURFACE_STATE_MAXIMIZED,
+				 GDK_TOPLEVEL_STATE_MAXIMIZED,
 				 0);
 }
 
@@ -4250,7 +4250,7 @@ gdk_win32_surface_fullscreen (GdkSurface *window)
       fi->style = GetWindowLong (GDK_SURFACE_HWND (window), GWL_STYLE);
 
       /* Send state change before configure event */
-      gdk_synthesize_surface_state (window, 0, GDK_SURFACE_STATE_FULLSCREEN);
+      gdk_synthesize_surface_state (window, 0, GDK_TOPLEVEL_STATE_FULLSCREEN);
 
       SetWindowLong (GDK_SURFACE_HWND (window), GWL_STYLE,
                      (fi->style & ~WS_OVERLAPPEDWINDOW) | WS_POPUP);
@@ -4273,7 +4273,7 @@ gdk_win32_surface_unfullscreen (GdkSurface *window)
     {
       GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
 
-      gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_FULLSCREEN, 0);
+      gdk_synthesize_surface_state (window, GDK_TOPLEVEL_STATE_FULLSCREEN, 0);
 
       impl->hint_flags = fi->hint_flags;
       SetWindowLong (GDK_SURFACE_HWND (window), GWL_STYLE, fi->style);
@@ -4302,9 +4302,9 @@ gdk_win32_surface_focus (GdkSurface *window,
 			   GDK_SURFACE_HWND (window),
 			   _gdk_win32_surface_state_to_string (window->state)));
 
-  if (window->state & GDK_SURFACE_STATE_MAXIMIZED)
+  if (window->state & GDK_TOPLEVEL_STATE_MAXIMIZED)
     GtkShowWindow (window, SW_SHOWMAXIMIZED);
-  else if (window->state & GDK_SURFACE_STATE_MINIMIZED)
+  else if (window->state & GDK_TOPLEVEL_STATE_MINIMIZED)
     GtkShowWindow (window, SW_RESTORE);
   else if (!IsWindowVisible (GDK_SURFACE_HWND (window)))
     GtkShowWindow (window, SW_SHOWNORMAL);
@@ -4927,7 +4927,7 @@ show_surface (GdkSurface *surface)
   was_mapped = GDK_SURFACE_IS_MAPPED (surface);
 
   if (!was_mapped)
-    gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+    gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
 
   gdk_win32_surface_show (surface, FALSE);
 

gdk/x11/gdkdisplay-x11.c

@@ -216,19 +216,19 @@ gdk_x11_display_event_translator_init (GdkEventTranslatorIface *iface)
   iface->translate_event = gdk_x11_display_translate_event;
 }
 
-#define ANY_EDGE_TILED (GDK_SURFACE_STATE_LEFT_TILED | \
-                        GDK_SURFACE_STATE_RIGHT_TILED | \
-                        GDK_SURFACE_STATE_TOP_TILED | \
-                        GDK_SURFACE_STATE_BOTTOM_TILED)
+#define ANY_EDGE_TILED (GDK_TOPLEVEL_STATE_LEFT_TILED | \
+                        GDK_TOPLEVEL_STATE_RIGHT_TILED | \
+                        GDK_TOPLEVEL_STATE_TOP_TILED | \
+                        GDK_TOPLEVEL_STATE_BOTTOM_TILED)
 
 static void
 do_edge_constraint_state_check (GdkSurface      *surface,
-                                GdkSurfaceState  old_state,
-                                GdkSurfaceState *set,
-                                GdkSurfaceState *unset)
+                                GdkToplevelState  old_state,
+                                GdkToplevelState *set,
+                                GdkToplevelState *unset)
 {
   GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (surface);
-  GdkSurfaceState local_set, local_unset;
+  GdkToplevelState local_set, local_unset;
   guint edge_constraints;
 
   local_set = *set;
@@ -237,7 +237,7 @@ do_edge_constraint_state_check (GdkSurface      *surface,
 
   /* If the WM doesn't support _GTK_EDGE_CONSTRAINTS, rely on the fallback
    * implementation. If it supports _GTK_EDGE_CONSTRAINTS, arrange for
-   * GDK_SURFACE_STATE_TILED to be set if any edge is tiled, and cleared
+   * GDK_TOPLEVEL_STATE_TILED to be set if any edge is tiled, and cleared
    * if no edge is tiled.
    */
   if (!gdk_x11_surface_supports_edge_constraints (surface))
@@ -246,121 +246,121 @@ do_edge_constraint_state_check (GdkSurface      *surface,
        * mutter only tiles horizontally, and sets maxvert when it does
        * and if it tiles, it always affects all edges
        */
-      if (old_state & GDK_SURFACE_STATE_TILED)
+      if (old_state & GDK_TOPLEVEL_STATE_TILED)
         {
           if (!toplevel->have_maxvert)
-            local_unset |= GDK_SURFACE_STATE_TILED;
+            local_unset |= GDK_TOPLEVEL_STATE_TILED;
         }
       else
         {
           if (toplevel->have_maxvert && !toplevel->have_maxhorz)
-            local_set |= GDK_SURFACE_STATE_TILED;
+            local_set |= GDK_TOPLEVEL_STATE_TILED;
         }
     }
   else
     {
-      if (old_state & GDK_SURFACE_STATE_TILED)
+      if (old_state & GDK_TOPLEVEL_STATE_TILED)
         {
           if (!(edge_constraints & ANY_EDGE_TILED))
-            local_unset |= GDK_SURFACE_STATE_TILED;
+            local_unset |= GDK_TOPLEVEL_STATE_TILED;
         }
       else
         {
           if (edge_constraints & ANY_EDGE_TILED)
-            local_set |= GDK_SURFACE_STATE_TILED;
+            local_set |= GDK_TOPLEVEL_STATE_TILED;
         }
     }
 
   /* Top edge */
-  if (old_state & GDK_SURFACE_STATE_TOP_TILED)
+  if (old_state & GDK_TOPLEVEL_STATE_TOP_TILED)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_TOP_TILED) == 0)
-        local_unset |= GDK_SURFACE_STATE_TOP_TILED;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_TOP_TILED) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_TOP_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_TOP_TILED)
-        local_set |= GDK_SURFACE_STATE_TOP_TILED;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_TOP_TILED)
+        local_set |= GDK_TOPLEVEL_STATE_TOP_TILED;
     }
 
-  if (old_state & GDK_SURFACE_STATE_TOP_RESIZABLE)
+  if (old_state & GDK_TOPLEVEL_STATE_TOP_RESIZABLE)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_TOP_RESIZABLE) == 0)
-        local_unset |= GDK_SURFACE_STATE_TOP_RESIZABLE;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_TOP_RESIZABLE) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_TOP_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_TOP_RESIZABLE)
-        local_set |= GDK_SURFACE_STATE_TOP_RESIZABLE;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_TOP_RESIZABLE)
+        local_set |= GDK_TOPLEVEL_STATE_TOP_RESIZABLE;
     }
 
   /* Right edge */
-  if (old_state & GDK_SURFACE_STATE_RIGHT_TILED)
+  if (old_state & GDK_TOPLEVEL_STATE_RIGHT_TILED)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_RIGHT_TILED) == 0)
-        local_unset |= GDK_SURFACE_STATE_RIGHT_TILED;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_RIGHT_TILED) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_RIGHT_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_RIGHT_TILED)
-        local_set |= GDK_SURFACE_STATE_RIGHT_TILED;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_RIGHT_TILED)
+        local_set |= GDK_TOPLEVEL_STATE_RIGHT_TILED;
     }
 
-  if (old_state & GDK_SURFACE_STATE_RIGHT_RESIZABLE)
+  if (old_state & GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_RIGHT_RESIZABLE) == 0)
-        local_unset |= GDK_SURFACE_STATE_RIGHT_RESIZABLE;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_RIGHT_RESIZABLE)
-        local_set |= GDK_SURFACE_STATE_RIGHT_RESIZABLE;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE)
+        local_set |= GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE;
     }
 
   /* Bottom edge */
-  if (old_state & GDK_SURFACE_STATE_BOTTOM_TILED)
+  if (old_state & GDK_TOPLEVEL_STATE_BOTTOM_TILED)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_BOTTOM_TILED) == 0)
-        local_unset |= GDK_SURFACE_STATE_BOTTOM_TILED;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_BOTTOM_TILED) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_BOTTOM_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_BOTTOM_TILED)
-        local_set |= GDK_SURFACE_STATE_BOTTOM_TILED;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_BOTTOM_TILED)
+        local_set |= GDK_TOPLEVEL_STATE_BOTTOM_TILED;
     }
 
-  if (old_state & GDK_SURFACE_STATE_BOTTOM_RESIZABLE)
+  if (old_state & GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_BOTTOM_RESIZABLE) == 0)
-        local_unset |= GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_BOTTOM_RESIZABLE)
-        local_set |= GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE)
+        local_set |= GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;
     }
 
   /* Left edge */
-  if (old_state & GDK_SURFACE_STATE_LEFT_TILED)
+  if (old_state & GDK_TOPLEVEL_STATE_LEFT_TILED)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_LEFT_TILED) == 0)
-        local_unset |= GDK_SURFACE_STATE_LEFT_TILED;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_LEFT_TILED) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_LEFT_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_LEFT_TILED)
-        local_set |= GDK_SURFACE_STATE_LEFT_TILED;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_LEFT_TILED)
+        local_set |= GDK_TOPLEVEL_STATE_LEFT_TILED;
     }
 
-  if (old_state & GDK_SURFACE_STATE_LEFT_RESIZABLE)
+  if (old_state & GDK_TOPLEVEL_STATE_LEFT_RESIZABLE)
     {
-      if ((edge_constraints & GDK_SURFACE_STATE_LEFT_RESIZABLE) == 0)
-        local_unset |= GDK_SURFACE_STATE_LEFT_RESIZABLE;
+      if ((edge_constraints & GDK_TOPLEVEL_STATE_LEFT_RESIZABLE) == 0)
+        local_unset |= GDK_TOPLEVEL_STATE_LEFT_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_LEFT_RESIZABLE)
-        local_set |= GDK_SURFACE_STATE_LEFT_RESIZABLE;
+      if (edge_constraints & GDK_TOPLEVEL_STATE_LEFT_RESIZABLE)
+        local_set |= GDK_TOPLEVEL_STATE_LEFT_RESIZABLE;
     }
 
   *set = local_set;
@@ -371,7 +371,7 @@ static void
 do_net_wm_state_changes (GdkSurface *surface)
 {
   GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (surface);
-  GdkSurfaceState old_state, set, unset;
+  GdkToplevelState old_state, set, unset;
 
   if (GDK_SURFACE_DESTROYED (surface) ||
       !GDK_IS_TOPLEVEL (surface))
@@ -381,51 +381,51 @@ do_net_wm_state_changes (GdkSurface *surface)
 
   set = unset = 0;
 
-  if (old_state & GDK_SURFACE_STATE_FULLSCREEN)
+  if (old_state & GDK_TOPLEVEL_STATE_FULLSCREEN)
     {
       if (!toplevel->have_fullscreen)
-        unset |= GDK_SURFACE_STATE_FULLSCREEN;
+        unset |= GDK_TOPLEVEL_STATE_FULLSCREEN;
     }
   else
     {
       if (toplevel->have_fullscreen)
-        set |= GDK_SURFACE_STATE_FULLSCREEN;
+        set |= GDK_TOPLEVEL_STATE_FULLSCREEN;
     }
 
   /* Our "maximized" means both vertical and horizontal; if only one,
    * we don't expose that via GDK
    */
-  if (old_state & GDK_SURFACE_STATE_MAXIMIZED)
+  if (old_state & GDK_TOPLEVEL_STATE_MAXIMIZED)
     {
       if (!(toplevel->have_maxvert && toplevel->have_maxhorz))
-        unset |= GDK_SURFACE_STATE_MAXIMIZED;
+        unset |= GDK_TOPLEVEL_STATE_MAXIMIZED;
     }
   else
     {
       if (toplevel->have_maxvert && toplevel->have_maxhorz)
-        set |= GDK_SURFACE_STATE_MAXIMIZED;
+        set |= GDK_TOPLEVEL_STATE_MAXIMIZED;
     }
 
-  if (old_state & GDK_SURFACE_STATE_FOCUSED)
+  if (old_state & GDK_TOPLEVEL_STATE_FOCUSED)
     {
       if (!toplevel->have_focused)
-        unset |= GDK_SURFACE_STATE_FOCUSED;
+        unset |= GDK_TOPLEVEL_STATE_FOCUSED;
     }
   else
     {
       if (toplevel->have_focused)
-        set |= GDK_SURFACE_STATE_FOCUSED;
+        set |= GDK_TOPLEVEL_STATE_FOCUSED;
     }
 
-  if (old_state & GDK_SURFACE_STATE_MINIMIZED)
+  if (old_state & GDK_TOPLEVEL_STATE_MINIMIZED)
     {
       if (!toplevel->have_hidden)
-        unset |= GDK_SURFACE_STATE_MINIMIZED;
+        unset |= GDK_TOPLEVEL_STATE_MINIMIZED;
     }
   else
     {
       if (toplevel->have_hidden)
-        set |= GDK_SURFACE_STATE_MINIMIZED;
+        set |= GDK_TOPLEVEL_STATE_MINIMIZED;
     }
 
   /* Update edge constraints and tiling */
@@ -827,7 +827,7 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
               if (GDK_SURFACE_IS_MAPPED (surface))
                 gdk_synthesize_surface_state (surface,
                                               0,
-                                              GDK_SURFACE_STATE_MINIMIZED);
+                                              GDK_TOPLEVEL_STATE_MINIMIZED);
             }
 
           if (surface_impl->toplevel &&
@@ -855,9 +855,9 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
       if (surface && !is_substructure)
 	{
 	  /* Unset minimized if it was set */
-	  if (surface->state & GDK_SURFACE_STATE_MINIMIZED)
+	  if (surface->state & GDK_TOPLEVEL_STATE_MINIMIZED)
 	    gdk_synthesize_surface_state (surface,
-				 	  GDK_SURFACE_STATE_MINIMIZED,
+				 	  GDK_TOPLEVEL_STATE_MINIMIZED,
 					  0);
 
 	  if (toplevel)

gdk/x11/gdkdrag-x11.c

@@ -2030,7 +2030,7 @@ _gdk_x11_surface_drag_begin (GdkSurface         *surface,
   if (gdk_x11_surface_get_group (surface))
     gdk_x11_surface_set_group (x11_drag->ipc_surface, surface);
 
-  gdk_synthesize_surface_state (x11_drag->ipc_surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+  gdk_synthesize_surface_state (x11_drag->ipc_surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
   gdk_x11_surface_show (x11_drag->ipc_surface, FALSE);
 
   x11_drag->drag_surface = create_drag_surface (display);

gdk/x11/gdkglcontext-x11.c

@@ -716,7 +716,7 @@ on_surface_state_changed (GdkGLContext *context)
 {
   GdkSurface *surface = gdk_gl_context_get_surface (context);
 
-  if ((surface->state & GDK_SURFACE_STATE_WITHDRAWN) == 0)
+  if ((surface->state & GDK_TOPLEVEL_STATE_WITHDRAWN) == 0)
     return;
 
   /* If we're about to withdraw the surface, then we don't care if the frame is
@@ -1060,7 +1060,9 @@ gdk_x11_screen_init_gl (GdkX11Screen *screen)
                        "\t* GLX_EXT_texture_from_pixmap: %s\n"
                        "\t* GLX_SGI_video_sync: %s\n"
                        "\t* GLX_EXT_buffer_age: %s\n"
-                       "\t* GLX_OML_sync_control: %s",
+                       "\t* GLX_OML_sync_control: %s"
+                       "\t* GLX_ARB_multisample: %s"
+                       "\t* GLX_EXT_visual_rating: %s",
                      display_x11->glx_version / 10,
                      display_x11->glx_version % 10,
                      glXGetClientString (dpy, GLX_VENDOR),
@@ -1070,7 +1072,9 @@ gdk_x11_screen_init_gl (GdkX11Screen *screen)
                      display_x11->has_glx_texture_from_pixmap ? "yes" : "no",
                      display_x11->has_glx_video_sync ? "yes" : "no",
                      display_x11->has_glx_buffer_age ? "yes" : "no",
-                     display_x11->has_glx_sync_control ? "yes" : "no"));
+                     display_x11->has_glx_sync_control ? "yes" : "no",
+                     display_x11->has_glx_multisample ? "yes" : "no",
+                     display_x11->has_glx_visual_rating ? "yes" : "no"));
 
   return TRUE;
 }

gdk/x11/gdkmonitor-x11.c

@@ -47,7 +47,7 @@ gdk_monitor_has_fullscreen_window (GdkMonitor *monitor)
       if (!GDK_IS_TOPLEVEL (surface))
         continue;
 
-      if ((gdk_toplevel_get_state (GDK_TOPLEVEL (surface)) & GDK_SURFACE_STATE_FULLSCREEN) == 0)
+      if ((gdk_toplevel_get_state (GDK_TOPLEVEL (surface)) & GDK_TOPLEVEL_STATE_FULLSCREEN) == 0)
         continue;
 
       if (surface->fullscreen_mode == GDK_FULLSCREEN_ON_ALL_MONITORS ||

gdk/x11/gdksurface-x11.c

@@ -1168,14 +1168,14 @@ update_wm_hints (GdkSurface *surface,
 
   if (!force &&
       !toplevel->is_leader &&
-      surface->state & GDK_SURFACE_STATE_WITHDRAWN)
+      surface->state & GDK_TOPLEVEL_STATE_WITHDRAWN)
     return;
 
   wm_hints.flags = StateHint | InputHint;
   wm_hints.input = True;
   wm_hints.initial_state = NormalState;
   
-  if (surface->state & GDK_SURFACE_STATE_MINIMIZED)
+  if (surface->state & GDK_TOPLEVEL_STATE_MINIMIZED)
     {
       wm_hints.flags |= StateHint;
       wm_hints.initial_state = IconicState;
@@ -1234,7 +1234,7 @@ set_initial_hints (GdkSurface *surface)
   
   i = 0;
 
-  if (surface->state & GDK_SURFACE_STATE_MAXIMIZED)
+  if (surface->state & GDK_TOPLEVEL_STATE_MAXIMIZED)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_MAXIMIZED_VERT");
@@ -1245,21 +1245,21 @@ set_initial_hints (GdkSurface *surface)
       toplevel->have_maxhorz = toplevel->have_maxvert = TRUE;
     }
 
-  if (surface->state & GDK_SURFACE_STATE_ABOVE)
+  if (surface->state & GDK_TOPLEVEL_STATE_ABOVE)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_ABOVE");
       ++i;
     }
   
-  if (surface->state & GDK_SURFACE_STATE_BELOW)
+  if (surface->state & GDK_TOPLEVEL_STATE_BELOW)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_BELOW");
       ++i;
     }
   
-  if (surface->state & GDK_SURFACE_STATE_FULLSCREEN)
+  if (surface->state & GDK_TOPLEVEL_STATE_FULLSCREEN)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_FULLSCREEN");
@@ -1288,7 +1288,7 @@ set_initial_hints (GdkSurface *surface)
       ++i;
     }
 
-  if (surface->state & GDK_SURFACE_STATE_MINIMIZED)
+  if (surface->state & GDK_TOPLEVEL_STATE_MINIMIZED)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_HIDDEN");
@@ -1311,7 +1311,7 @@ set_initial_hints (GdkSurface *surface)
 		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"));
     }
 
-  if (surface->state & GDK_SURFACE_STATE_STICKY)
+  if (surface->state & GDK_TOPLEVEL_STATE_STICKY)
     {
       atoms[0] = 0xFFFFFFFF;
       XChangeProperty (xdisplay,
@@ -1377,7 +1377,7 @@ gdk_x11_surface_withdraw (GdkSurface *surface)
       if (GDK_SURFACE_IS_MAPPED (surface))
         gdk_synthesize_surface_state (surface,
                                      0,
-                                     GDK_SURFACE_STATE_WITHDRAWN);
+                                     GDK_TOPLEVEL_STATE_WITHDRAWN);
 
       g_assert (!GDK_SURFACE_IS_MAPPED (surface));
       XWithdrawWindow (GDK_SURFACE_XDISPLAY (surface),
@@ -1596,7 +1596,7 @@ static void
 show_popup (GdkSurface *surface)
 {
   gdk_x11_surface_raise (surface);
-  gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+  gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
   gdk_x11_surface_show (surface, FALSE);
   gdk_surface_invalidate_rect (surface, NULL);
 }
@@ -3075,7 +3075,7 @@ gdk_x11_surface_minimize (GdkSurface *surface)
   else
     {
       /* Flip our client side flag, the real work happens on map. */
-      gdk_synthesize_surface_state (surface, 0, GDK_SURFACE_STATE_MINIMIZED);
+      gdk_synthesize_surface_state (surface, 0, GDK_TOPLEVEL_STATE_MINIMIZED);
       gdk_wmspec_change_state (TRUE, surface,
                                "_NET_WM_STATE_HIDDEN",
                                NULL);
@@ -3098,7 +3098,7 @@ gdk_x11_surface_unminimize (GdkSurface *surface)
   else
     {
       /* Flip our client side flag, the real work happens on map. */
-      gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_MINIMIZED, 0);
+      gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_MINIMIZED, 0);
       gdk_wmspec_change_state (FALSE, surface,
                                "_NET_WM_STATE_HIDDEN",
                                NULL);
@@ -3118,7 +3118,7 @@ gdk_x11_surface_maximize (GdkSurface *surface)
   else
     gdk_synthesize_surface_state (surface,
 				 0,
-				 GDK_SURFACE_STATE_MAXIMIZED);
+				 GDK_TOPLEVEL_STATE_MAXIMIZED);
 }
 
 static void
@@ -3133,7 +3133,7 @@ gdk_x11_surface_unmaximize (GdkSurface *surface)
 			     "_NET_WM_STATE_MAXIMIZED_HORZ");
   else
     gdk_synthesize_surface_state (surface,
-				 GDK_SURFACE_STATE_MAXIMIZED,
+				 GDK_TOPLEVEL_STATE_MAXIMIZED,
 				 0);
 }
 
@@ -3248,7 +3248,7 @@ gdk_x11_surface_fullscreen (GdkSurface *surface)
   else
     gdk_synthesize_surface_state (surface,
                                  0,
-                                 GDK_SURFACE_STATE_FULLSCREEN);
+                                 GDK_TOPLEVEL_STATE_FULLSCREEN);
 }
 
 static void
@@ -3281,7 +3281,7 @@ gdk_x11_surface_unfullscreen (GdkSurface *surface)
 
   else
     gdk_synthesize_surface_state (surface,
-				 GDK_SURFACE_STATE_FULLSCREEN,
+				 GDK_TOPLEVEL_STATE_FULLSCREEN,
 				 0);
 }
 
@@ -3790,7 +3790,7 @@ check_maximize (MoveResizeData *mv_resize,
                 double          x_root,
                 double          y_root)
 {
-  GdkSurfaceState state;
+  GdkToplevelState state;
   int y;
 
   if (mv_resize->is_resize)
@@ -3798,7 +3798,7 @@ check_maximize (MoveResizeData *mv_resize,
 
   state = gdk_toplevel_get_state (GDK_TOPLEVEL (mv_resize->moveresize_surface));
 
-  if (state & GDK_SURFACE_STATE_MAXIMIZED)
+  if (state & GDK_TOPLEVEL_STATE_MAXIMIZED)
     return;
 
   y = mv_resize->moveresize_orig_y + (y_root - mv_resize->moveresize_y);
@@ -3812,7 +3812,7 @@ check_unmaximize (MoveResizeData *mv_resize,
                   double          x_root,
                   double          y_root)
 {
-  GdkSurfaceState state;
+  GdkToplevelState state;
   int dx, dy;
 
   if (mv_resize->is_resize)
@@ -3820,7 +3820,7 @@ check_unmaximize (MoveResizeData *mv_resize,
 
   state = gdk_toplevel_get_state (GDK_TOPLEVEL (mv_resize->moveresize_surface));
 
-  if ((state & (GDK_SURFACE_STATE_MAXIMIZED | GDK_SURFACE_STATE_TILED)) == 0)
+  if ((state & (GDK_TOPLEVEL_STATE_MAXIMIZED | GDK_TOPLEVEL_STATE_TILED)) == 0)
     return;
 
   dx = x_root - mv_resize->moveresize_x;
@@ -4923,7 +4923,7 @@ gdk_x11_toplevel_present (GdkToplevel       *toplevel,
   was_mapped = GDK_SURFACE_IS_MAPPED (surface);
 
   if (!was_mapped)
-    gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+    gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
 
   gdk_x11_surface_show (surface, was_mapped);
 
@@ -4980,7 +4980,7 @@ gdk_x11_toplevel_inhibit_system_shortcuts (GdkToplevel *toplevel,
   if (surface->shortcuts_inhibited)
     return; /* Already inhibited */
 
-  if (!(surface->state & GDK_SURFACE_STATE_FOCUSED))
+  if (!(surface->state & GDK_TOPLEVEL_STATE_FOCUSED))
     return;
 
   gdk_seat = gdk_surface_get_seat_from_event (surface, gdk_event);
@@ -5019,7 +5019,7 @@ gdk_x11_toplevel_restore_system_shortcuts (GdkToplevel *toplevel)
 static void
 gdk_x11_toplevel_state_callback (GdkSurface *surface)
 {
-  if (surface->state & GDK_SURFACE_STATE_FOCUSED)
+  if (surface->state & GDK_TOPLEVEL_STATE_FOCUSED)
     return;
 
   if (surface->shortcuts_inhibited)
@@ -5096,7 +5096,7 @@ gdk_x11_drag_surface_present (GdkDragSurface *drag_surface,
   GdkSurface *surface = GDK_SURFACE (drag_surface);
 
   gdk_x11_surface_toplevel_resize (surface, width, height);
-  gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_WITHDRAWN, 0);
+  gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_WITHDRAWN, 0);
   gdk_x11_surface_show (surface, FALSE);
   gdk_surface_invalidate_rect (surface, NULL);
 

gsk/gl/gskgldriver.c

@@ -541,16 +541,37 @@ gsk_gl_driver_get_texture_for_texture (GskGLDriver *self,
   return t->texture_id;
 }
 
+static guint
+texture_key_hash (gconstpointer v)
+{
+  const GskTextureKey *k = (GskTextureKey *)v;
+
+  return GPOINTER_TO_UINT (k->pointer)
+         + (guint)(k->scale*100)
+         + (guint)k->filter;
+}
+
+static gboolean
+texture_key_equal (gconstpointer v1, gconstpointer v2)
+{
+  const GskTextureKey *k1 = (GskTextureKey *)v1;
+  const GskTextureKey *k2 = (GskTextureKey *)v2;
+
+  return k1->pointer == k2->pointer &&
+         k1->scale == k2->scale &&
+         k1->filter == k2->filter;
+}
+
 int
-gsk_gl_driver_get_texture_for_pointer (GskGLDriver *self,
-                                       gpointer     pointer)
+gsk_gl_driver_get_texture_for_key (GskGLDriver   *self,
+                                   GskTextureKey *key)
 {
   int id = 0;
 
   if (G_UNLIKELY (self->pointer_textures == NULL))
-    self->pointer_textures = g_hash_table_new (NULL, NULL);
+    self->pointer_textures = g_hash_table_new_full (texture_key_hash, texture_key_equal, g_free, NULL);
 
-  id = GPOINTER_TO_INT (g_hash_table_lookup (self->pointer_textures, pointer));
+  id = GPOINTER_TO_INT (g_hash_table_lookup (self->pointer_textures, key));
 
   if (id != 0)
     {
@@ -566,14 +587,19 @@ gsk_gl_driver_get_texture_for_pointer (GskGLDriver *self,
 }
 
 void
-gsk_gl_driver_set_texture_for_pointer (GskGLDriver *self,
-                                       gpointer     pointer,
-                                       int          texture_id)
+gsk_gl_driver_set_texture_for_key (GskGLDriver   *self,
+                                   GskTextureKey *key,
+                                   int            texture_id)
 {
-  if (G_UNLIKELY (self->pointer_textures == NULL))
-    self->pointer_textures = g_hash_table_new (NULL, NULL);
+  GskTextureKey *k;
 
-  g_hash_table_insert (self->pointer_textures, pointer, GINT_TO_POINTER (texture_id));
+  if (G_UNLIKELY (self->pointer_textures == NULL))
+    self->pointer_textures = g_hash_table_new_full (texture_key_hash, texture_key_equal, g_free, NULL);
+
+  k = g_new (GskTextureKey, 1);
+  *k = *key;
+
+  g_hash_table_insert (self->pointer_textures, k, GINT_TO_POINTER (texture_id));
 }
 
 int
@@ -594,6 +620,8 @@ void
 gsk_gl_driver_create_render_target (GskGLDriver *self,
                                     int          width,
                                     int          height,
+                                    int          min_filter,
+                                    int          mag_filter,
                                     int         *out_texture_id,
                                     int         *out_render_target_id)
 {
@@ -604,7 +632,7 @@ gsk_gl_driver_create_render_target (GskGLDriver *self,
 
   texture = create_texture (self, width, height);
   gsk_gl_driver_bind_source_texture (self, texture->texture_id);
-  gsk_gl_driver_init_texture_empty (self, texture->texture_id, GL_NEAREST, GL_NEAREST);
+  gsk_gl_driver_init_texture_empty (self, texture->texture_id, min_filter, mag_filter);
 
   glGenFramebuffers (1, &fbo_id);
   glBindFramebuffer (GL_FRAMEBUFFER, fbo_id);

gsk/gl/gskgldriverprivate.h

@@ -21,6 +21,11 @@ typedef struct {
   guint texture_id;
 } TextureSlice;
 
+typedef struct {
+  gpointer pointer;
+  float scale;
+  int filter;
+} GskTextureKey;
 
 GskGLDriver *   gsk_gl_driver_new                       (GdkGLContext    *context);
 GdkGLContext   *gsk_gl_driver_get_gl_context            (GskGLDriver     *driver);
@@ -34,10 +39,10 @@ int             gsk_gl_driver_get_texture_for_texture   (GskGLDriver     *driver
                                                          GdkTexture      *texture,
                                                          int              min_filter,
                                                          int              mag_filter);
-int             gsk_gl_driver_get_texture_for_pointer   (GskGLDriver     *driver,
-                                                         gpointer         pointer);
-void            gsk_gl_driver_set_texture_for_pointer   (GskGLDriver     *driver,
-                                                         gpointer         pointer,
+int             gsk_gl_driver_get_texture_for_key       (GskGLDriver     *driver,
+                                                         GskTextureKey   *key);
+void            gsk_gl_driver_set_texture_for_key       (GskGLDriver     *driver,
+                                                         GskTextureKey   *key,
                                                          int              texture_id);
 int             gsk_gl_driver_create_texture            (GskGLDriver     *driver,
                                                          float            width,
@@ -45,6 +50,8 @@ int             gsk_gl_driver_create_texture            (GskGLDriver     *driver
 void            gsk_gl_driver_create_render_target      (GskGLDriver     *driver,
                                                          int              width,
                                                          int              height,
+                                                         int              min_filter,
+                                                         int              mag_filter,
                                                          int             *out_texture_id,
                                                          int             *out_render_target_id);
 void            gsk_gl_driver_mark_texture_permanent    (GskGLDriver     *self,

gsk/gl/gskglrenderer.c

@@ -71,6 +71,7 @@ typedef enum
   RESET_OPACITY    = 1 << 2,
   DUMP_FRAMEBUFFER = 1 << 3,
   NO_CACHE_PLZ     = 1 << 5,
+  LINEAR_FILTER    = 1 << 6,
 } OffscreenFlags;
 
 static inline void
@@ -571,12 +572,17 @@ render_fallback_node (GskGLRenderer   *self,
   cairo_t *cr;
   int cached_id;
   int texture_id;
+  GskTextureKey key;
 
   if (surface_width <= 0 ||
       surface_height <= 0)
     return;
 
-  cached_id = gsk_gl_driver_get_texture_for_pointer (self->gl_driver, node);
+  key.pointer = node;
+  key.scale = scale;
+  key.filter = GL_NEAREST;
+
+  cached_id = gsk_gl_driver_get_texture_for_key (self->gl_driver, &key);
 
   if (cached_id != 0)
     {
@@ -658,7 +664,7 @@ render_fallback_node (GskGLRenderer   *self,
   cairo_surface_destroy (surface);
   cairo_surface_destroy (rendered_surface);
 
-  gsk_gl_driver_set_texture_for_pointer (self->gl_driver, node, texture_id);
+  gsk_gl_driver_set_texture_for_key (self->gl_driver, &key, texture_id);
 
   ops_set_program (builder, &self->programs->blit_program);
   ops_set_texture (builder, texture_id);
@@ -1000,6 +1006,38 @@ render_texture_node (GskGLRenderer       *self,
     }
 }
 
+/* Returns TRUE is applying transform to bounds
+ * yields an axis-aligned rectangle
+ */
+static gboolean
+result_is_axis_aligned (GskTransform          *transform,
+                        const graphene_rect_t *bounds)
+{
+  graphene_matrix_t m;
+  graphene_quad_t q;
+  graphene_rect_t b;
+  graphene_point_t b1, b2;
+  const graphene_point_t *p;
+  int i;
+
+  gsk_transform_to_matrix (transform, &m);
+  gsk_matrix_transform_rect (&m, bounds, &q);
+  graphene_quad_bounds (&q, &b);
+  graphene_rect_get_top_left (&b, &b1);
+  graphene_rect_get_bottom_right (&b, &b2);
+
+  for (i = 0; i < 4; i++)
+    {
+      p = graphene_quad_get_point (&q, i);
+      if (fabs (p->x - b1.x) > FLT_EPSILON && fabs (p->x - b2.x) > FLT_EPSILON)
+        return FALSE;
+      if (fabs (p->y - b1.y) > FLT_EPSILON && fabs (p->y - b2.y) > FLT_EPSILON)
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
 static inline void
 render_transform_node (GskGLRenderer   *self,
                        GskRenderNode   *node,
@@ -1035,11 +1073,10 @@ render_transform_node (GskGLRenderer   *self,
       }
     break;
 
-    case GSK_TRANSFORM_CATEGORY_UNKNOWN:
-    case GSK_TRANSFORM_CATEGORY_ANY:
-    case GSK_TRANSFORM_CATEGORY_3D:
     case GSK_TRANSFORM_CATEGORY_2D:
-    default:
+    case GSK_TRANSFORM_CATEGORY_3D:
+    case GSK_TRANSFORM_CATEGORY_ANY:
+    case GSK_TRANSFORM_CATEGORY_UNKNOWN:
       {
         TextureRegion region;
         gboolean is_offscreen;
@@ -1050,29 +1087,42 @@ render_transform_node (GskGLRenderer   *self,
             gsk_gl_renderer_add_render_ops (self, child, builder);
             ops_pop_modelview (builder);
           }
-        else if (add_offscreen_ops (self, builder,
+        else
+          {
+            int filter_flag = 0;
+
+            if (!result_is_axis_aligned (node_transform, &child->bounds))
+              filter_flag = LINEAR_FILTER;
+
+            if (add_offscreen_ops (self, builder,
                                    &child->bounds,
                                    child,
                                    &region, &is_offscreen,
-                                   RESET_CLIP | RESET_OPACITY))
-          {
-            /* For non-trivial transforms, we draw everything on a texture and then
-             * draw the texture transformed. */
-            /* TODO: We should compute a modelview containing only the "non-trivial"
-             *       part (e.g. the rotation) and use that. We want to keep the scale
-             *       for the texture.
-             */
-            ops_push_modelview (builder, node_transform);
-            ops_set_texture (builder, region.texture_id);
-            ops_set_program (builder, &self->programs->blit_program);
+                                   RESET_CLIP | RESET_OPACITY | filter_flag))
+              {
+                /* For non-trivial transforms, we draw everything on a texture and then
+                 * draw the texture transformed. */
+                /* TODO: We should compute a modelview containing only the "non-trivial"
+                 *       part (e.g. the rotation) and use that. We want to keep the scale
+                 *       for the texture.
+                 */
+                ops_push_modelview (builder, node_transform);
+                ops_set_texture (builder, region.texture_id);
+                ops_set_program (builder, &self->programs->blit_program);
 
-            load_vertex_data_with_region (ops_draw (builder, NULL),
-                                          child, builder,
-                                          &region,
-                                          is_offscreen);
-            ops_pop_modelview (builder);
+                load_vertex_data_with_region (ops_draw (builder, NULL),
+                                              child, builder,
+                                              &region,
+                                              is_offscreen);
+                ops_pop_modelview (builder);
+              }
           }
       }
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
     }
 }
 
@@ -1451,10 +1501,12 @@ blur_texture (GskGLRenderer       *self,
 
   gsk_gl_driver_create_render_target (self->gl_driver,
                                       texture_to_blur_width, texture_to_blur_height,
+                                      GL_NEAREST, GL_NEAREST,
                                       &pass1_texture_id, &pass1_render_target);
 
   gsk_gl_driver_create_render_target (self->gl_driver,
                                       texture_to_blur_width, texture_to_blur_height,
+                                      GL_NEAREST, GL_NEAREST,
                                       &pass2_texture_id, &pass2_render_target);
 
   graphene_matrix_init_ortho (&item_proj,
@@ -1591,6 +1643,7 @@ render_blur_node (GskGLRenderer   *self,
   const float blur_radius = gsk_blur_node_get_radius (node);
   GskRenderNode *child = gsk_blur_node_get_child (node);
   TextureRegion blurred_region;
+  GskTextureKey key;
 
   if (node_is_invisible (child))
     return;
@@ -1601,7 +1654,10 @@ render_blur_node (GskGLRenderer   *self,
       return;
     }
 
-  blurred_region.texture_id = gsk_gl_driver_get_texture_for_pointer (self->gl_driver, node);
+  key.pointer = node;
+  key.scale = ops_get_scale (builder);
+  key.filter = GL_NEAREST;
+  blurred_region.texture_id = gsk_gl_driver_get_texture_for_key (self->gl_driver, &key);
   if (blurred_region.texture_id == 0)
     blur_node (self, child, builder, blur_radius, 0, &blurred_region, NULL);
 
@@ -1613,7 +1669,7 @@ render_blur_node (GskGLRenderer   *self,
   load_offscreen_vertex_data (ops_draw (builder, NULL), node, builder); /* Render result to screen */
 
   /* Add to cache for the blur node */
-  gsk_gl_driver_set_texture_for_pointer (self->gl_driver, node, blurred_region.texture_id);
+  gsk_gl_driver_set_texture_for_key (self->gl_driver, &key, blurred_region.texture_id);
 }
 
 static inline void
@@ -1651,13 +1707,17 @@ render_inset_shadow_node (GskGLRenderer   *self,
   float texture_width;
   float texture_height;
   int blurred_texture_id;
+  GskTextureKey key;
 
   g_assert (blur_radius > 0);
 
   texture_width = ceilf ((node_outline->bounds.size.width + blur_extra) * scale);
   texture_height = ceilf ((node_outline->bounds.size.height + blur_extra) * scale);
 
-  blurred_texture_id = gsk_gl_driver_get_texture_for_pointer (self->gl_driver, node);
+  key.pointer = node;
+  key.scale = scale;
+  key.filter = GL_NEAREST;
+  blurred_texture_id = gsk_gl_driver_get_texture_for_key (self->gl_driver, &key);
   if (blurred_texture_id == 0)
     {
       const float spread = gsk_inset_shadow_node_get_spread (node) + (blur_extra / 2.0);
@@ -1696,6 +1756,7 @@ render_inset_shadow_node (GskGLRenderer   *self,
 
       gsk_gl_driver_create_render_target (self->gl_driver,
                                           texture_width, texture_height,
+                                          GL_NEAREST, GL_NEAREST,
                                           &texture_id, &render_target);
 
       graphene_matrix_init_ortho (&item_proj,
@@ -1752,7 +1813,7 @@ render_inset_shadow_node (GskGLRenderer   *self,
     const float ty1 = blur_extra / 2.0 * scale / texture_height;
     const float ty2 = 1.0 - ty1;
 
-    gsk_gl_driver_set_texture_for_pointer (self->gl_driver, node, blurred_texture_id);
+    gsk_gl_driver_set_texture_for_key (self->gl_driver, &key, blurred_texture_id);
 
     if (needs_clip)
       {
@@ -1869,7 +1930,9 @@ render_outset_shadow_node (GskGLRenderer   *self,
       graphene_rect_t prev_viewport;
       graphene_matrix_t item_proj;
 
-      gsk_gl_driver_create_render_target (self->gl_driver, texture_width, texture_height,
+      gsk_gl_driver_create_render_target (self->gl_driver,
+                                          texture_width, texture_height,
+                                          GL_NEAREST, GL_NEAREST,
                                           &texture_id, &render_target);
       if (gdk_gl_context_has_debug (self->gl_context))
         {
@@ -3321,6 +3384,8 @@ gsk_gl_renderer_add_render_ops (GskGLRenderer   *self,
     break;
 
     case GSK_REPEATING_LINEAR_GRADIENT_NODE:
+    case GSK_RADIAL_GRADIENT_NODE:
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
     case GSK_CAIRO_NODE:
     default:
       {
@@ -3349,6 +3414,9 @@ add_offscreen_ops (GskGLRenderer         *self,
   float prev_opacity = 1.0;
   int texture_id = 0;
   int max_texture_size;
+  int filter;
+  GskTextureKey key;
+  int cached_id;
 
   if (node_is_invisible (child_node))
     {
@@ -3370,18 +3438,24 @@ add_offscreen_ops (GskGLRenderer         *self,
       return TRUE;
     }
 
-  /* Check if we've already cached the drawn texture. */
-  {
-    const int cached_id = gsk_gl_driver_get_texture_for_pointer (self->gl_driver, child_node);
+  if (flags & LINEAR_FILTER)
+    filter = GL_LINEAR;
+  else
+    filter = GL_NEAREST;
 
-    if (cached_id != 0)
-      {
-        init_full_texture_region (texture_region_out, cached_id);
-        /* We didn't render it offscreen, but hand out an offscreen texture id */
-        *is_offscreen = TRUE;
-        return TRUE;
-      }
-  }
+  /* Check if we've already cached the drawn texture. */
+  key.pointer = child_node;
+  key.scale = ops_get_scale (builder);
+  key.filter = filter;
+  cached_id = gsk_gl_driver_get_texture_for_key (self->gl_driver, &key);
+
+  if (cached_id != 0)
+    {
+      init_full_texture_region (texture_region_out, cached_id);
+      /* We didn't render it offscreen, but hand out an offscreen texture id */
+      *is_offscreen = TRUE;
+      return TRUE;
+    }
 
   scale = ops_get_scale (builder);
   width = bounds->size.width;
@@ -3401,7 +3475,10 @@ add_offscreen_ops (GskGLRenderer         *self,
   width  = ceilf (width * scale);
   height = ceilf (height * scale);
 
-  gsk_gl_driver_create_render_target (self->gl_driver, width, height, &texture_id, &render_target);
+  gsk_gl_driver_create_render_target (self->gl_driver,
+                                      width, height,
+                                      filter, filter,
+                                      &texture_id, &render_target);
   if (gdk_gl_context_has_debug (self->gl_context))
     {
       gdk_gl_context_label_object_printf (self->gl_context, GL_TEXTURE, texture_id,
@@ -3476,7 +3553,7 @@ add_offscreen_ops (GskGLRenderer         *self,
   init_full_texture_region (texture_region_out, texture_id);
 
   if ((flags & NO_CACHE_PLZ) == 0)
-    gsk_gl_driver_set_texture_for_pointer (self->gl_driver, child_node, texture_id);
+    gsk_gl_driver_set_texture_for_key (self->gl_driver, &key, texture_id);
 
   return TRUE;
 }

gsk/gskenums.h

@@ -30,6 +30,8 @@
  * @GSK_COLOR_NODE: A node drawing a single color rectangle
  * @GSK_LINEAR_GRADIENT_NODE: A node drawing a linear gradient
  * @GSK_REPEATING_LINEAR_GRADIENT_NODE: A node drawing a repeating linear gradient
+ * @GSK_RADIAL_GRADIENT_NODE: A node drawing a radial gradient
+ * @GSK_REPEATING_RADIAL_GRADIENT_NODE: A node drawing a repeating radial gradient
  * @GSK_BORDER_NODE: A node stroking a border around an area
  * @GSK_TEXTURE_NODE: A node drawing a #GdkTexture
  * @GSK_INSET_SHADOW_NODE: A node drawing an inset shadow
@@ -56,6 +58,8 @@ typedef enum {
   GSK_COLOR_NODE,
   GSK_LINEAR_GRADIENT_NODE,
   GSK_REPEATING_LINEAR_GRADIENT_NODE,
+  GSK_RADIAL_GRADIENT_NODE,
+  GSK_REPEATING_RADIAL_GRADIENT_NODE,
   GSK_BORDER_NODE,
   GSK_TEXTURE_NODE,
   GSK_INSET_SHADOW_NODE,

gsk/gskrenderer.c

@@ -510,6 +510,7 @@ get_renderer_for_name (const char *renderer_name)
 #endif
       g_print ("   cairo - Use the Cairo fallback renderer\n");
       g_print ("  opengl - Use the default OpenGL renderer\n");
+      g_print ("      gl - Same as opengl\n");
 #ifdef GDK_RENDERING_VULKAN
       g_print ("  vulkan - Use the Vulkan renderer\n");
 #else
@@ -636,11 +637,10 @@ gsk_renderer_new_for_surface (GdkSurface *surface)
           return renderer;
         }
 
-      GSK_RENDERER_NOTE (renderer, RENDERER,
-          g_message ("Failed to realize renderer of type '%s' for surface '%s': %s\n",
-                   G_OBJECT_TYPE_NAME (renderer),
-                   G_OBJECT_TYPE_NAME (surface),
-                   error->message));
+      g_message ("Failed to realize renderer of type '%s' for surface '%s': %s\n",
+                 G_OBJECT_TYPE_NAME (renderer),
+                 G_OBJECT_TYPE_NAME (surface),
+                 error->message);
       g_object_unref (renderer);
       g_clear_error (&error);
     }

gsk/gskrendernode.h

@@ -104,6 +104,8 @@ GskRenderNode *         gsk_render_node_deserialize             (GBytes
 #define GSK_TYPE_TEXTURE_NODE                   (gsk_texture_node_get_type())
 #define GSK_TYPE_LINEAR_GRADIENT_NODE           (gsk_linear_gradient_node_get_type())
 #define GSK_TYPE_REPEATING_LINEAR_GRADIENT_NODE (gsk_repeating_linear_gradient_node_get_type())
+#define GSK_TYPE_RADIAL_GRADIENT_NODE           (gsk_radial_gradient_node_get_type())
+#define GSK_TYPE_REPEATING_RADIAL_GRADIENT_NODE (gsk_repeating_radial_gradient_node_get_type())
 #define GSK_TYPE_BORDER_NODE                    (gsk_border_node_get_type())
 #define GSK_TYPE_INSET_SHADOW_NODE              (gsk_inset_shadow_node_get_type())
 #define GSK_TYPE_OUTSET_SHADOW_NODE             (gsk_outset_shadow_node_get_type())
@@ -126,6 +128,8 @@ typedef struct _GskColorNode                    GskColorNode;
 typedef struct _GskTextureNode                  GskTextureNode;
 typedef struct _GskLinearGradientNode           GskLinearGradientNode;
 typedef struct _GskRepeatingLinearGradientNode  GskRepeatingLinearGradientNode;
+typedef struct _GskRadialGradientNode           GskRadialGradientNode;
+typedef struct _GskRepeatingRadialGradientNode  GskRepeatingRadialGradientNode;
 typedef struct _GskBorderNode                   GskBorderNode;
 typedef struct _GskInsetShadowNode              GskInsetShadowNode;
 typedef struct _GskOutsetShadowNode             GskOutsetShadowNode;
@@ -196,6 +200,45 @@ GskRenderNode *         gsk_repeating_linear_gradient_node_new      (const graph
                                                                      const GskColorStop       *color_stops,
                                                                      gsize                     n_color_stops);
 
+GDK_AVAILABLE_IN_ALL
+GType                   gsk_radial_gradient_node_get_type (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskRenderNode *         gsk_radial_gradient_node_new      (const graphene_rect_t    *bounds,
+                                                           const graphene_point_t   *center,
+                                                           float                     hradius,
+                                                           float                     vradius,
+                                                           float                     start,
+                                                           float                     end,
+                                                           const GskColorStop       *color_stops,
+                                                           gsize                     n_color_stops);
+GDK_AVAILABLE_IN_ALL
+gsize                   gsk_radial_gradient_node_get_n_color_stops (GskRenderNode *node);
+GDK_AVAILABLE_IN_ALL
+const GskColorStop *    gsk_radial_gradient_node_peek_color_stops  (GskRenderNode *node,
+                                                                    gsize         *n_stops);
+GDK_AVAILABLE_IN_ALL
+const graphene_point_t *gsk_radial_gradient_node_peek_center       (GskRenderNode *node);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_radial_gradient_node_get_hradius       (GskRenderNode *node);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_radial_gradient_node_get_vradius       (GskRenderNode *node);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_radial_gradient_node_get_start         (GskRenderNode *node);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_radial_gradient_node_get_end           (GskRenderNode *node);
+
+GDK_AVAILABLE_IN_ALL
+GType                   gsk_repeating_radial_gradient_node_get_type (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskRenderNode *         gsk_repeating_radial_gradient_node_new      (const graphene_rect_t    *bounds,
+                                                                     const graphene_point_t   *center,
+                                                                     float                     hradius,
+                                                                     float                     vradius,
+                                                                     float                     start,
+                                                                     float                     end,
+                                                                     const GskColorStop       *color_stops,
+                                                                     gsize                     n_color_stops);
+
 GDK_AVAILABLE_IN_ALL
 GType                   gsk_border_node_get_type                (void) G_GNUC_CONST;
 GDK_AVAILABLE_IN_ALL

gsk/gskrendernodeimpl.c

@@ -386,6 +386,261 @@ gsk_linear_gradient_node_peek_color_stops (GskRenderNode *node,
   return self->stops;
 }
 
+/*** GSK_RADIAL_GRADIENT_NODE ***/
+
+struct _GskRadialGradientNode
+{
+  GskRenderNode render_node;
+
+  graphene_point_t center;
+
+  gboolean circle;
+
+  float hradius;
+  float vradius;
+  float start;
+  float end;
+
+  gsize n_stops;
+  GskColorStop *stops;
+};
+
+static void
+gsk_radial_gradient_node_finalize (GskRenderNode *node)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_RADIAL_GRADIENT_NODE));
+
+  g_free (self->stops);
+
+  parent_class->finalize (node);
+}
+
+static void
+gsk_radial_gradient_node_draw (GskRenderNode *node,
+                               cairo_t       *cr)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+  cairo_pattern_t *pattern;
+  cairo_matrix_t matrix;
+  gsize i;
+
+  pattern = cairo_pattern_create_radial (0, 0, self->hradius * self->start,
+                                         0, 0, self->hradius * self->end);
+
+  if (self->hradius != self->vradius)
+    {
+      cairo_matrix_init_scale (&matrix, 1.0, self->hradius / self->vradius);
+      cairo_pattern_set_matrix (pattern, &matrix);
+    }
+
+  if (gsk_render_node_get_node_type (node) == GSK_REPEATING_RADIAL_GRADIENT_NODE)
+    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+  else
+    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+
+  for (i = 0; i < self->n_stops; i++)
+    cairo_pattern_add_color_stop_rgba (pattern,
+                                       self->stops[i].offset,
+                                       self->stops[i].color.red,
+                                       self->stops[i].color.green,
+                                       self->stops[i].color.blue,
+                                       self->stops[i].color.alpha);
+
+  gsk_cairo_rectangle (cr, &node->bounds);
+  cairo_translate (cr, self->center.x, self->center.y);
+  cairo_set_source (cr, pattern);
+  cairo_fill (cr);
+
+  cairo_pattern_destroy (pattern);
+}
+
+static void
+gsk_radial_gradient_node_diff (GskRenderNode  *node1,
+                               GskRenderNode  *node2,
+                               cairo_region_t *region)
+{
+  GskRadialGradientNode *self1 = (GskRadialGradientNode *) node1;
+  GskRadialGradientNode *self2 = (GskRadialGradientNode *) node2;
+
+  if (graphene_point_equal (&self1->center, &self2->center) &&
+      self1->hradius == self2->hradius &&
+      self1->vradius == self2->vradius &&
+      self1->start == self2->start &&
+      self1->end == self2->end &&
+      self1->n_stops == self2->n_stops)
+    {
+      gsize i;
+
+      for (i = 0; i < self1->n_stops; i++)
+        {
+          GskColorStop *stop1 = &self1->stops[i];
+          GskColorStop *stop2 = &self2->stops[i];
+
+          if (stop1->offset == stop2->offset &&
+              gdk_rgba_equal (&stop1->color, &stop2->color))
+            continue;
+
+          gsk_render_node_diff_impossible (node1, node2, region);
+          return;
+        }
+
+      return;
+    }
+
+  gsk_render_node_diff_impossible (node1, node2, region);
+}
+
+GskRenderNode *
+gsk_radial_gradient_node_new (const graphene_rect_t  *bounds,
+                              const graphene_point_t *center,
+                              float                   hradius,
+                              float                   vradius,
+                              float                   start,
+                              float                   end,
+                              const GskColorStop     *color_stops,
+                              gsize                   n_color_stops)
+{
+  GskRadialGradientNode *self;
+  GskRenderNode *node;
+  gsize i;
+
+  g_return_val_if_fail (bounds != NULL, NULL);
+  g_return_val_if_fail (center != NULL, NULL);
+  g_return_val_if_fail (hradius > 0., NULL);
+  g_return_val_if_fail (vradius > 0., NULL);
+  g_return_val_if_fail (start > 0., NULL);
+  g_return_val_if_fail (end > 0., NULL);
+  g_return_val_if_fail (color_stops != NULL, NULL);
+  g_return_val_if_fail (n_color_stops >= 2, NULL);
+  g_return_val_if_fail (color_stops[0].offset >= 0, NULL);
+  for (i = 1; i < n_color_stops; i++)
+    g_return_val_if_fail (color_stops[i].offset >= color_stops[i - 1].offset, NULL);
+  g_return_val_if_fail (color_stops[n_color_stops - 1].offset <= 1, NULL);
+
+  self = gsk_render_node_alloc (GSK_RADIAL_GRADIENT_NODE);
+  node = (GskRenderNode *) self;
+
+  graphene_rect_init_from_rect (&node->bounds, bounds);
+  graphene_point_init_from_point (&self->center, center);
+
+  self->hradius = hradius;
+  self->vradius = vradius;
+  self->start = start;
+  self->end = end;
+
+  self->n_stops = n_color_stops;
+  self->stops = g_malloc_n (n_color_stops, sizeof (GskColorStop));
+  memcpy (self->stops, color_stops, n_color_stops * sizeof (GskColorStop));
+
+  return node;
+}
+
+GskRenderNode *
+gsk_repeating_radial_gradient_node_new (const graphene_rect_t  *bounds,
+                                        const graphene_point_t *center,
+                                        float                   hradius,
+                                        float                   vradius,
+                                        float                   start,
+                                        float                   end,
+                                        const GskColorStop     *color_stops,
+                                        gsize                   n_color_stops)
+{
+  GskRadialGradientNode *self;
+  GskRenderNode *node;
+  gsize i;
+
+  g_return_val_if_fail (bounds != NULL, NULL);
+  g_return_val_if_fail (center != NULL, NULL);
+  g_return_val_if_fail (hradius > 0., NULL);
+  g_return_val_if_fail (vradius > 0., NULL);
+  g_return_val_if_fail (start > 0., NULL);
+  g_return_val_if_fail (end > 0., NULL);
+  g_return_val_if_fail (color_stops != NULL, NULL);
+  g_return_val_if_fail (n_color_stops >= 2, NULL);
+  g_return_val_if_fail (color_stops[0].offset >= 0, NULL);
+  for (i = 1; i < n_color_stops; i++)
+    g_return_val_if_fail (color_stops[i].offset >= color_stops[i - 1].offset, NULL);
+  g_return_val_if_fail (color_stops[n_color_stops - 1].offset <= 1, NULL);
+
+  self = gsk_render_node_alloc (GSK_REPEATING_RADIAL_GRADIENT_NODE);
+  node = (GskRenderNode *) self;
+
+  graphene_rect_init_from_rect (&node->bounds, bounds);
+  graphene_point_init_from_point (&self->center, center);
+
+  self->hradius = hradius;
+  self->vradius = vradius;
+  self->start = start;
+  self->end = end;
+
+  self->n_stops = n_color_stops;
+  self->stops = g_malloc_n (n_color_stops, sizeof (GskColorStop));
+  memcpy (self->stops, color_stops, n_color_stops * sizeof (GskColorStop));
+
+  return node;
+}
+
+gsize
+gsk_radial_gradient_node_get_n_color_stops (GskRenderNode *node)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+
+  return self->n_stops;
+}
+
+const GskColorStop *
+gsk_radial_gradient_node_peek_color_stops (GskRenderNode *node,
+                                           gsize         *n_stops)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+
+  if (n_stops != NULL)
+    *n_stops = self->n_stops;
+
+  return self->stops;
+}
+
+const graphene_point_t *
+gsk_radial_gradient_node_peek_center (GskRenderNode *node)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+
+  return &self->center;
+}
+
+float
+gsk_radial_gradient_node_get_hradius (GskRenderNode *node)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+
+  return self->hradius;
+}
+
+float
+gsk_radial_gradient_node_get_vradius (GskRenderNode *node)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+
+  return self->vradius;
+}
+
+float
+gsk_radial_gradient_node_get_start (GskRenderNode *node)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+
+  return self->start;
+}
+
+float
+gsk_radial_gradient_node_get_end (GskRenderNode *node)
+{
+  GskRadialGradientNode *self = (GskRadialGradientNode *) node;
+
+  return self->end;
+}
+
 /*** GSK_BORDER_NODE ***/
 
 struct _GskBorderNode
@@ -4191,6 +4446,8 @@ GSK_DEFINE_RENDER_NODE_TYPE (gsk_cairo_node, GSK_CAIRO_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_color_node, GSK_COLOR_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_linear_gradient_node, GSK_LINEAR_GRADIENT_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_repeating_linear_gradient_node, GSK_REPEATING_LINEAR_GRADIENT_NODE)
+GSK_DEFINE_RENDER_NODE_TYPE (gsk_radial_gradient_node, GSK_RADIAL_GRADIENT_NODE)
+GSK_DEFINE_RENDER_NODE_TYPE (gsk_repeating_radial_gradient_node, GSK_REPEATING_RADIAL_GRADIENT_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_border_node, GSK_BORDER_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_texture_node, GSK_TEXTURE_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_inset_shadow_node, GSK_INSET_SHADOW_NODE)
@@ -4291,6 +4548,38 @@ gsk_render_node_init_types_once (void)
     gsk_render_node_types[GSK_REPEATING_LINEAR_GRADIENT_NODE] = node_type;
   }
 
+  {
+    const GskRenderNodeTypeInfo node_info =
+    {
+      GSK_RADIAL_GRADIENT_NODE,
+      sizeof (GskRadialGradientNode),
+      NULL,
+      gsk_radial_gradient_node_finalize,
+      gsk_radial_gradient_node_draw,
+      NULL,
+      gsk_radial_gradient_node_diff,
+    };
+
+    GType node_type = gsk_render_node_type_register_static (I_("GskRadialGradientNode"), &node_info);
+    gsk_render_node_types[GSK_RADIAL_GRADIENT_NODE] = node_type;
+  }
+
+  {
+    const GskRenderNodeTypeInfo node_info =
+    {
+      GSK_REPEATING_RADIAL_GRADIENT_NODE,
+      sizeof (GskRadialGradientNode),
+      NULL,
+      gsk_radial_gradient_node_finalize,
+      gsk_radial_gradient_node_draw,
+      NULL,
+      gsk_radial_gradient_node_diff,
+    };
+
+    GType node_type = gsk_render_node_type_register_static (I_("GskRepeatingRadialGradientNode"), &node_info);
+    gsk_render_node_types[GSK_REPEATING_RADIAL_GRADIENT_NODE] = node_type;
+  }
+
   {
     const GskRenderNodeTypeInfo node_info =
     {

gsk/gskrendernodeparser.c

@@ -2003,6 +2003,42 @@ render_node_print (Printer       *p,
       }
       break;
 
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
+    case GSK_RADIAL_GRADIENT_NODE:
+      {
+        const gsize n_stops = gsk_radial_gradient_node_get_n_color_stops (node);
+        const GskColorStop *stops = gsk_radial_gradient_node_peek_color_stops (node, NULL);
+        gsize i;
+
+        if (gsk_render_node_get_node_type (node) == GSK_REPEATING_RADIAL_GRADIENT_NODE)
+          start_node (p, "repeating-radial-gradient");
+        else
+          start_node (p, "radial-gradient");
+
+        append_rect_param (p, "bounds", &node->bounds);
+        append_point_param (p, "center", gsk_radial_gradient_node_peek_center (node));
+        append_float_param (p, "hradius", gsk_radial_gradient_node_get_hradius (node), 0.0f);
+        append_float_param (p, "vradius", gsk_radial_gradient_node_get_vradius (node), 0.0f);
+        append_float_param (p, "start", gsk_radial_gradient_node_get_start (node), 0.0f);
+        append_float_param (p, "end", gsk_radial_gradient_node_get_end (node), 1.0f);
+
+        _indent (p);
+        g_string_append (p->str, "stops: ");
+        for (i = 0; i < n_stops; i ++)
+          {
+            if (i > 0)
+              g_string_append (p->str, ", ");
+
+            string_append_double (p->str, stops[i].offset);
+            g_string_append_c (p->str, ' ');
+            append_rgba (p->str, &stops[i].color);
+          }
+        g_string_append (p->str, ";\n");
+
+        end_node (p);
+      }
+      break;
+
     case GSK_OPACITY_NODE:
       {
         start_node (p, "opacity");

gsk/gsktransform.c

@@ -2204,13 +2204,11 @@ gsk_matrix_transform_point3d (const graphene_matrix_t  *m,
 }
 
 void
-gsk_matrix_transform_bounds (const graphene_matrix_t *m,
-                             const graphene_rect_t   *r,
-                             graphene_rect_t         *res)
+gsk_matrix_transform_rect (const graphene_matrix_t *m,
+                           const graphene_rect_t   *r,
+                           graphene_quad_t         *res)
 {
   graphene_point_t ret[4];
-  float min_x, min_y;
-  float max_x, max_y;
   graphene_rect_t rr;
 
   graphene_rect_normalize_r (r, &rr);
@@ -2233,12 +2231,15 @@ gsk_matrix_transform_bounds (const graphene_matrix_t *m,
 
 #undef TRANSFORM_POINT
 
-  /* FIXME: graphene doesn't export a fast way to do this */
-  min_x = MIN (MIN (ret[0].x, ret[1].x), MIN (ret[2].x, ret[3].x));
-  min_y = MIN (MIN (ret[0].y, ret[1].y), MIN (ret[2].y, ret[3].y));
-
-  max_x = MAX (MAX (ret[0].x, ret[1].x), MAX (ret[2].x, ret[3].x));
-  max_y = MAX (MAX (ret[0].y, ret[1].y), MAX (ret[2].y, ret[3].y));
-
-  graphene_rect_init (res, min_x, min_y, max_x - min_x, max_y - min_y);
+  graphene_quad_init (res, &ret[0], &ret[1], &ret[2], &ret[3]);
+}
+void
+gsk_matrix_transform_bounds (const graphene_matrix_t *m,
+                             const graphene_rect_t   *r,
+                             graphene_rect_t         *res)
+{
+  graphene_quad_t q;
+
+  gsk_matrix_transform_rect (m, r, &q);
+  graphene_quad_bounds (&q, res);
 }

gsk/gsktransformprivate.h

@@ -41,7 +41,9 @@ void gsk_matrix_transform_point3d (const graphene_matrix_t  *m,
 void gsk_matrix_transform_bounds  (const graphene_matrix_t  *m,
                                    const graphene_rect_t    *r,
                                    graphene_rect_t          *res);
-
+void gsk_matrix_transform_rect    (const graphene_matrix_t  *m,
+                                   const graphene_rect_t    *r,
+                                   graphene_quad_t          *res);
 
 G_END_DECLS
 

gsk/vulkan/gskvulkanrenderpass.c

@@ -257,6 +257,8 @@ gsk_vulkan_render_pass_add_node (GskVulkanRenderPass           *self,
       g_assert_not_reached ();
       return;
     case GSK_SHADOW_NODE:
+    case GSK_RADIAL_GRADIENT_NODE:
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
     default:
       FALLBACK ("Unsupported node '%s'", g_type_name_from_instance ((GTypeInstance *) node));
 

gtk/gtk-autocleanups.h

@@ -63,7 +63,6 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkCssProvider, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkDrawingArea, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkEditable, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkEntry, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkEntryBuffer, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkEntryCompletion, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkEventController, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkExpander, g_object_unref)

gtk/gtkaboutdialog.c

@@ -2042,6 +2042,8 @@ text_buffer_new (GtkAboutDialog  *about,
   gtk_text_buffer_get_end_iter (buffer, &end_iter);
   gtk_text_buffer_apply_tag (buffer, tag, &start_iter, &end_iter);
 
+  gtk_text_buffer_set_enable_undo (buffer, FALSE);
+
   return buffer;
 }
 

gtk/gtkcolorchooserwidget.c

@@ -31,6 +31,7 @@
 #include "gtkstylecontext.h"
 #include "gtkboxlayout.h"
 #include "gtkwidgetprivate.h"
+#include "gdkrgbaprivate.h"
 
 #include <math.h>
 
@@ -83,6 +84,8 @@ struct _GtkColorChooserWidget
   gboolean has_default_palette;
 
   GSettings *settings;
+
+  int max_custom;
 };
 
 struct _GtkColorChooserWidgetClass
@@ -294,8 +297,7 @@ add_palette (GtkColorChooserWidget  *cc,
              GtkOrientation          orientation,
              int                     colors_per_line,
              int                     n_colors,
-             GdkRGBA                *colors,
-             const char            **names)
+             GdkRGBA                *colors)
 {
   GtkWidget *grid;
   GtkWidget *p;
@@ -314,7 +316,6 @@ add_palette (GtkColorChooserWidget  *cc,
   gtk_grid_set_row_spacing (GTK_GRID (grid), 2);
   gtk_grid_set_column_spacing (GTK_GRID (grid), 4);
   gtk_box_append (GTK_BOX (cc->palette), grid);
-  
 
   left = 0;
   right = colors_per_line - 1;
@@ -353,6 +354,11 @@ add_palette (GtkColorChooserWidget  *cc,
           gtk_grid_attach (GTK_GRID (grid), p, line, pos, 1, 1);
        }
     }
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    cc->max_custom = MAX (cc->max_custom, colors_per_line);
+  else
+    cc->max_custom = MAX (cc->max_custom, n_colors / colors_per_line);
 }
 
 static void
@@ -363,86 +369,24 @@ remove_default_palette (GtkColorChooserWidget *cc)
 
   remove_palette (cc);
   cc->has_default_palette = FALSE;
+  cc->max_custom = 0;
 }
 
 static void
 add_default_palette (GtkColorChooserWidget *cc)
 {
-  const char *default_colors[9][3] = {
-    { "#ef2929", "#cc0000", "#a40000" }, /* Scarlet Red */
-    { "#fcaf3e", "#f57900", "#ce5c00" }, /* Orange */
-    { "#fce94f", "#edd400", "#c4a000" }, /* Butter */
-    { "#8ae234", "#73d216", "#4e9a06" }, /* Chameleon */
-    { "#729fcf", "#3465a4", "#204a87" }, /* Sky Blue */
-    { "#ad7fa8", "#75507b", "#5c3566" }, /* Plum */
-    { "#e9b96e", "#c17d11", "#8f5902" }, /* Chocolate */
-    { "#888a85", "#555753", "#2e3436" }, /* Aluminum 1 */
-    { "#eeeeec", "#d3d7cf", "#babdb6" }  /* Aluminum 2 */
+  GdkRGBA colors[8*3] = {
+    GDK_RGBA("99c1f1"), GDK_RGBA("3584e4"), GDK_RGBA("1a5fb4"), /* Blue */
+    GDK_RGBA("8ff0a4"), GDK_RGBA("33d17a"), GDK_RGBA("26a269"), /* Green */
+    GDK_RGBA("f9f06b"), GDK_RGBA("f6d32d"), GDK_RGBA("e5a50a"), /* Yellow */
+    GDK_RGBA("ffbe6f"), GDK_RGBA("ff7800"), GDK_RGBA("c64600"), /* Orange */
+    GDK_RGBA("f66151"), GDK_RGBA("e01b24"), GDK_RGBA("a51d2d"), /* Red */
+    GDK_RGBA("dc8add"), GDK_RGBA("9141ac"), GDK_RGBA("613583"), /* Purple */
+    GDK_RGBA("cdab8f"), GDK_RGBA("986a44"), GDK_RGBA("63452c"), /* Brown */
+    GDK_RGBA("f6f5f4"), GDK_RGBA("9a9996"), GDK_RGBA("3d3846")  /* Neutral */
   };
-  const char *color_names[] = {
-    NC_("Color name", "Light Scarlet Red"),
-    NC_("Color name", "Scarlet Red"),
-    NC_("Color name", "Dark Scarlet Red"),
-    NC_("Color name", "Light Orange"),
-    NC_("Color name", "Orange"),
-    NC_("Color name", "Dark Orange"),
-    NC_("Color name", "Light Butter"),
-    NC_("Color name", "Butter"),
-    NC_("Color name", "Dark Butter"),
-    NC_("Color name", "Light Chameleon"),
-    NC_("Color name", "Chameleon"),
-    NC_("Color name", "Dark Chameleon"),
-    NC_("Color name", "Light Sky Blue"),
-    NC_("Color name", "Sky Blue"),
-    NC_("Color name", "Dark Sky Blue"),
-    NC_("Color name", "Light Plum"),
-    NC_("Color name", "Plum"),
-    NC_("Color name", "Dark Plum"),
-    NC_("Color name", "Light Chocolate"),
-    NC_("Color name", "Chocolate"),
-    NC_("Color name", "Dark Chocolate"),
-    NC_("Color name", "Light Aluminum 1"),
-    NC_("Color name", "Aluminum 1"),
-    NC_("Color name", "Dark Aluminum 1"),
-    NC_("Color name", "Light Aluminum 2"),
-    NC_("Color name", "Aluminum 2"),
-    NC_("Color name", "Dark Aluminum 2")
-  };
-  const char *default_grays[9] = {
-    "#000000", /* black */
-    "#2e3436", /* very dark gray */
-    "#555753", /* darker gray */
-    "#888a85", /* dark gray */
-    "#babdb6", /* medium gray */
-    "#d3d7cf", /* light gray */
-    "#eeeeec", /* lighter gray */
-    "#f3f3f3", /* very light gray */
-    "#ffffff"  /* white */
-  };
-  const char *gray_names[] = {
-    NC_("Color name", "Black"),
-    NC_("Color name", "Very Dark Gray"),
-    NC_("Color name", "Darker Gray"),
-    NC_("Color name", "Dark Gray"),
-    NC_("Color name", "Medium Gray"),
-    NC_("Color name", "Light Gray"),
-    NC_("Color name", "Lighter Gray"),
-    NC_("Color name", "Very Light Gray"),
-    NC_("Color name", "White")
-  };
-  GdkRGBA colors[9*3];
-  int i, j;
 
-  for (i = 0; i < 9; i++)
-    for (j = 0; j < 3; j++)
-      gdk_rgba_parse (&colors[i*3 + j], default_colors[i][j]);
-
-  add_palette (cc, GTK_ORIENTATION_VERTICAL, 3, 9*3, colors, color_names);
-
-  for (i = 0; i < 9; i++)
-    gdk_rgba_parse (&colors[i], default_grays[i]);
-
-  add_palette (cc, GTK_ORIENTATION_HORIZONTAL, 9, 9, colors, gray_names);
+  add_palette (cc, GTK_ORIENTATION_VERTICAL, 3, 8*3, colors);
 
   cc->has_default_palette = TRUE;
 }
@@ -730,16 +674,16 @@ add_custom_color (GtkColorChooserWidget *cc,
                   const GdkRGBA         *color)
 {
   GtkWidget *widget;
-  GList *children;
   GtkWidget *p;
+  int n;
 
-  children = NULL;
+  n = 0;
   for (widget = gtk_widget_get_first_child (cc->custom);
        widget != NULL;
        widget = gtk_widget_get_next_sibling (widget))
-    children = g_list_prepend (children, widget);
+    n++;
 
-  if (g_list_length (children) >= 9)
+  while (n >= cc->max_custom)
     {
       GtkWidget *last = gtk_widget_get_last_child (cc->custom);
 
@@ -747,8 +691,8 @@ add_custom_color (GtkColorChooserWidget *cc,
         cc->current = NULL;
 
       gtk_box_remove (GTK_BOX (cc->custom), last);
+      n--;
     }
-  g_list_free (children);
 
   p = gtk_color_swatch_new ();
   gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (p), color);
@@ -807,7 +751,7 @@ gtk_color_chooser_widget_add_palette (GtkColorChooser *chooser,
   GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (chooser);
 
   remove_default_palette (cc);
-  add_palette (cc, orientation, colors_per_line, n_colors, colors, NULL);
+  add_palette (cc, orientation, colors_per_line, n_colors, colors);
 
   gtk_box_reorder_child_after (GTK_BOX (cc->palette), cc->custom_label, gtk_widget_get_last_child (cc->palette));
   gtk_box_reorder_child_after (GTK_BOX (cc->palette), cc->custom, cc->custom_label);
@@ -821,19 +765,3 @@ gtk_color_chooser_widget_iface_init (GtkColorChooserInterface *iface)
   iface->add_palette = gtk_color_chooser_widget_add_palette;
 }
 
-/* Public API {{{1 */
-
-/**
- * gtk_color_chooser_widget_new:
- *
- * Creates a new #GtkColorChooserWidget.
- *
- * Returns: a new #GtkColorChooserWidget
- */
-GtkWidget *
-gtk_color_chooser_widget_new (void)
-{
-  return g_object_new (GTK_TYPE_COLOR_CHOOSER_WIDGET, NULL);
-}
-
-/* vim:set foldmethod=marker: */

gtk/gtkcolumnview.c

@@ -58,10 +58,9 @@
  * separators between the rows or columns.
  *
  * GtkColumnView allows the user to select items according to the selection
- * characteristics of the model. If the provided model is not a #GtkSelectionModel,
- * GtkColumnView will wrap it in a #GtkSingleSelection. For models that allow
- * multiple selected items, it is possible to turn on *rubberband selection*,
- * using #GtkColumnView:enable-rubberband.
+ * characteristics of the model. For models that allow multiple selected items,
+ * it is possible to turn on *rubberband selection*, using
+ * #GtkColumnView:enable-rubberband.
  *
  * The column view supports sorting that can be customized by the user by
  * clicking on column headers. To set this up, the #GtkSorter returned by

gtk/gtkcssimageradial.c

@@ -80,18 +80,13 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
                                double       height)
 {
   GtkCssImageRadial *radial = GTK_CSS_IMAGE_RADIAL (image);
-  cairo_pattern_t *pattern;
-  cairo_matrix_t matrix;
+  GskColorStop *stops;
   double x, y;
-  double radius, yscale;
+  double hradius, vradius;
   double start, end;
   double r1, r2, r3, r4, r;
   double offset;
   int i, last;
-  cairo_t *cr;
-
-  cr = gtk_snapshot_append_cairo (snapshot,
-                                  &GRAPHENE_RECT_INIT (0, 0, width, height));
 
   x = _gtk_css_position_value_get_x (radial->position, width);
   y = _gtk_css_position_value_get_y (radial->position, height);
@@ -101,13 +96,13 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
       switch (radial->size)
         {
         case GTK_CSS_EXPLICIT_SIZE:
-          radius = _gtk_css_number_value_get (radial->sizes[0], width);
+          hradius = _gtk_css_number_value_get (radial->sizes[0], width);
           break;
         case GTK_CSS_CLOSEST_SIDE:
-          radius = MIN (MIN (x, width - x), MIN (y, height - y));
+          hradius = MIN (MIN (x, width - x), MIN (y, height - y));
           break;
         case GTK_CSS_FARTHEST_SIDE:
-          radius = MAX (MAX (x, width - x), MAX (y, height - y));
+          hradius = MAX (MAX (x, width - x), MAX (y, height - y));
           break;
         case GTK_CSS_CLOSEST_CORNER:
         case GTK_CSS_FARTHEST_CORNER:
@@ -119,19 +114,17 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
             r = MIN ( MIN (r1, r2), MIN (r3, r4));
           else
             r = MAX ( MAX (r1, r2), MAX (r3, r4));
-          radius = sqrt (r);
+          hradius = sqrt (r);
           break;
         default:
           g_assert_not_reached ();
         }
 
-      radius = MAX (1.0, radius);
-      yscale = 1.0;
+      hradius = MAX (1.0, hradius);
+      vradius = hradius;
     }
   else
     {
-      double hradius, vradius;
-
       switch (radial->size)
         {
         case GTK_CSS_EXPLICIT_SIZE:
@@ -160,27 +153,14 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
 
       hradius = MAX (1.0, hradius);
       vradius = MAX (1.0, vradius);
-
-      radius = hradius;
-      yscale = vradius / hradius;
     }
 
-  gtk_css_image_radial_get_start_end (radial, radius, &start, &end);
-
-  pattern = cairo_pattern_create_radial (0, 0, radius * start, 0, 0, radius * end);
-  if (yscale != 1.0)
-    {
-      cairo_matrix_init_scale (&matrix, 1.0, 1.0 / yscale);
-      cairo_pattern_set_matrix (pattern, &matrix);
-    }
-
- if (radial->repeating)
-    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
-  else
-    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+  gtk_css_image_radial_get_start_end (radial, hradius, &start, &end);
 
   offset = start;
   last = -1;
+  stops = g_newa (GskColorStop, radial->n_stops);
+
   for (i = 0; i < radial->n_stops; i++)
     {
       const GtkCssImageRadialColorStop *stop = &radial->color_stops[i];
@@ -196,39 +176,44 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
             continue;
         }
       else
-        pos = _gtk_css_number_value_get (stop->offset, radius) / radius;
+        pos = _gtk_css_number_value_get (stop->offset, hradius) / hradius;
 
       pos = MAX (pos, 0);
       step = (pos - offset) / (i - last);
       for (last = last + 1; last <= i; last++)
         {
-          const GdkRGBA *rgba;
-
           stop = &radial->color_stops[last];
 
-          rgba = gtk_css_color_value_get_rgba (stop->color);
           offset += step;
 
-          cairo_pattern_add_color_stop_rgba (pattern,
-                                             (offset - start) / (end - start),
-                                             rgba->red,
-                                             rgba->green,
-                                             rgba->blue,
-                                             rgba->alpha);
+          stops[last].offset = (offset - start) / (end - start);
+          stops[last].color = *gtk_css_color_value_get_rgba (stop->color);
         }
 
       offset = pos;
       last = i;
     }
 
-  cairo_rectangle (cr, 0, 0, width, height);
-  cairo_translate (cr, x, y);
-  cairo_set_source (cr, pattern);
-  cairo_fill (cr);
-
-  cairo_pattern_destroy (pattern);
-
-  cairo_destroy (cr);
+ if (radial->repeating)
+   gtk_snapshot_append_repeating_radial_gradient (snapshot,
+                                                  &GRAPHENE_RECT_INIT (0, 0, width, height),
+                                                  &GRAPHENE_POINT_INIT (x, y),
+                                                  hradius,
+                                                  vradius,
+                                                  start,
+                                                  end,
+                                                  stops,
+                                                  radial->n_stops);
+  else
+    gtk_snapshot_append_radial_gradient (snapshot,
+                                         &GRAPHENE_RECT_INIT (0, 0, width, height),
+                                         &GRAPHENE_POINT_INIT (x, y),
+                                         hradius,
+                                         vradius,
+                                         start,
+                                         end,
+                                         stops,
+                                         radial->n_stops);
 }
 
 static guint

gtk/gtkdropdown.c

@@ -909,7 +909,7 @@ gtk_drop_down_get_enable_search (GtkDropDown *self)
  *
  * Sets the expression that gets evaluated to obtain strings from items
  * when searching in the popup. The expression must have a value type of
- * #GTK_TYPE_STRING.
+ * #G_TYPE_STRING.
  */
 void
 gtk_drop_down_set_expression (GtkDropDown   *self,

gtk/gtkentrybuffer.h

@@ -137,6 +137,8 @@ void                      gtk_entry_buffer_emit_deleted_text      (GtkEntryBuffe
                                                                    guint            position,
                                                                    guint            n_chars);
 
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkEntryBuffer, g_object_unref)
+
 G_END_DECLS
 
 #endif /* __GTK_ENTRY_BUFFER_H__ */

gtk/gtkgridview.c

@@ -55,10 +55,9 @@
  * grid reflows vertically or horizontally.
  *
  * GtkGridView allows the user to select items according to the selection
- * characteristics of the model. If the provided model is not a #GtkSelectionModel,
- * GtkGridView will wrap it in a #GtkSingleSelection. For models that allow
- * multiple selected items, it is possible to turn on _rubberband selection_,
- * using #GtkGridView:enable-rubberband.
+ * characteristics of the model. For models that allow multiple selected items,
+ * it is possible to turn on _rubberband selection_, using
+ * #GtkGridView:enable-rubberband.
  *
  * To learn more about the list widget framework, see the [overview](#ListWidget).
  *

gtk/gtkheaderbar.c

@@ -128,7 +128,7 @@ struct _GtkHeaderBar
   guint show_title_buttons : 1;
   guint track_default_decoration : 1;
 
-  GdkSurfaceState state;
+  GdkToplevelState state;
 };
 
 typedef struct _GtkHeaderBarClass GtkHeaderBarClass;
@@ -609,7 +609,7 @@ gtk_header_bar_init (GtkHeaderBar *bar)
   bar->title_widget = NULL;
   bar->decoration_layout = NULL;
   bar->show_title_buttons = TRUE;
-  bar->state = GDK_SURFACE_STATE_WITHDRAWN;
+  bar->state = GDK_TOPLEVEL_STATE_WITHDRAWN;
 
   bar->handle = gtk_window_handle_new ();
   gtk_widget_set_parent (bar->handle, GTK_WIDGET (bar));

gtk/gtklistview.c

@@ -54,10 +54,9 @@
  * between the rows.
  *
  * GtkListView allows the user to select items according to the selection
- * characteristics of the model. If the provided model is not a #GtkSelectionModel,
- * GtkListView will wrap it in a #GtkSingleSelection. For models that allow
- * multiple selected items, it is possible to turn on _rubberband selection_,
- * using #GtkListView:enable-rubberband.
+ * characteristics of the model. For models that allow multiple selected items,
+ * it is possible to turn on _rubberband selection_, using
+ * #GtkListView:enable-rubberband.
  *
  * If you need multiple columns with headers, see #GtkColumnView.
  *
@@ -95,7 +94,7 @@
  * {
  *   GAppInfo *app_info;
  *
- *   app_info = g_list_model_get_item (gtk_list_view_get_model (list), position);
+ *   app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
  *   g_app_info_launch (app_info, NULL, NULL, NULL);
  *   g_object_unref (app_info);
  * }
@@ -108,7 +107,7 @@
  *   g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
  *   g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
  *
- *   list = gtk_list_view_new (model, factory);
+ *   list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
  *
  *   g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);
  *

gtk/gtkpasswordentry.c

@@ -24,15 +24,16 @@
 
 #include "gtktextprivate.h"
 #include "gtkeditable.h"
+#include "gtkeventcontrollerkey.h"
 #include "gtkgestureclick.h"
 #include "gtkbox.h"
 #include "gtkimage.h"
 #include "gtkintl.h"
-#include "gtkprivate.h"
-#include "gtkwidgetprivate.h"
 #include "gtkmarshalers.h"
+#include "gtkpasswordentrybufferprivate.h"
+#include "gtkprivate.h"
 #include "gtkstylecontext.h"
-#include "gtkeventcontrollerkey.h"
+#include "gtkwidgetprivate.h"
 
 /**
  * SECTION:gtkpasswordentry
@@ -41,7 +42,10 @@
  *
  * #GtkPasswordEntry is entry that has been tailored for entering secrets.
  * It does not show its contents in clear text, does not allow to copy it
- * to the clipboard, and it shows a warning when Caps Lock is engaged.
+ * to the clipboard, and it shows a warning when Caps Lock is engaged. If
+ * the underlying platform allows it, GtkPasswordEntry will also place the
+ * text in a non-pageable memory area, to avoid it being written out to
+ * disk by the operating system.
  *
  * Optionally, it can offer a way to reveal the contents in clear text.
  *
@@ -159,8 +163,10 @@ static void
 gtk_password_entry_init (GtkPasswordEntry *entry)
 {
   GtkPasswordEntryPrivate *priv = gtk_password_entry_get_instance_private (entry);
+  GtkEntryBuffer *buffer = gtk_password_entry_buffer_new ();
 
   priv->entry = gtk_text_new ();
+  gtk_text_set_buffer (GTK_TEXT (priv->entry), buffer);
   gtk_text_set_visibility (GTK_TEXT (priv->entry), FALSE);
   gtk_widget_set_parent (priv->entry, GTK_WIDGET (entry));
   gtk_editable_init_delegate (GTK_EDITABLE (entry));
@@ -175,6 +181,9 @@ gtk_password_entry_init (GtkPasswordEntry *entry)
   gtk_widget_add_css_class (GTK_WIDGET (entry), I_("password"));
 
   gtk_password_entry_set_extra_menu (entry, NULL);
+
+  /* Transfer ownership to the GtkText widget */
+  g_object_unref (buffer);
 }
 
 static void

gtk/gtkpasswordentrybuffer.c

@@ -0,0 +1,203 @@
+/* gtkpasswordentrybuffer.c: Entry buffer with secure allocation 
+ *
+   Copyright 2009  Stefan Walter
+ * Copyright 2020  GNOME Foundation
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gtkpasswordentrybufferprivate.h"
+
+#include "gtksecurememoryprivate.h"
+
+#include <string.h>
+
+/* Initial size of buffer, in bytes */
+#define MIN_SIZE 16
+
+struct _GtkPasswordEntryBuffer
+{
+  GtkEntryBuffer parent_instance;
+
+  char *text;
+  gsize text_size;
+  gsize text_bytes;
+  guint text_chars;
+};
+
+G_DEFINE_TYPE (GtkPasswordEntryBuffer, gtk_password_entry_buffer, GTK_TYPE_ENTRY_BUFFER)
+
+static const char *
+gtk_password_entry_buffer_real_get_text (GtkEntryBuffer *buffer,
+                                       gsize *n_bytes)
+{
+  GtkPasswordEntryBuffer *self = GTK_PASSWORD_ENTRY_BUFFER (buffer);
+
+  if (n_bytes != NULL)
+    *n_bytes = self->text_bytes;
+
+  if (!self->text)
+    return "";
+
+  return self->text;
+}
+
+static guint
+gtk_password_entry_buffer_real_get_length (GtkEntryBuffer *buffer)
+{
+  GtkPasswordEntryBuffer *self = GTK_PASSWORD_ENTRY_BUFFER (buffer);
+  return self->text_chars;
+}
+
+static guint
+gtk_password_entry_buffer_real_insert_text (GtkEntryBuffer *buffer,
+                                            guint           position,
+                                            const char     *chars,
+                                            guint           n_chars)
+{
+  GtkPasswordEntryBuffer *self = GTK_PASSWORD_ENTRY_BUFFER (buffer);
+
+  gsize n_bytes = g_utf8_offset_to_pointer (chars, n_chars) - chars;
+
+  /* Need more memory */
+  if (n_bytes + self->text_bytes + 1 > self->text_size)
+    {
+      /* Calculate our new buffer size */
+      while (n_bytes + self->text_bytes + 1 > self->text_size)
+        {
+          if (self->text_size == 0)
+            {
+              self->text_size = MIN_SIZE;
+            }
+          else
+            {
+              if (2 * self->text_size < GTK_ENTRY_BUFFER_MAX_SIZE)
+                {
+                  self->text_size *= 2;
+                }
+              else
+                {
+                  self->text_size = GTK_ENTRY_BUFFER_MAX_SIZE;
+                  if (n_bytes > self->text_size - self->text_bytes - 1)
+                    {
+                      n_bytes = self->text_size - self->text_bytes - 1;
+                      n_bytes = g_utf8_find_prev_char (chars, chars + n_bytes + 1) - chars;
+                      n_chars = g_utf8_strlen (chars, n_bytes);
+                    }
+                  break;
+                }
+            }
+        }
+
+      self->text = gtk_secure_realloc (self->text, self->text_size);
+    }
+
+  /* Actual text insertion */
+  gsize at = g_utf8_offset_to_pointer (self->text, position) - self->text;
+  memmove (self->text + at + n_bytes, self->text + at, self->text_bytes - at);
+  memcpy (self->text + at, chars, n_bytes);
+
+  /* Book keeping */
+  self->text_bytes += n_bytes;
+  self->text_chars += n_chars;
+  self->text[self->text_bytes] = '\0';
+
+  gtk_entry_buffer_emit_inserted_text (buffer, position, chars, n_chars);
+
+  return n_chars;
+}
+
+static void
+gtk_password_entry_buffer_real_deleted_text (GtkEntryBuffer *buffer,
+                                             guint           position,
+                                             guint           n_chars)
+{
+  GtkPasswordEntryBuffer *self = GTK_PASSWORD_ENTRY_BUFFER (buffer);
+
+  gsize start = g_utf8_offset_to_pointer (self->text, position) - self->text;
+  gsize end = g_utf8_offset_to_pointer (self->text, position + n_chars) - self->text;
+
+  memmove (self->text + start, self->text + end, self->text_bytes + 1 - end);
+  self->text_chars -= n_chars;
+  self->text_bytes -= (end - start);
+}
+
+static guint
+gtk_password_entry_buffer_real_delete_text (GtkEntryBuffer *buffer,
+                                            guint           position,
+                                            guint           n_chars)
+{
+  GtkPasswordEntryBuffer *self = GTK_PASSWORD_ENTRY_BUFFER (buffer);
+
+  if (position > self->text_chars)
+    position = self->text_chars;
+  if (position + n_chars > self->text_chars)
+    n_chars = self->text_chars - position;
+
+  if (n_chars > 0)
+    gtk_entry_buffer_emit_deleted_text (buffer, position, n_chars);
+
+  return n_chars;
+}
+
+static void
+gtk_password_entry_buffer_finalize (GObject *gobject)
+{
+  GtkPasswordEntryBuffer *self = GTK_PASSWORD_ENTRY_BUFFER (gobject);
+
+  g_clear_pointer (&self->text, gtk_secure_free);
+
+  self->text_bytes = 0;
+  self->text_size = 0;
+  self->text_chars = 0;
+
+  G_OBJECT_CLASS (gtk_password_entry_buffer_parent_class)->finalize (gobject);
+}
+
+static void
+gtk_password_entry_buffer_class_init (GtkPasswordEntryBufferClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GtkEntryBufferClass *buffer_class = GTK_ENTRY_BUFFER_CLASS (klass);
+
+  gobject_class->finalize = gtk_password_entry_buffer_finalize;
+
+  buffer_class->get_text = gtk_password_entry_buffer_real_get_text;
+  buffer_class->get_length = gtk_password_entry_buffer_real_get_length;
+  buffer_class->insert_text = gtk_password_entry_buffer_real_insert_text;
+  buffer_class->delete_text = gtk_password_entry_buffer_real_delete_text;
+  buffer_class->deleted_text = gtk_password_entry_buffer_real_deleted_text;
+}
+
+static void
+gtk_password_entry_buffer_init (GtkPasswordEntryBuffer *self)
+{
+}
+
+/*< private >
+ * gtk_password_entry_buffer_new:
+ *
+ * Creates a new #GtkEntryBuffer using secure memory allocations.
+ *
+ * Returns: (transfer full): the newly created instance
+ */
+GtkEntryBuffer *
+gtk_password_entry_buffer_new (void)
+{
+  return g_object_new (GTK_TYPE_PASSWORD_ENTRY_BUFFER, NULL);
+}

gtk/gtkpasswordentrybufferprivate.h

@@ -0,0 +1,33 @@
+/* gtkpasswordentrybufferprivate.h: Entry buffer using secure allocation
+ *
+ * Copyright 2020  GNOME Foundation
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <gtk/gtkentrybuffer.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_PASSWORD_ENTRY_BUFFER (gtk_password_entry_buffer_get_type())
+
+G_DECLARE_FINAL_TYPE (GtkPasswordEntryBuffer, gtk_password_entry_buffer, GTK, PASSWORD_ENTRY_BUFFER, GtkEntryBuffer)
+
+GtkEntryBuffer *        gtk_password_entry_buffer_new   (void);
+
+G_END_DECLS

gtk/gtkrevealer.c

@@ -457,8 +457,6 @@ gtk_revealer_size_allocate (GtkWidget *widget,
       return;
     }
 
-  child_width = width;
-  child_height = height;
   hscale = get_child_size_scale (revealer, GTK_ORIENTATION_HORIZONTAL);
   vscale = get_child_size_scale (revealer, GTK_ORIENTATION_VERTICAL);
   if (hscale <= 0 || vscale <= 0)
@@ -475,29 +473,53 @@ gtk_revealer_size_allocate (GtkWidget *widget,
    * some other form of clipping. We do this by reverse-applying
    * the scale when size allocating the child.
    *
-   * Unfortunately this causes precision issues, because the scaled
-   * size request is always rounded up to an integer.  For instance if
-   * natural with is 100, and scale is 0.001.  we will request a
-   * natural size of ceil(0.1) == 1, but reversing this results in 1 /
-   * 0.001 == 1000 (rather than 100). In the swing case we can get the
-   * scale arbitrarily near 0 causing arbitrary large problems here.
+   * Unfortunately this causes precision issues.
    *
-   * In order to avoid such issue we pick an arbitrary maximum upscale
-   * scale factor of 100. This means that in the case where the allocated
-   * size is 1 we never allocate the child at > 100 px. This means
-   * that in large downscaling cases we may run into the clipping issue
-   * described above. However, at these downscaling levels (100 times!)
-   * we're unlikely to notice much detail anyway.
+   * So we assume that the fully expanded revealer will likely get
+   * an allocation that matches the child's minimum or natural allocation,
+   * so we special-case these two values.
+   * So when - due to the precision loss - multiple sizes would match
+   * the current allocation, we don't pick one at random, we prefer the
+   * min and nat size.
+   *
+   * On top, the scaled size request is always rounded up to an integer.
+   * For instance if natural with is 100, and scale is 0.001, we would
+   * request a natural size of ceil(0.1) == 1, but reversing this would
+   * result in 1 / 0.001 == 1000 (rather than 100).
+   * In the swing case we can get the scale arbitrarily near 0 causing
+   * arbitrary large problems.
+   * These also get avoided by the preference.
    */
 
   if (hscale < 1.0)
     {
+      int min, nat;
       g_assert (vscale == 1.0);
-      child_width = MIN (100*width, ceil (width / hscale));
+      gtk_widget_measure (priv->child, GTK_ORIENTATION_HORIZONTAL, height, &min, &nat, NULL, NULL);
+      if (ceil (nat * hscale) == width)
+        child_width = nat;
+      else if (ceil (min * hscale) == width)
+        child_width = min;
+      else
+        child_width = floor (width / hscale);
+      child_height = height;
     }
   else if (vscale < 1.0)
     {
-      child_height = MIN (100*height, ceil (height / vscale));
+      int min, nat;
+      child_width = width;
+      gtk_widget_measure (priv->child, GTK_ORIENTATION_VERTICAL, width, &min, &nat, NULL, NULL);
+      if (ceil (nat * vscale) == height)
+        child_height = nat;
+      else if (ceil (min * vscale) == height)
+        child_height = min;
+      else
+        child_height = floor (height / vscale);
+    }
+  else
+    {
+      child_width = width;
+      child_height = height;
     }
 
   transform = NULL;

gtk/gtksearchentry.c

@@ -593,9 +593,9 @@ capture_widget_key_handled (GtkEventControllerKey *controller,
 
   handled = gtk_event_controller_key_forward (controller, entry->entry);
 
-  if (handled && entry->content_changed && !entry->search_stopped)
+  if (handled)
     {
-      if (was_empty)
+      if (was_empty && entry->content_changed && !entry->search_stopped)
         g_signal_emit (entry, signals[SEARCH_STARTED], 0);
 
       return GDK_EVENT_STOP;

gtk/gtksecurememoryprivate.h

@@ -0,0 +1,95 @@
+/* gtksecurememoryprivate.h - Allocator for non-pageable memory
+
+   Copyright 2007  Stefan Walter
+   Copyright 2020  GNOME Foundation
+
+   SPDX-License-Identifier: LGPL-2.0-or-later
+
+   The Gnome Keyring Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The Gnome Keyring Library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the Gnome Library; see the file COPYING.LIB.  If not,
+   see <http://www.gnu.org/licenses/>.
+
+   Author: Stef Walter <stef@memberwebs.com>
+*/
+
+#pragma once
+
+#include <stdlib.h>
+
+/*
+ * Main functionality
+ *
+ * Allocations return NULL on failure.
+ */
+
+#define GTK_SECURE_USE_FALLBACK     0x0001
+
+void *          gtk_secure_alloc_full   (const char *tag,
+                                         size_t length,
+                                         int options);
+
+void *          gtk_secure_realloc_full (const char *tag,
+                                         void *p,
+                                         size_t length,
+                                         int options);
+
+void            gtk_secure_free         (void *p);
+
+void            gtk_secure_free_full    (void *p,
+                                         int fallback);
+
+void            gtk_secure_clear        (void *p,
+                                         size_t length);
+
+int             gtk_secure_check        (const void *p);
+
+void            gtk_secure_validate     (void);
+
+char *          gtk_secure_strdup_full  (const char *tag,
+                                         const char *str,
+                                         int options);
+
+char *          gtk_secure_strndup_full (const char *tag,
+                                         const char *str,
+                                         size_t length,
+                                         int options);
+
+void            gtk_secure_strclear     (char *str);
+
+void            gtk_secure_strfree      (char *str);
+
+/* Simple wrappers */
+
+static inline void *gtk_secure_alloc (size_t length) {
+  return gtk_secure_alloc_full ("gtk", length, GTK_SECURE_USE_FALLBACK);
+}
+
+static inline void *gtk_secure_realloc (void *p, size_t length) {
+  return gtk_secure_realloc_full ("gtk", p, length, GTK_SECURE_USE_FALLBACK);
+}
+
+static inline void *gtk_secure_strdup (const char *str) {
+  return gtk_secure_strdup_full ("gtk", str, GTK_SECURE_USE_FALLBACK);
+}
+
+static inline void *gtk_secure_strndup (const char *str, size_t length) {
+  return gtk_secure_strndup_full ("gtk", str, length, GTK_SECURE_USE_FALLBACK);
+}
+
+typedef struct {
+  const char *tag;
+  size_t request_length;
+  size_t block_length;
+} gtk_secure_rec;
+
+gtk_secure_rec *   gtk_secure_records    (unsigned int *count);

gtk/gtksnapshot.c

@@ -1967,6 +1967,82 @@ gtk_snapshot_append_repeating_linear_gradient (GtkSnapshot            *snapshot,
   gtk_snapshot_append_node_internal (snapshot, node);
 }
 
+void
+gtk_snapshot_append_radial_gradient (GtkSnapshot            *snapshot,
+                                     const graphene_rect_t  *bounds,
+                                     const graphene_point_t *center,
+                                     float                   hradius,
+                                     float                   vradius,
+                                     float                   start,
+                                     float                   end,
+                                     const GskColorStop     *stops,
+                                     gsize                   n_stops)
+{
+  GskRenderNode *node;
+  graphene_rect_t real_bounds;
+  graphene_point_t real_center;
+  float scale_x, scale_y, dx, dy;
+
+  g_return_if_fail (snapshot != NULL);
+  g_return_if_fail (center != NULL);
+  g_return_if_fail (stops != NULL);
+  g_return_if_fail (n_stops > 1);
+
+  gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
+  gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
+  real_center.x = scale_x * center->x + dx;
+  real_center.y = scale_y * center->y + dy;
+
+  node = gsk_radial_gradient_node_new (&real_bounds,
+                                       &real_center,
+                                       hradius * scale_x,
+                                       vradius * scale_y,
+                                       start,
+                                       end,
+                                       stops,
+                                       n_stops);
+
+  gtk_snapshot_append_node_internal (snapshot, node);
+}
+
+void
+gtk_snapshot_append_repeating_radial_gradient (GtkSnapshot            *snapshot,
+                                               const graphene_rect_t  *bounds,
+                                               const graphene_point_t *center,
+                                               float                   hradius,
+                                               float                   vradius,
+                                               float                   start,
+                                               float                   end,
+                                               const GskColorStop     *stops,
+                                               gsize                   n_stops)
+{
+  GskRenderNode *node;
+  graphene_rect_t real_bounds;
+  graphene_point_t real_center;
+  float scale_x, scale_y, dx, dy;
+
+  g_return_if_fail (snapshot != NULL);
+  g_return_if_fail (center != NULL);
+  g_return_if_fail (stops != NULL);
+  g_return_if_fail (n_stops > 1);
+
+  gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
+  gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
+  real_center.x = scale_x * center->x + dx;
+  real_center.y = scale_y * center->y + dy;
+
+  node = gsk_repeating_radial_gradient_node_new (&real_bounds,
+                                                 &real_center,
+                                                 hradius * scale_x,
+                                                 vradius * scale_y,
+                                                 start,
+                                                 end,
+                                                 stops,
+                                                 n_stops);
+
+  gtk_snapshot_append_node_internal (snapshot, node);
+}
+
 /**
  * gtk_snapshot_append_border:
  * @snapshot: a #GtkSnapshot

gtk/gtksnapshot.h

@@ -165,6 +165,26 @@ void            gtk_snapshot_append_repeating_linear_gradient (GtkSnapshot
                                                                const GskColorStop     *stops,
                                                                gsize                   n_stops);
 GDK_AVAILABLE_IN_ALL
+void            gtk_snapshot_append_radial_gradient     (GtkSnapshot            *snapshot,
+                                                         const graphene_rect_t  *bounds,
+                                                         const graphene_point_t *center,
+                                                         float                   hradius,
+                                                         float                   vradius,
+                                                         float                   start,
+                                                         float                   end,
+                                                         const GskColorStop     *stops,
+                                                         gsize                   n_stops);
+GDK_AVAILABLE_IN_ALL
+void            gtk_snapshot_append_repeating_radial_gradient (GtkSnapshot            *snapshot,
+                                                               const graphene_rect_t  *bounds,
+                                                               const graphene_point_t *center,
+                                                               float                   hradius,
+                                                               float                   vradius,
+                                                               float                   start,
+                                                               float                   end,
+                                                               const GskColorStop     *stops,
+                                                               gsize                   n_stops);
+GDK_AVAILABLE_IN_ALL
 void            gtk_snapshot_append_border              (GtkSnapshot            *snapshot,
                                                          const GskRoundedRect   *outline,
                                                          const float             border_width[4],

gtk/gtktext.c

@@ -2910,6 +2910,16 @@ dnd_finished_cb (GdkDrag *drag,
   priv->drag = NULL;
 }
 
+static void
+dnd_cancel_cb (GdkDrag             *drag,
+               GdkDragCancelReason  reason,
+               GtkText             *self)
+{
+  GtkTextPrivate *priv = gtk_text_get_instance_private (self);
+
+  priv->drag = NULL;
+}
+
 static void
 gtk_text_drag_gesture_update (GtkGestureDrag *gesture,
                               double          offset_x,
@@ -2973,9 +2983,12 @@ gtk_text_drag_gesture_update (GtkGestureDrag *gesture,
           g_object_unref (content);
 
           g_signal_connect (drag, "dnd-finished", G_CALLBACK (dnd_finished_cb), self);
+          g_signal_connect (drag, "cancel", G_CALLBACK (dnd_cancel_cb), self);
 
           paintable = gtk_text_util_create_drag_icon (widget, text, -1);
-          gtk_drag_icon_set_from_paintable (drag, paintable, ranges[0], 0);
+          gtk_drag_icon_set_from_paintable (drag, paintable,
+                                            (priv->drag_start_x - ranges[0]),
+                                            priv->drag_start_y);
           g_clear_object (&paintable);
 
           priv->drag = drag;
@@ -2986,6 +2999,9 @@ gtk_text_drag_gesture_update (GtkGestureDrag *gesture,
           g_free (text);
 
           priv->in_drag = FALSE;
+
+          /* Deny the gesture so we don't get further updates */
+          gtk_gesture_set_state (priv->drag_gesture, GTK_EVENT_SEQUENCE_DENIED);
         }
     }
   else

gtk/gtktexthistory.c

@@ -1037,6 +1037,8 @@ gtk_text_history_set_enabled (GtkTextHistory *self,
           clear_action_queue (&self->undo_queue);
           clear_action_queue (&self->redo_queue);
         }
+
+      gtk_text_history_update_state (self);
     }
 }
 

gtk/gtktextlayout.c

@@ -964,7 +964,7 @@ gtk_text_layout_validate_yrange (GtkTextLayout *layout,
     y0 = 0;
   if (y1 < 0)
     y1 = 0;
-  
+
   /* Validate backwards from the anchor line to y0
    */
   line = _gtk_text_iter_get_text_line (anchor);
@@ -4138,6 +4138,8 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
   GtkStyleContext *context;
   int offset_y;
   GtkTextIter selection_start, selection_end;
+  int selection_start_line;
+  int selection_end_line;
   gboolean have_selection;
   GSList *line_list;
   GSList *tmp_list;
@@ -4173,6 +4175,16 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
   have_selection = gtk_text_buffer_get_selection_bounds (layout->buffer,
                                                          &selection_start,
                                                          &selection_end);
+  if (have_selection)
+    {
+      selection_start_line = gtk_text_iter_get_line (&selection_start);
+      selection_end_line = gtk_text_iter_get_line (&selection_end);
+    }
+  else
+    {
+      selection_start_line = -1;
+      selection_end_line = -1;
+    }
 
   tmp_list = line_list;
   while (tmp_list != NULL)
@@ -4190,34 +4202,43 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
 
           if (have_selection)
             {
-              GtkTextIter line_start, line_end;
-              int byte_count;
+              GtkTextIter line_start;
+              int current_line;
 
               gtk_text_layout_get_iter_at_line (layout, &line_start, line, 0);
-              line_end = line_start;
-              if (!gtk_text_iter_ends_line (&line_end))
-                gtk_text_iter_forward_to_line_end (&line_end);
-              byte_count = gtk_text_iter_get_visible_line_index (&line_end);
+              current_line = gtk_text_iter_get_line (&line_start);
 
-              if (gtk_text_iter_compare (&selection_start, &line_end) <= 0 &&
-                  gtk_text_iter_compare (&selection_end, &line_start) >= 0)
+              if (selection_start_line < current_line)
+                selection_start_index = -1;
+              else if (selection_start_line == current_line)
+                selection_start_index = gtk_text_iter_get_visible_line_index (&selection_start);
+              else
+                selection_start_index = -1;
+
+              if (selection_end_line < current_line)
                 {
-                  if (gtk_text_iter_compare (&selection_start, &line_start) >= 0)
-                    selection_start_index = gtk_text_iter_get_visible_line_index (&selection_start);
-                  else
-                    selection_start_index = -1;
-
-                  if (gtk_text_iter_compare (&selection_end, &line_end) <= 0)
-                    selection_end_index = gtk_text_iter_get_visible_line_index (&selection_end);
-                  else
-                    selection_end_index = byte_count + 1; /* + 1 to flag past-the-end */
+                  selection_end_index = -1;
+                  have_selection = FALSE;
                 }
+              else if (selection_end_line == current_line)
+                selection_end_index = gtk_text_iter_get_visible_line_index (&selection_end);
+              else if (selection_start_line <= current_line)
+                {
+                  GtkTextIter line_end = line_start;
+                  int byte_count;
+
+                  if (!gtk_text_iter_ends_line (&line_end))
+                    gtk_text_iter_forward_to_line_end (&line_end);
+                  byte_count = gtk_text_iter_get_visible_line_index (&line_end);
+                  selection_end_index = byte_count + 1; /* + 1 to flag past-the-end */
+                }
+              else
+                selection_end_index = -1;
             }
 
           if (line_display->node == NULL)
             {
               gtk_snapshot_push_collect (snapshot);
-
               render_para (crenderer, 0, line_display,
                            selection_start_index, selection_end_index,
                            cursor_alpha);

gtk/gtktextview.c

@@ -7188,11 +7188,11 @@ selection_data_free (SelectionData *data)
 
 static gboolean
 drag_gesture_get_text_surface_coords (GtkGestureDrag *gesture,
-                                     GtkTextView    *text_view,
-                                     int            *start_x,
-                                     int            *start_y,
-                                     int            *x,
-                                     int            *y)
+                                      GtkTextView    *text_view,
+                                      int            *start_x,
+                                      int            *start_y,
+                                      int            *x,
+                                      int            *y)
 {
   double sx, sy, ox, oy;
 
@@ -7262,6 +7262,10 @@ gtk_text_view_drag_gesture_update (GtkGestureDrag *gesture,
 
               gtk_text_view_start_selection_dnd (text_view, &iter, event,
                                                  start_x, start_y);
+
+              /* Deny the gesture so we don't get further updates */
+              gtk_gesture_set_state (text_view->priv->drag_gesture,
+                                     GTK_EVENT_SEQUENCE_DENIED);
               return;
             }
           else
@@ -7275,6 +7279,8 @@ gtk_text_view_drag_gesture_update (GtkGestureDrag *gesture,
         return;
     }
 
+  g_assert (data != NULL);
+
   /* Text selection */
   if (data->granularity == SELECT_CHARACTERS)
     {
@@ -7782,6 +7788,14 @@ dnd_finished_cb (GdkDrag     *drag,
   self->priv->drag = NULL;
 }
 
+static void
+dnd_cancel_cb (GdkDrag *drag,
+               GdkDragCancelReason reason,
+               GtkTextView *self)
+{
+  self->priv->drag = NULL;
+}
+
 static void
 gtk_text_view_start_selection_dnd (GtkTextView       *text_view,
                                    const GtkTextIter *iter,
@@ -7808,9 +7822,11 @@ gtk_text_view_start_selection_dnd (GtkTextView       *text_view,
   surface = gdk_event_get_surface (event);
   device = gdk_event_get_device (event);
   drag = gdk_drag_begin (surface, device, content, actions, x, y);
+
   g_object_unref (content);
 
   g_signal_connect (drag, "dnd-finished", G_CALLBACK (dnd_finished_cb), text_view);
+  g_signal_connect (drag, "cancel", G_CALLBACK (dnd_cancel_cb), text_view);
 
   if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
     {

gtk/gtktooltipwindow.c

@@ -47,7 +47,7 @@ struct _GtkTooltipWindow
   GdkSurface *surface;
   GskRenderer *renderer;
 
-  GdkSurfaceState state;
+  GdkToplevelState state;
   GtkWidget *relative_to;
   GdkRectangle rect;
   GdkGravity rect_anchor;
@@ -173,16 +173,16 @@ static void
 surface_state_changed (GtkWidget *widget)
 {
   GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
-  GdkSurfaceState new_surface_state;
-  GdkSurfaceState changed_mask;
+  GdkToplevelState new_surface_state;
+  GdkToplevelState changed_mask;
 
   new_surface_state = gdk_toplevel_get_state (GDK_TOPLEVEL (window->surface));
   changed_mask = new_surface_state ^ window->state;
   window->state = new_surface_state;
 
-  if (changed_mask & GDK_SURFACE_STATE_WITHDRAWN)
+  if (changed_mask & GDK_TOPLEVEL_STATE_WITHDRAWN)
     {
-      if (window->state & GDK_SURFACE_STATE_WITHDRAWN)
+      if (window->state & GDK_TOPLEVEL_STATE_WITHDRAWN)
         gtk_widget_hide (widget);
     }
 }

gtk/gtkwidget.c

@@ -3785,6 +3785,28 @@ gtk_widget_allocate (GtkWidget    *widget,
                  "How does the code know the size to allocate?",
                  gtk_widget_get_name (widget), widget);
     }
+  if (!GTK_IS_SCROLLABLE (widget))
+    {
+      int min;
+      gtk_widget_measure (widget, GTK_ORIENTATION_VERTICAL, width, &min, NULL, NULL, NULL);
+      if (min > height)
+        {
+          g_critical ("Allocation height too small. Tried to allocate %dx%d, but %s %p needs "
+                      "at least %dx%d.",
+                      width, height,
+                      gtk_widget_get_name (widget), widget,
+                      width, min);
+        }
+      gtk_widget_measure (widget, GTK_ORIENTATION_HORIZONTAL, height, &min, NULL, NULL, NULL);
+      if (min > width)
+        {
+          g_critical ("Allocation width too small. Tried to allocate %dx%d, but %s %p needs "
+                      "at least %dx%d.",
+                      width, height,
+                      gtk_widget_get_name (widget), widget,
+                      min, height);
+        }
+    }
 #endif /* G_ENABLE_DEBUG */
 
   alloc_needed = priv->alloc_needed;

gtk/gtkwindow.c

@@ -191,7 +191,7 @@ typedef struct
   GdkMonitor *initial_fullscreen_monitor;
   guint      edge_constraints;
 
-  GdkSurfaceState state;
+  GdkToplevelState state;
 
   /* The following flags are initially TRUE (before a window is mapped).
    * They cause us to compute a configure request that involves
@@ -1164,21 +1164,21 @@ constraints_for_edge (GdkSurfaceEdge edge)
   switch (edge)
     {
     case GDK_SURFACE_EDGE_NORTH_WEST:
-      return GDK_SURFACE_STATE_LEFT_RESIZABLE | GDK_SURFACE_STATE_TOP_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_LEFT_RESIZABLE | GDK_TOPLEVEL_STATE_TOP_RESIZABLE;
     case GDK_SURFACE_EDGE_NORTH:
-      return GDK_SURFACE_STATE_TOP_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_TOP_RESIZABLE;
     case GDK_SURFACE_EDGE_NORTH_EAST:
-      return GDK_SURFACE_STATE_RIGHT_RESIZABLE | GDK_SURFACE_STATE_TOP_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE | GDK_TOPLEVEL_STATE_TOP_RESIZABLE;
     case GDK_SURFACE_EDGE_WEST:
-      return GDK_SURFACE_STATE_LEFT_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_LEFT_RESIZABLE;
     case GDK_SURFACE_EDGE_EAST:
-      return GDK_SURFACE_STATE_RIGHT_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE;
     case GDK_SURFACE_EDGE_SOUTH_WEST:
-      return GDK_SURFACE_STATE_LEFT_RESIZABLE | GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_LEFT_RESIZABLE | GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;
     case GDK_SURFACE_EDGE_SOUTH:
-      return GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;
     case GDK_SURFACE_EDGE_SOUTH_EAST:
-      return GDK_SURFACE_STATE_RIGHT_RESIZABLE | GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
+      return GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE | GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;
     default:
       g_warn_if_reached ();
       return 0;
@@ -1474,7 +1474,7 @@ gtk_window_init (GtkWindow *window)
   priv->decorated = TRUE;
   priv->display = gdk_display_get_default ();
 
-  priv->state = GDK_SURFACE_STATE_WITHDRAWN;
+  priv->state = GDK_TOPLEVEL_STATE_WITHDRAWN;
 
   priv->deletable = TRUE;
   priv->startup_id = NULL;
@@ -3905,7 +3905,7 @@ gtk_window_unmap (GtkWidget *widget)
   GtkWindow *window = GTK_WINDOW (widget);
   GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
   GtkWidget *child = priv->child;
-  GdkSurfaceState state;
+  GdkToplevelState state;
 
   GTK_WIDGET_CLASS (gtk_window_parent_class)->unmap (widget);
   gdk_surface_hide (priv->surface);
@@ -3918,8 +3918,8 @@ gtk_window_unmap (GtkWidget *widget)
   priv->configure_notify_received = FALSE;
 
   state = gdk_toplevel_get_state (GDK_TOPLEVEL (priv->surface));
-  priv->minimize_initially = (state & GDK_SURFACE_STATE_MINIMIZED) != 0;
-  priv->maximize_initially = (state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
+  priv->minimize_initially = (state & GDK_TOPLEVEL_STATE_MINIMIZED) != 0;
+  priv->maximize_initially = (state & GDK_TOPLEVEL_STATE_MAXIMIZED) != 0;
 
   if (priv->title_box != NULL)
     gtk_widget_unmap (priv->title_box);
@@ -4528,22 +4528,22 @@ update_window_style_classes (GtkWindow *window)
     }
   else
     {
-      if (edge_constraints & GDK_SURFACE_STATE_TOP_TILED)
+      if (edge_constraints & GDK_TOPLEVEL_STATE_TOP_TILED)
         gtk_widget_add_css_class (widget, "tiled-top");
       else
         gtk_widget_remove_css_class (widget, "tiled-top");
 
-      if (edge_constraints & GDK_SURFACE_STATE_RIGHT_TILED)
+      if (edge_constraints & GDK_TOPLEVEL_STATE_RIGHT_TILED)
         gtk_widget_add_css_class (widget, "tiled-right");
       else
         gtk_widget_remove_css_class (widget, "tiled-right");
 
-      if (edge_constraints & GDK_SURFACE_STATE_BOTTOM_TILED)
+      if (edge_constraints & GDK_TOPLEVEL_STATE_BOTTOM_TILED)
         gtk_widget_add_css_class (widget, "tiled-bottom");
       else
         gtk_widget_remove_css_class (widget, "tiled-bottom");
 
-      if (edge_constraints & GDK_SURFACE_STATE_LEFT_TILED)
+      if (edge_constraints & GDK_TOPLEVEL_STATE_LEFT_TILED)
         gtk_widget_add_css_class (widget, "tiled-left");
       else
         gtk_widget_remove_css_class (widget, "tiled-left");
@@ -4656,20 +4656,20 @@ gtk_window_size_allocate (GtkWidget *widget,
 
 static void
 update_edge_constraints (GtkWindow      *window,
-                         GdkSurfaceState  state)
+                         GdkToplevelState  state)
 {
   GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
 
-  priv->edge_constraints = (state & GDK_SURFACE_STATE_TOP_TILED) |
-                           (state & GDK_SURFACE_STATE_TOP_RESIZABLE) |
-                           (state & GDK_SURFACE_STATE_RIGHT_TILED) |
-                           (state & GDK_SURFACE_STATE_RIGHT_RESIZABLE) |
-                           (state & GDK_SURFACE_STATE_BOTTOM_TILED) |
-                           (state & GDK_SURFACE_STATE_BOTTOM_RESIZABLE) |
-                           (state & GDK_SURFACE_STATE_LEFT_TILED) |
-                           (state & GDK_SURFACE_STATE_LEFT_RESIZABLE);
+  priv->edge_constraints = (state & GDK_TOPLEVEL_STATE_TOP_TILED) |
+                           (state & GDK_TOPLEVEL_STATE_TOP_RESIZABLE) |
+                           (state & GDK_TOPLEVEL_STATE_RIGHT_TILED) |
+                           (state & GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE) |
+                           (state & GDK_TOPLEVEL_STATE_BOTTOM_TILED) |
+                           (state & GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE) |
+                           (state & GDK_TOPLEVEL_STATE_LEFT_TILED) |
+                           (state & GDK_TOPLEVEL_STATE_LEFT_RESIZABLE);
 
-  priv->tiled = (state & GDK_SURFACE_STATE_TILED) ? 1 : 0;
+  priv->tiled = (state & GDK_TOPLEVEL_STATE_TILED) ? 1 : 0;
 }
 
 static void
@@ -4677,16 +4677,16 @@ surface_state_changed (GtkWidget *widget)
 {
   GtkWindow *window = GTK_WINDOW (widget);
   GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
-  GdkSurfaceState new_surface_state;
-  GdkSurfaceState changed_mask;
+  GdkToplevelState new_surface_state;
+  GdkToplevelState changed_mask;
 
   new_surface_state = gdk_toplevel_get_state (GDK_TOPLEVEL (priv->surface));
   changed_mask = new_surface_state ^ priv->state;
   priv->state = new_surface_state;
 
-  if (changed_mask & GDK_SURFACE_STATE_FOCUSED)
+  if (changed_mask & GDK_TOPLEVEL_STATE_FOCUSED)
     {
-      gboolean focused = new_surface_state & GDK_SURFACE_STATE_FOCUSED;
+      gboolean focused = new_surface_state & GDK_TOPLEVEL_STATE_FOCUSED;
 
       ensure_state_flag_backdrop (widget);
 
@@ -4694,25 +4694,25 @@ surface_state_changed (GtkWidget *widget)
         gtk_window_set_mnemonics_visible (window, FALSE);
     }
 
-  if (changed_mask & GDK_SURFACE_STATE_FULLSCREEN)
-    priv->fullscreen = (new_surface_state & GDK_SURFACE_STATE_FULLSCREEN) ? TRUE : FALSE;
+  if (changed_mask & GDK_TOPLEVEL_STATE_FULLSCREEN)
+    priv->fullscreen = (new_surface_state & GDK_TOPLEVEL_STATE_FULLSCREEN) ? TRUE : FALSE;
 
-  if (changed_mask & GDK_SURFACE_STATE_MAXIMIZED)
+  if (changed_mask & GDK_TOPLEVEL_STATE_MAXIMIZED)
     {
-      priv->maximized = (new_surface_state & GDK_SURFACE_STATE_MAXIMIZED) ? TRUE : FALSE;
+      priv->maximized = (new_surface_state & GDK_TOPLEVEL_STATE_MAXIMIZED) ? TRUE : FALSE;
       g_object_notify_by_pspec (G_OBJECT (widget), window_props[PROP_IS_MAXIMIZED]);
     }
 
   update_edge_constraints (window, new_surface_state);
 
-  if (changed_mask & (GDK_SURFACE_STATE_FULLSCREEN |
-                      GDK_SURFACE_STATE_MAXIMIZED |
-                      GDK_SURFACE_STATE_TILED |
-                      GDK_SURFACE_STATE_TOP_TILED |
-                      GDK_SURFACE_STATE_RIGHT_TILED |
-                      GDK_SURFACE_STATE_BOTTOM_TILED |
-                      GDK_SURFACE_STATE_LEFT_TILED |
-                      GDK_SURFACE_STATE_MINIMIZED))
+  if (changed_mask & (GDK_TOPLEVEL_STATE_FULLSCREEN |
+                      GDK_TOPLEVEL_STATE_MAXIMIZED |
+                      GDK_TOPLEVEL_STATE_TILED |
+                      GDK_TOPLEVEL_STATE_TOP_TILED |
+                      GDK_TOPLEVEL_STATE_RIGHT_TILED |
+                      GDK_TOPLEVEL_STATE_BOTTOM_TILED |
+                      GDK_TOPLEVEL_STATE_LEFT_TILED |
+                      GDK_TOPLEVEL_STATE_MINIMIZED))
     {
       update_window_style_classes (window);
       update_window_actions (window);
@@ -6563,7 +6563,7 @@ ensure_state_flag_backdrop (GtkWidget *widget)
   GtkWindowPrivate *priv = gtk_window_get_instance_private (GTK_WINDOW (widget));
   gboolean surface_focused = TRUE;
 
-  surface_focused = gdk_toplevel_get_state (GDK_TOPLEVEL (priv->surface)) & GDK_SURFACE_STATE_FOCUSED;
+  surface_focused = gdk_toplevel_get_state (GDK_TOPLEVEL (priv->surface)) & GDK_TOPLEVEL_STATE_FOCUSED;
 
   if (!surface_focused)
     gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_BACKDROP, FALSE);

gtk/inspector/general.c

@@ -817,6 +817,13 @@ add_seat (GtkInspectorGeneral *gen,
   g_list_free (list);
 }
 
+static void
+disconnect_seat (GtkInspectorGeneral *gen,
+                 GdkSeat             *seat)
+{
+  g_signal_handlers_disconnect_by_func (seat, G_CALLBACK (populate_seats), gen);
+}
+
 static void
 populate_seats (GtkInspectorGeneral *gen)
 {
@@ -835,11 +842,28 @@ populate_seats (GtkInspectorGeneral *gen)
   g_list_free (list);
 }
 
+static void
+seat_added (GdkDisplay          *display,
+            GdkSeat             *seat,
+            GtkInspectorGeneral *gen)
+{
+  populate_seats (gen);
+}
+
+static void
+seat_removed (GdkDisplay          *display,
+              GdkSeat             *seat,
+              GtkInspectorGeneral *gen)
+{
+  disconnect_seat (gen, seat);
+  populate_seats (gen);
+}
+
 static void
 init_device (GtkInspectorGeneral *gen)
 {
-  g_signal_connect_swapped (gen->display, "seat-added", G_CALLBACK (populate_seats), gen);
-  g_signal_connect_swapped (gen->display, "seat-removed", G_CALLBACK (populate_seats), gen);
+  g_signal_connect (gen->display, "seat-added", G_CALLBACK (seat_added), gen);
+  g_signal_connect (gen->display, "seat-removed", G_CALLBACK (seat_removed), gen);
 
   populate_seats (gen);
 }
@@ -911,9 +935,18 @@ static void
 gtk_inspector_general_dispose (GObject *object)
 {
   GtkInspectorGeneral *gen = GTK_INSPECTOR_GENERAL (object);
+  GList *list, *l;
 
   g_clear_pointer (&gen->swin, gtk_widget_unparent);
 
+  g_signal_handlers_disconnect_by_func (gen->display, G_CALLBACK (seat_added), gen);
+  g_signal_handlers_disconnect_by_func (gen->display, G_CALLBACK (seat_removed), gen);
+
+  list = gdk_display_list_seats (gen->display);
+  for (l = list; l; l = l->next)
+    disconnect_seat (gen, GDK_SEAT (l->data));
+  g_list_free (list);
+
   G_OBJECT_CLASS (gtk_inspector_general_parent_class)->dispose (object);
 }
 

gtk/inspector/recorder.c

@@ -131,6 +131,8 @@ create_list_model_for_render_node (GskRenderNode *node)
     case GSK_COLOR_NODE:
     case GSK_LINEAR_GRADIENT_NODE:
     case GSK_REPEATING_LINEAR_GRADIENT_NODE:
+    case GSK_RADIAL_GRADIENT_NODE:
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
     case GSK_BORDER_NODE:
     case GSK_INSET_SHADOW_NODE:
     case GSK_OUTSET_SHADOW_NODE:
@@ -234,6 +236,10 @@ node_type_name (GskRenderNodeType type)
       return "Linear Gradient";
     case GSK_REPEATING_LINEAR_GRADIENT_NODE:
       return "Repeating Linear Gradient";
+    case GSK_RADIAL_GRADIENT_NODE:
+      return "Radial Gradient";
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
+      return "Repeating Radial Gradient";
     case GSK_BORDER_NODE:
       return "Border";
     case GSK_TEXTURE_NODE:
@@ -279,6 +285,8 @@ node_name (GskRenderNode *node)
     case GSK_CAIRO_NODE:
     case GSK_LINEAR_GRADIENT_NODE:
     case GSK_REPEATING_LINEAR_GRADIENT_NODE:
+    case GSK_RADIAL_GRADIENT_NODE:
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
     case GSK_BORDER_NODE:
     case GSK_INSET_SHADOW_NODE:
     case GSK_OUTSET_SHADOW_NODE:
@@ -625,6 +633,11 @@ populate_render_node_properties (GtkListStore  *store,
       }
       break;
 
+    case GSK_RADIAL_GRADIENT_NODE:
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
+      /* TODO */
+      break;
+
     case GSK_TEXT_NODE:
       {
         const PangoFont *font = gsk_text_node_peek_font (node);

gtk/meson.build

@@ -121,6 +121,7 @@ gtk_private_sources = files([
   'gtkmenutrackeritem.c',
   'gtkpango.c',
   'gskpango.c',
+  'gtkpasswordentrybuffer.c',
   'gtkpathbar.c',
   'gtkplacessidebar.c',
   'gtkplacesview.c',
@@ -134,6 +135,7 @@ gtk_private_sources = files([
   'gtkscaler.c',
   'gtksearchengine.c',
   'gtksearchenginemodel.c',
+  'gtksecurememory.c',
   'gtksizerequestcache.c',
   'gtksortkeys.c',
   'gtkstyleanimation.c',
@@ -998,6 +1000,7 @@ if win32_enabled
 
   gtk_deps += [cc.find_library('advapi32'),
                cc.find_library('comctl32'),
+               cc.find_library('crypt32'), # For CryptProtectMemory()
                cc.find_library('dwmapi'),
                cc.find_library('imm32'),
                cc.find_library('setupapi'),

meson.build

@@ -217,6 +217,11 @@ if cc.compiles(uint128_t_src, name : '__uint128_t available')
   cdata.set('HAVE_UINT128_T', 1)
 endif
 
+# Check for mlock
+if cc.has_function('mlock', prefix: '#include <sys/mman.h>')
+  cdata.set('HAVE_MLOCK', 1)
+endif
+
 # Disable deprecation checks for all libraries we depend on on stable branches.
 # This is so newer versions of those libraries don't cause more warnings with
 # a stable GTK version.

po-properties/ca.po

@@ -7,7 +7,7 @@
 # Josep Puigdemont <josep.puigdemont@gmail.com>, 2005, 2006.
 # David Planella <david.planella@gmail.com>, 2008, 2009, 2010.
 # Jordi Serratosa <jordis@softcatala.cat>, 2012.
-# Gil Forcada <gilforcada@guifi.net>, 2011-2014.
+# Gil Forcada <gilforcada@guifi.net>, 2011-2020.
 # Benet R.i Camps <benny@softcatala.org>, 2015
 # Jordi Mas <jmas@softcatala.org>, 2015-2020
 #
@@ -40,16 +40,16 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gtk+ 2.3.0\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2020-08-27 00:10+0000\n"
-"PO-Revision-Date: 2020-07-26 20:32+0200\n"
-"Last-Translator: Jordi Serratosa <jordis@softcatala.cat>\n"
+"POT-Creation-Date: 2020-09-06 13:26+0000\n"
+"PO-Revision-Date: 2020-09-07 09:24+0200\n"
+"Last-Translator: Gil Forcada <gilforcada@guifi.net>\n"
 "Language-Team: Catalan <tradgnome@softcatala.org>\n"
 "Language: ca\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Generator: Poedit 2.4\n"
+"Plural-Forms: nplurals=2; plural=(n != 1)\n"
+"X-Generator: Gtranslator 3.36.0\n"
 
 #: gdk/gdkapplaunchcontext.c:133 gdk/gdkdrawcontext.c:155 gdk/gdkseat.c:201
 #: gdk/gdkseat.c:202 gdk/gdksurface.c:508 gdk/gdksurface.c:509
@@ -679,11 +679,11 @@ msgstr "Finestra activa"
 msgid "The window which most recently had focus"
 msgstr "L'última finestra que ha tingut el focus"
 
-#: gtk/gtkapplicationwindow.c:677
+#: gtk/gtkapplicationwindow.c:684
 msgid "Show a menubar"
 msgstr "Mostra la barra de menú"
 
-#: gtk/gtkapplicationwindow.c:678
+#: gtk/gtkapplicationwindow.c:685
 msgid "TRUE if the window should show a menubar at the top of the window"
 msgstr ""
 "«TRUE» (cert) si la finestra hauria de mostrar una barra de menú a dalt de "
@@ -721,7 +721,7 @@ msgstr "Obeeix el fill"
 msgid "Force aspect ratio to match that of the frame’s child"
 msgstr "Força la proporció perquè coincideixi amb el marc del fill"
 
-#: gtk/gtkaspectframe.c:173 gtk/gtkbutton.c:252 gtk/gtkcombobox.c:782
+#: gtk/gtkaspectframe.c:173 gtk/gtkbutton.c:256 gtk/gtkcombobox.c:782
 #: gtk/gtkdragicon.c:372 gtk/gtkexpander.c:366 gtk/gtkflowbox.c:509
 #: gtk/gtkframe.c:191 gtk/gtklistbox.c:3467 gtk/gtklistitem.c:185
 #: gtk/gtknotebook.c:567 gtk/gtkoverlay.c:319 gtk/gtkpopover.c:1670
@@ -731,7 +731,7 @@ msgstr "Força la proporció perquè coincideixi amb el marc del fill"
 msgid "Child"
 msgstr "Fill"
 
-#: gtk/gtkaspectframe.c:174 gtk/gtkbutton.c:253 gtk/gtkexpander.c:367
+#: gtk/gtkaspectframe.c:174 gtk/gtkbutton.c:257 gtk/gtkexpander.c:367
 #: gtk/gtkflowbox.c:510 gtk/gtkframe.c:192 gtk/gtklistbox.c:3468
 #: gtk/gtkoverlay.c:320 gtk/gtkpopover.c:1671 gtk/gtkrevealer.c:353
 #: gtk/gtkscrolledwindow.c:757 gtk/gtksearchbar.c:325 gtk/gtkviewport.c:381
@@ -918,24 +918,24 @@ msgstr "recurs que conté la definició de la IU"
 msgid "scope to use when instantiating listitems"
 msgstr "àmbit a usar quan s'instancia la llista d'elements"
 
-#: gtk/gtkbutton.c:224 gtk/gtkexpander.c:320 gtk/gtkframe.c:169
-#: gtk/gtklabel.c:744 gtk/gtkmenubutton.c:399
+#: gtk/gtkbutton.c:228 gtk/gtkcheckbutton.c:472 gtk/gtkexpander.c:320
+#: gtk/gtkframe.c:169 gtk/gtklabel.c:744 gtk/gtkmenubutton.c:399
 msgid "Label"
 msgstr "Etiqueta"
 
-#: gtk/gtkbutton.c:225
+#: gtk/gtkbutton.c:229 gtk/gtkcheckbutton.c:473
 msgid ""
 "Text of the label widget inside the button, if the button contains a label "
 "widget"
 msgstr "Text de l'etiqueta dins del botó, si el botó conté una etiqueta"
 
-#: gtk/gtkbutton.c:231 gtk/gtkexpander.c:328 gtk/gtklabel.c:765
-#: gtk/gtkmenubutton.c:406 gtk/gtkstack.c:383
+#: gtk/gtkbutton.c:235 gtk/gtkcheckbutton.c:486 gtk/gtkexpander.c:328
+#: gtk/gtklabel.c:765 gtk/gtkmenubutton.c:406 gtk/gtkstack.c:383
 msgid "Use underline"
 msgstr "Utilitza subratllat"
 
-#: gtk/gtkbutton.c:232 gtk/gtkexpander.c:329 gtk/gtklabel.c:766
-#: gtk/gtkmenubutton.c:407
+#: gtk/gtkbutton.c:236 gtk/gtkcheckbutton.c:487 gtk/gtkexpander.c:329
+#: gtk/gtklabel.c:766 gtk/gtkmenubutton.c:407
 msgid ""
 "If set, an underline in the text indicates the next character should be used "
 "for the mnemonic accelerator key"
@@ -943,21 +943,21 @@ msgstr ""
 "Si s'habilita, un subratllat en el text indica que el caràcter següent "
 "s'hauria d'utilitzar per a la tecla de drecera"
 
-#: gtk/gtkbutton.c:238 gtk/gtkcombobox.c:669 gtk/gtkentry.c:469
+#: gtk/gtkbutton.c:242 gtk/gtkcombobox.c:669 gtk/gtkentry.c:469
 #: gtk/gtkscrolledwindow.c:638
 msgid "Has Frame"
 msgstr "Té marc"
 
-#: gtk/gtkbutton.c:239 gtk/gtkmenubutton.c:414
+#: gtk/gtkbutton.c:243 gtk/gtkmenubutton.c:414
 msgid "Whether the button has a frame"
 msgstr "Si el botó té un marc"
 
-#: gtk/gtkbutton.c:245 gtk/gtkcellrendererpixbuf.c:209 gtk/gtkimage.c:211
+#: gtk/gtkbutton.c:249 gtk/gtkcellrendererpixbuf.c:209 gtk/gtkimage.c:211
 #: gtk/gtkmenubutton.c:392 gtk/gtkprinter.c:170 gtk/gtkwindow.c:822
 msgid "Icon Name"
 msgstr "Nom de la icona"
 
-#: gtk/gtkbutton.c:246 gtk/gtkmenubutton.c:393
+#: gtk/gtkbutton.c:250 gtk/gtkmenubutton.c:393
 msgid "The name of the icon used to automatically populate the button"
 msgstr ""
 "El nom de la icona que s'utilitza automàticament per a emplenar el botó"
@@ -1427,8 +1427,9 @@ msgstr "Dígits"
 msgid "The number of decimal places to display"
 msgstr "El nombre de decimals a mostrar"
 
-#: gtk/gtkcellrendererspinner.c:138 gtk/gtkmodelbutton.c:1130
-#: gtk/gtkmodelbutton.c:1131 gtk/gtkswitch.c:528 gtk/gtktogglebutton.c:208
+#: gtk/gtkcellrendererspinner.c:138 gtk/gtkcheckbutton.c:460
+#: gtk/gtkmodelbutton.c:1130 gtk/gtkmodelbutton.c:1131 gtk/gtkswitch.c:528
+#: gtk/gtktogglebutton.c:260
 msgid "Active"
 msgstr "Actiu"
 
@@ -1892,19 +1893,24 @@ msgstr "Model ajustat"
 msgid "Whether to request enough space for every row in the model"
 msgstr "Si s'ha de demanar l'espai necessari per a cada fila del model"
 
-#: gtk/gtkcheckbutton.c:223
-msgid "Draw Indicator"
-msgstr "Indicador de dibuix"
+#: gtk/gtkcheckbutton.c:461 gtk/gtktogglebutton.c:261
+msgid "If the toggle button should be pressed in"
+msgstr "Si el botó de commutació ha d'estar premut cap endins"
 
-#: gtk/gtkcheckbutton.c:224
-msgid "If the indicator part of the button is displayed"
-msgstr "Si la part d'indicació del botó es visualitza"
+#: gtk/gtkcheckbutton.c:466 gtk/gtktogglebutton.c:267
+msgid "Group"
+msgstr "Grup"
 
-#: gtk/gtkcheckbutton.c:230
+#: gtk/gtkcheckbutton.c:467
+#| msgid "The radio button whose group this widget belongs to."
+msgid "The check button whose group this widget belongs to."
+msgstr "El botó de commutació al grup del qual pertany aquest giny."
+
+#: gtk/gtkcheckbutton.c:479
 msgid "Inconsistent"
 msgstr "Inconsistent"
 
-#: gtk/gtkcheckbutton.c:231
+#: gtk/gtkcheckbutton.c:480
 msgid "If the check button is in an “in between” state"
 msgstr "Si el botó de commutació és en un estat «intermedi»"
 
@@ -4984,7 +4990,7 @@ msgstr "Paràmetres"
 msgid "Printer settings"
 msgstr "Paràmetres de la impressora"
 
-#: gtk/gtkprintjob.c:171 gtk/gtkprintjob.c:172 gtk/gtkprintunixdialog.c:382
+#: gtk/gtkprintjob.c:171 gtk/gtkprintjob.c:172 gtk/gtkprintunixdialog.c:381
 msgid "Page Setup"
 msgstr "Configuració de la pàgina"
 
@@ -5009,11 +5015,11 @@ msgstr "Configuració de la pàgina per defecte"
 msgid "The GtkPageSetup used by default"
 msgstr "El GtkPageSetup utilitzat per defecte"
 
-#: gtk/gtkprintoperation.c:1093 gtk/gtkprintunixdialog.c:400
+#: gtk/gtkprintoperation.c:1093 gtk/gtkprintunixdialog.c:399
 msgid "Print Settings"
 msgstr "Paràmetres de la impressora"
 
-#: gtk/gtkprintoperation.c:1094 gtk/gtkprintunixdialog.c:401
+#: gtk/gtkprintoperation.c:1094 gtk/gtkprintunixdialog.c:400
 msgid "The GtkPrintSettings used for initializing the dialog"
 msgstr "El GtkPrintSettings utilitzat per a inicialitzar el diàleg"
 
@@ -5033,11 +5039,11 @@ msgstr "Nombre de pàgines"
 msgid "The number of pages in the document."
 msgstr "El nombre de pàgines del document."
 
-#: gtk/gtkprintoperation.c:1153 gtk/gtkprintunixdialog.c:390
+#: gtk/gtkprintoperation.c:1153 gtk/gtkprintunixdialog.c:389
 msgid "Current Page"
 msgstr "Pàgina actual"
 
-#: gtk/gtkprintoperation.c:1154 gtk/gtkprintunixdialog.c:391
+#: gtk/gtkprintoperation.c:1154 gtk/gtkprintunixdialog.c:390
 msgid "The current page in the document"
 msgstr "La pàgina actual en el document"
 
@@ -5116,7 +5122,7 @@ msgstr "Etiqueta de pestanya personalitzada"
 msgid "Label for the tab containing custom widgets."
 msgstr "Etiqueta per a la pestanya que contingui ginys personalitzats."
 
-#: gtk/gtkprintoperation.c:1330 gtk/gtkprintunixdialog.c:425
+#: gtk/gtkprintoperation.c:1330 gtk/gtkprintunixdialog.c:424
 msgid "Support Selection"
 msgstr "Admet la selecció"
 
@@ -5126,7 +5132,7 @@ msgstr ""
 "«TRUE» (cert) si l'operació d'impressió ha d'admetre la impressió de la "
 "selecció."
 
-#: gtk/gtkprintoperation.c:1345 gtk/gtkprintunixdialog.c:433
+#: gtk/gtkprintoperation.c:1345 gtk/gtkprintunixdialog.c:432
 msgid "Has Selection"
 msgstr "Té selecció"
 
@@ -5134,11 +5140,11 @@ msgstr "Té selecció"
 msgid "TRUE if a selection exists."
 msgstr "«TRUE» (cert) si existeix una selecció."
 
-#: gtk/gtkprintoperation.c:1359 gtk/gtkprintunixdialog.c:441
+#: gtk/gtkprintoperation.c:1359 gtk/gtkprintunixdialog.c:440
 msgid "Embed Page Setup"
 msgstr "Incrusta la configuració de la pàgina"
 
-#: gtk/gtkprintoperation.c:1360 gtk/gtkprintunixdialog.c:442
+#: gtk/gtkprintoperation.c:1360 gtk/gtkprintunixdialog.c:441
 msgid "TRUE if page setup combos are embedded in GtkPrintUnixDialog"
 msgstr ""
 "«TRUE» (cert) si els quadres combinats de la configuració de pàgina estan "
@@ -5152,31 +5158,31 @@ msgstr "Nombre de pàgines a imprimir"
 msgid "The number of pages that will be printed."
 msgstr "El nombre de pàgines que s'imprimiran."
 
-#: gtk/gtkprintunixdialog.c:383
+#: gtk/gtkprintunixdialog.c:382
 msgid "The GtkPageSetup to use"
 msgstr "El GtkPageSetup a utilitzar"
 
-#: gtk/gtkprintunixdialog.c:408
+#: gtk/gtkprintunixdialog.c:407
 msgid "Selected Printer"
 msgstr "Impressora seleccionada"
 
-#: gtk/gtkprintunixdialog.c:409
+#: gtk/gtkprintunixdialog.c:408
 msgid "The GtkPrinter which is selected"
 msgstr "La GtkPrinter seleccionada"
 
-#: gtk/gtkprintunixdialog.c:416
+#: gtk/gtkprintunixdialog.c:415
 msgid "Manual Capabilities"
 msgstr "Capacitats manuals"
 
-#: gtk/gtkprintunixdialog.c:417
+#: gtk/gtkprintunixdialog.c:416
 msgid "Capabilities the application can handle"
 msgstr "Capacitats que l'aplicació admet"
 
-#: gtk/gtkprintunixdialog.c:426
+#: gtk/gtkprintunixdialog.c:425
 msgid "Whether the dialog supports selection"
 msgstr "Si el diàleg admet la selecció"
 
-#: gtk/gtkprintunixdialog.c:434
+#: gtk/gtkprintunixdialog.c:433
 msgid "Whether the application has a selection"
 msgstr "Si l'aplicació té una selecció"
 
@@ -5234,14 +5240,6 @@ msgstr "Objecte"
 msgid "The root object"
 msgstr "L'objecte arrel"
 
-#: gtk/gtkradiobutton.c:203
-msgid "Group"
-msgstr "Grup"
-
-#: gtk/gtkradiobutton.c:204
-msgid "The radio button whose group this widget belongs to."
-msgstr "El botó de grup al grup del qual pertany aquest giny."
-
 #: gtk/gtkrange.c:366
 msgid "The GtkAdjustment that contains the current value of this range object"
 msgstr "El GtkAdjustment que conté el valor actual d'aquest rang d'objectes"
@@ -7078,9 +7076,10 @@ msgstr "Tipus de finestra"
 msgid "The GtkTextWindowType"
 msgstr "El GtkTextWindowType"
 
-#: gtk/gtktogglebutton.c:209
-msgid "If the toggle button should be pressed in"
-msgstr "Si el botó de commutació ha d'estar premut cap endins"
+#: gtk/gtktogglebutton.c:268
+#| msgid "The radio button whose group this widget belongs to."
+msgid "The toggle button whose group this widget belongs to."
+msgstr "El botó commutat al grup del qual pertany aquest giny."
 
 #: gtk/gtktreeexpander.c:460
 msgid "The child widget with the actual contents"
@@ -7898,6 +7897,12 @@ msgstr "Títol del perfil de color"
 msgid "The title of the color profile to use"
 msgstr "El títol del perfil de color a utilitzar"
 
+#~ msgid "Draw Indicator"
+#~ msgstr "Indicador de dibuix"
+
+#~ msgid "If the indicator part of the button is displayed"
+#~ msgstr "Si la part d'indicació del botó es visualitza"
+
 #~ msgid "The text displayed next to the accelerator"
 #~ msgstr "El text que es mostra al costat de l'accelerador"
 

po-properties/eu.po

@@ -8,8 +8,8 @@
 msgid ""
 msgstr "Project-Id-Version: gtk+_properties master\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2020-08-27 00:10+0000\n"
-"PO-Revision-Date: 2020-08-30 10:00+0100\n"
+"POT-Creation-Date: 2020-09-05 09:54+0000\n"
+"PO-Revision-Date: 2020-09-06 10:00+0100\n"
 "Last-Translator: Asier Sarasua Garmendia <asiersarasua@ni.eus>\n"
 "Language-Team: Basque <librezale@librezale.eus>\n"
 "Language: eu\n"
@@ -656,11 +656,11 @@ msgstr "Leiho aktiboa"
 msgid "The window which most recently had focus"
 msgstr "Azken aldian fokua daukan leihoa"
 
-#: gtk/gtkapplicationwindow.c:677
+#: gtk/gtkapplicationwindow.c:684
 msgid "Show a menubar"
 msgstr "Erakutsi menu-barra"
 
-#: gtk/gtkapplicationwindow.c:678
+#: gtk/gtkapplicationwindow.c:685
 msgid "TRUE if the window should show a menubar at the top of the window"
 msgstr "TRUE (egia) leihoak goian menu-barra erakutsi behar badu"
 
@@ -696,7 +696,7 @@ msgstr "Umeari obeditu"
 msgid "Force aspect ratio to match that of the frame’s child"
 msgstr "Behartu aspektu-erlazioa markoaren haurrarekin bat etor dadin"
 
-#: gtk/gtkaspectframe.c:173 gtk/gtkbutton.c:252 gtk/gtkcombobox.c:782
+#: gtk/gtkaspectframe.c:173 gtk/gtkbutton.c:256 gtk/gtkcombobox.c:782
 #: gtk/gtkdragicon.c:372 gtk/gtkexpander.c:366 gtk/gtkflowbox.c:509
 #: gtk/gtkframe.c:191 gtk/gtklistbox.c:3467 gtk/gtklistitem.c:185
 #: gtk/gtknotebook.c:567 gtk/gtkoverlay.c:319 gtk/gtkpopover.c:1670
@@ -706,7 +706,7 @@ msgstr "Behartu aspektu-erlazioa markoaren haurrarekin bat etor dadin"
 msgid "Child"
 msgstr "Haurra"
 
-#: gtk/gtkaspectframe.c:174 gtk/gtkbutton.c:253 gtk/gtkexpander.c:367
+#: gtk/gtkaspectframe.c:174 gtk/gtkbutton.c:257 gtk/gtkexpander.c:367
 #: gtk/gtkflowbox.c:510 gtk/gtkframe.c:192 gtk/gtklistbox.c:3468
 #: gtk/gtkoverlay.c:320 gtk/gtkpopover.c:1671 gtk/gtkrevealer.c:353
 #: gtk/gtkscrolledwindow.c:757 gtk/gtksearchbar.c:325 gtk/gtkviewport.c:381
@@ -895,44 +895,44 @@ msgstr "UI definizioa duen baliabidea"
 msgid "scope to use when instantiating listitems"
 msgstr "zerrenda-elementuak instantziatzean erabiliko den esparrua"
 
-#: gtk/gtkbutton.c:224 gtk/gtkexpander.c:320 gtk/gtkframe.c:169
-#: gtk/gtklabel.c:744 gtk/gtkmenubutton.c:399
+#: gtk/gtkbutton.c:228 gtk/gtkcheckbutton.c:472 gtk/gtkexpander.c:320
+#: gtk/gtkframe.c:169 gtk/gtklabel.c:744 gtk/gtkmenubutton.c:399
 msgid "Label"
 msgstr "Etiketa"
 
-#: gtk/gtkbutton.c:225
+#: gtk/gtkbutton.c:229 gtk/gtkcheckbutton.c:473
 msgid ""
 "Text of the label widget inside the button, if the button contains a label "
 "widget"
 msgstr "Etiketa-trepetaren testua botoi barruan, botoiak etiketa-trepeta badu"
 
-#: gtk/gtkbutton.c:231 gtk/gtkexpander.c:328 gtk/gtklabel.c:765
-#: gtk/gtkmenubutton.c:406 gtk/gtkstack.c:383
+#: gtk/gtkbutton.c:235 gtk/gtkcheckbutton.c:486 gtk/gtkexpander.c:328
+#: gtk/gtklabel.c:765 gtk/gtkmenubutton.c:406 gtk/gtkstack.c:383
 msgid "Use underline"
 msgstr "Erabili azpimarra"
 
-#: gtk/gtkbutton.c:232 gtk/gtkexpander.c:329 gtk/gtklabel.c:766
-#: gtk/gtkmenubutton.c:407
+#: gtk/gtkbutton.c:236 gtk/gtkcheckbutton.c:487 gtk/gtkexpander.c:329
+#: gtk/gtklabel.c:766 gtk/gtkmenubutton.c:407
 msgid ""
 "If set, an underline in the text indicates the next character should be used "
 "for the mnemonic accelerator key"
 msgstr "Ezartzen bada, testuko azpimarrak adierazten du hurrengo karakterea tekla bizkortzaile mnemoteknikorako erabili behar dela"
 
-#: gtk/gtkbutton.c:238 gtk/gtkcombobox.c:669 gtk/gtkentry.c:469
+#: gtk/gtkbutton.c:242 gtk/gtkcombobox.c:669 gtk/gtkentry.c:469
 #: gtk/gtkscrolledwindow.c:638
 msgid "Has Frame"
 msgstr "Markoa dauka"
 
-#: gtk/gtkbutton.c:239 gtk/gtkmenubutton.c:414
+#: gtk/gtkbutton.c:243 gtk/gtkmenubutton.c:414
 msgid "Whether the button has a frame"
 msgstr "Botoiak markoa duen ala ez"
 
-#: gtk/gtkbutton.c:245 gtk/gtkcellrendererpixbuf.c:209 gtk/gtkimage.c:211
+#: gtk/gtkbutton.c:249 gtk/gtkcellrendererpixbuf.c:209 gtk/gtkimage.c:211
 #: gtk/gtkmenubutton.c:392 gtk/gtkprinter.c:170 gtk/gtkwindow.c:822
 msgid "Icon Name"
 msgstr "Ikono-izena"
 
-#: gtk/gtkbutton.c:246 gtk/gtkmenubutton.c:393
+#: gtk/gtkbutton.c:250 gtk/gtkmenubutton.c:393
 msgid "The name of the icon used to automatically populate the button"
 msgstr "Ikonoaren izena botoia automatikoki betetzeko"
 
@@ -1400,8 +1400,9 @@ msgstr "Digituak"
 msgid "The number of decimal places to display"
 msgstr "Bistaratu beharreko dezimalen kopurua"
 
-#: gtk/gtkcellrendererspinner.c:138 gtk/gtkmodelbutton.c:1130
-#: gtk/gtkmodelbutton.c:1131 gtk/gtkswitch.c:528 gtk/gtktogglebutton.c:208
+#: gtk/gtkcellrendererspinner.c:138 gtk/gtkcheckbutton.c:460
+#: gtk/gtkmodelbutton.c:1130 gtk/gtkmodelbutton.c:1131 gtk/gtkswitch.c:528
+#: gtk/gtktogglebutton.c:260
 msgid "Active"
 msgstr "Aktibo"
 
@@ -1863,22 +1864,26 @@ msgstr "Doitu eredua"
 msgid "Whether to request enough space for every row in the model"
 msgstr "Ereduan errenkada bakoitzarentzako nahiko leku eskatu edo ez"
 
-#: gtk/gtkcheckbutton.c:223
-msgid "Draw Indicator"
-msgstr "Marrazki-adierazlea"
+#: gtk/gtkcheckbutton.c:461 gtk/gtktogglebutton.c:261
+msgid "If the toggle button should be pressed in"
+msgstr "Txandakatze-botoiak sakatuta egon behar duen ala ez"
 
-#: gtk/gtkcheckbutton.c:224
-msgid "If the indicator part of the button is displayed"
-msgstr "Botoiaren adierazle-zatia bistaratuta dagoen"
+#: gtk/gtkcheckbutton.c:466 gtk/gtktogglebutton.c:267
+msgid "Group"
+msgstr "Taldea"
+
+#: gtk/gtkcheckbutton.c:467
+msgid "The check button whose group this widget belongs to."
+msgstr "Trepeta honi dagokion taldearen kontrol-botoia."
 
 #
-#: gtk/gtkcheckbutton.c:230
+#: gtk/gtkcheckbutton.c:479
 msgid "Inconsistent"
 msgstr "Sendotasunik gabea"
 
-#: gtk/gtkcheckbutton.c:231
+#: gtk/gtkcheckbutton.c:480
 msgid "If the check button is in an “in between” state"
-msgstr "Txandakatze-botoia “tarteko” egoeran dagoen"
+msgstr "Kontrol-botoia “tarteko” egoeran dagoen"
 
 #: gtk/gtkcolorbutton.c:158 gtk/gtkcolorchooser.c:83
 msgid "Use alpha"
@@ -4921,7 +4926,7 @@ msgid "Printer settings"
 msgstr "Inprimagailuaren ezarpenak"
 
 #
-#: gtk/gtkprintjob.c:171 gtk/gtkprintjob.c:172 gtk/gtkprintunixdialog.c:382
+#: gtk/gtkprintjob.c:171 gtk/gtkprintjob.c:172 gtk/gtkprintunixdialog.c:381
 msgid "Page Setup"
 msgstr "Orrialdearen konfigurazioa"
 
@@ -4943,11 +4948,11 @@ msgstr "Orriaren konfigurazio lehenetsia"
 msgid "The GtkPageSetup used by default"
 msgstr "GtkPageSetup lehenespenez erabilita"
 
-#: gtk/gtkprintoperation.c:1093 gtk/gtkprintunixdialog.c:400
+#: gtk/gtkprintoperation.c:1093 gtk/gtkprintunixdialog.c:399
 msgid "Print Settings"
 msgstr "Inprimatze-ezarpenak"
 
-#: gtk/gtkprintoperation.c:1094 gtk/gtkprintunixdialog.c:401
+#: gtk/gtkprintoperation.c:1094 gtk/gtkprintunixdialog.c:400
 msgid "The GtkPrintSettings used for initializing the dialog"
 msgstr "GtkPrintSettings elkarrizketa-koadroa hasieratzeko erabilita"
 
@@ -4967,11 +4972,11 @@ msgstr "Orrialde kopurua"
 msgid "The number of pages in the document."
 msgstr "Dokumentuaren orrialde kopurua."
 
-#: gtk/gtkprintoperation.c:1153 gtk/gtkprintunixdialog.c:390
+#: gtk/gtkprintoperation.c:1153 gtk/gtkprintunixdialog.c:389
 msgid "Current Page"
 msgstr "Uneko orrialdea"
 
-#: gtk/gtkprintoperation.c:1154 gtk/gtkprintunixdialog.c:391
+#: gtk/gtkprintoperation.c:1154 gtk/gtkprintunixdialog.c:390
 msgid "The current page in the document"
 msgstr "Dokumentuaren uneko orrialdea"
 
@@ -5043,7 +5048,7 @@ msgstr "Fitxaren etiketa pertsonalizatua"
 msgid "Label for the tab containing custom widgets."
 msgstr "Trepeta pertsonalizatuak dituen fitxaren etiketa."
 
-#: gtk/gtkprintoperation.c:1330 gtk/gtkprintunixdialog.c:425
+#: gtk/gtkprintoperation.c:1330 gtk/gtkprintunixdialog.c:424
 msgid "Support Selection"
 msgstr "Hautapenaren euskarria"
 
@@ -5051,7 +5056,7 @@ msgstr "Hautapenaren euskarria"
 msgid "TRUE if the print operation will support print of selection."
 msgstr "TRUE (egia) inprimatzeko eragiketak hautapena inprimatzea onartzen badu."
 
-#: gtk/gtkprintoperation.c:1345 gtk/gtkprintunixdialog.c:433
+#: gtk/gtkprintoperation.c:1345 gtk/gtkprintunixdialog.c:432
 msgid "Has Selection"
 msgstr "Hautapena du"
 
@@ -5060,11 +5065,11 @@ msgid "TRUE if a selection exists."
 msgstr "TRUE (egia) hautapena existitzen bada."
 
 #
-#: gtk/gtkprintoperation.c:1359 gtk/gtkprintunixdialog.c:441
+#: gtk/gtkprintoperation.c:1359 gtk/gtkprintunixdialog.c:440
 msgid "Embed Page Setup"
 msgstr "Kapsulatutako orriaren konfigurazioa"
 
-#: gtk/gtkprintoperation.c:1360 gtk/gtkprintunixdialog.c:442
+#: gtk/gtkprintoperation.c:1360 gtk/gtkprintunixdialog.c:441
 msgid "TRUE if page setup combos are embedded in GtkPrintUnixDialog"
 msgstr "TRUE (egia) orria konfiguratzeko konbinazio-koadroak GtkPrintUnixDialog-en kapsulatuta badaude"
 
@@ -5076,31 +5081,31 @@ msgstr "Orrialde kopurua inprimatzeko"
 msgid "The number of pages that will be printed."
 msgstr "Inprimatuko diren orrialdeen kopurua."
 
-#: gtk/gtkprintunixdialog.c:383
+#: gtk/gtkprintunixdialog.c:382
 msgid "The GtkPageSetup to use"
 msgstr "GtkPageSetup erabiltzeko"
 
-#: gtk/gtkprintunixdialog.c:408
+#: gtk/gtkprintunixdialog.c:407
 msgid "Selected Printer"
 msgstr "Hautatutako inprimagailua"
 
-#: gtk/gtkprintunixdialog.c:409
+#: gtk/gtkprintunixdialog.c:408
 msgid "The GtkPrinter which is selected"
 msgstr "Hautatutako GtkPrinter"
 
-#: gtk/gtkprintunixdialog.c:416
+#: gtk/gtkprintunixdialog.c:415
 msgid "Manual Capabilities"
 msgstr "Eskuzko gaitasunak"
 
-#: gtk/gtkprintunixdialog.c:417
+#: gtk/gtkprintunixdialog.c:416
 msgid "Capabilities the application can handle"
 msgstr "Aplikazioak kudea ditzakeen gaitasunak"
 
-#: gtk/gtkprintunixdialog.c:426
+#: gtk/gtkprintunixdialog.c:425
 msgid "Whether the dialog supports selection"
 msgstr "Elkarrizketa-koadroak hautapena onartzen duen edo ez"
 
-#: gtk/gtkprintunixdialog.c:434
+#: gtk/gtkprintunixdialog.c:433
 msgid "Whether the application has a selection"
 msgstr "Aplikazioak hautapen bat duen edo ez"
 
@@ -5155,14 +5160,6 @@ msgstr "Objektua"
 msgid "The root object"
 msgstr "Erro-objektua"
 
-#: gtk/gtkradiobutton.c:203
-msgid "Group"
-msgstr "Taldea"
-
-#: gtk/gtkradiobutton.c:204
-msgid "The radio button whose group this widget belongs to."
-msgstr "Aukera-botoia (taldeari dagokion trepeta hau)."
-
 #: gtk/gtkrange.c:366
 msgid "The GtkAdjustment that contains the current value of this range object"
 msgstr "Barruti-objektu honen uneko balioa duen GtkAdjustment"
@@ -6891,9 +6888,9 @@ msgstr "Leiho-mota"
 msgid "The GtkTextWindowType"
 msgstr "GtkTextWindowType"
 
-#: gtk/gtktogglebutton.c:209
-msgid "If the toggle button should be pressed in"
-msgstr "Txandakatze-botoiak sakatuta egon behar duen ala ez"
+#: gtk/gtktogglebutton.c:268
+msgid "The toggle button whose group this widget belongs to."
+msgstr "Trepeta honi dagokion taldearen txandakatze-botoia."
 
 #: gtk/gtktreeexpander.c:460
 msgid "The child widget with the actual contents"
@@ -7691,6 +7688,12 @@ msgstr "Kolore-profilaren titulua"
 msgid "The title of the color profile to use"
 msgstr "Erabiliko den kolore-profilaren titulua"
 
+#~ msgid "Draw Indicator"
+#~ msgstr "Marrazki-adierazlea"
+
+#~ msgid "If the indicator part of the button is displayed"
+#~ msgstr "Botoiaren adierazle-zatia bistaratuta dagoen"
+
 #
 #~ msgid "Device type"
 #~ msgstr "Gailu mota"

po-properties/id.po

@@ -12,8 +12,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gtk+-properties master\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2020-08-28 10:27+0000\n"
-"PO-Revision-Date: 2020-08-31 10:25+0700\n"
+"POT-Creation-Date: 2020-09-05 09:54+0000\n"
+"PO-Revision-Date: 2020-09-06 12:15+0700\n"
 "Last-Translator: Kukuh Syafaat <kukuhsyafaat@gnome.org>\n"
 "Language-Team: Indonesian <gnome@i15n.org>\n"
 "Language: id\n"
@@ -655,11 +655,11 @@ msgstr "Jendela aktif"
 msgid "The window which most recently had focus"
 msgstr "Jendela yang terakhir kali memiliki fokus"
 
-#: gtk/gtkapplicationwindow.c:677
+#: gtk/gtkapplicationwindow.c:684
 msgid "Show a menubar"
 msgstr "Tampilkan bilah menu"
 
-#: gtk/gtkapplicationwindow.c:678
+#: gtk/gtkapplicationwindow.c:685
 msgid "TRUE if the window should show a menubar at the top of the window"
 msgstr ""
 "TRUE jika jendela mesti menampilkan bilah menu di bagian puncak jendela"
@@ -696,7 +696,7 @@ msgstr "Obey child"
 msgid "Force aspect ratio to match that of the frame’s child"
 msgstr "Paksakan rasio aspek agar cocok dengan dengan bingkai anak"
 
-#: gtk/gtkaspectframe.c:173 gtk/gtkbutton.c:252 gtk/gtkcombobox.c:782
+#: gtk/gtkaspectframe.c:173 gtk/gtkbutton.c:256 gtk/gtkcombobox.c:782
 #: gtk/gtkdragicon.c:372 gtk/gtkexpander.c:366 gtk/gtkflowbox.c:509
 #: gtk/gtkframe.c:191 gtk/gtklistbox.c:3467 gtk/gtklistitem.c:185
 #: gtk/gtknotebook.c:567 gtk/gtkoverlay.c:319 gtk/gtkpopover.c:1670
@@ -706,7 +706,7 @@ msgstr "Paksakan rasio aspek agar cocok dengan dengan bingkai anak"
 msgid "Child"
 msgstr "Anak"
 
-#: gtk/gtkaspectframe.c:174 gtk/gtkbutton.c:253 gtk/gtkexpander.c:367
+#: gtk/gtkaspectframe.c:174 gtk/gtkbutton.c:257 gtk/gtkexpander.c:367
 #: gtk/gtkflowbox.c:510 gtk/gtkframe.c:192 gtk/gtklistbox.c:3468
 #: gtk/gtkoverlay.c:320 gtk/gtkpopover.c:1671 gtk/gtkrevealer.c:353
 #: gtk/gtkscrolledwindow.c:757 gtk/gtksearchbar.c:325 gtk/gtkviewport.c:381
@@ -891,25 +891,25 @@ msgstr "sumber daya yang berisi definisi UI"
 msgid "scope to use when instantiating listitems"
 msgstr "lingkup untuk digunakan saat instantiating listitems"
 
-#: gtk/gtkbutton.c:224 gtk/gtkexpander.c:320 gtk/gtkframe.c:169
-#: gtk/gtklabel.c:744 gtk/gtkmenubutton.c:399
+#: gtk/gtkbutton.c:228 gtk/gtkcheckbutton.c:472 gtk/gtkexpander.c:320
+#: gtk/gtkframe.c:169 gtk/gtklabel.c:744 gtk/gtkmenubutton.c:399
 msgid "Label"
 msgstr "Label"
 
-#: gtk/gtkbutton.c:225
+#: gtk/gtkbutton.c:229 gtk/gtkcheckbutton.c:473
 msgid ""
 "Text of the label widget inside the button, if the button contains a label "
 "widget"
 msgstr ""
 "Tulisan pada widget label dalam tombol, (jika tombol berisi widget label"
 
-#: gtk/gtkbutton.c:231 gtk/gtkexpander.c:328 gtk/gtklabel.c:765
-#: gtk/gtkmenubutton.c:406 gtk/gtkstack.c:383
+#: gtk/gtkbutton.c:235 gtk/gtkcheckbutton.c:486 gtk/gtkexpander.c:328
+#: gtk/gtklabel.c:765 gtk/gtkmenubutton.c:406 gtk/gtkstack.c:383
 msgid "Use underline"
 msgstr "Gunakan garis bawah"
 
-#: gtk/gtkbutton.c:232 gtk/gtkexpander.c:329 gtk/gtklabel.c:766
-#: gtk/gtkmenubutton.c:407
+#: gtk/gtkbutton.c:236 gtk/gtkcheckbutton.c:487 gtk/gtkexpander.c:329
+#: gtk/gtklabel.c:766 gtk/gtkmenubutton.c:407
 msgid ""
 "If set, an underline in the text indicates the next character should be used "
 "for the mnemonic accelerator key"
@@ -917,21 +917,21 @@ msgstr ""
 "Jika ini diisi maka ada garis bawah pada teks yang menunjukkan bahwa huruf "
 "tersebut berisi singkatan tombol jalan pintas"
 
-#: gtk/gtkbutton.c:238 gtk/gtkcombobox.c:669 gtk/gtkentry.c:469
+#: gtk/gtkbutton.c:242 gtk/gtkcombobox.c:669 gtk/gtkentry.c:469
 #: gtk/gtkscrolledwindow.c:638
 msgid "Has Frame"
 msgstr "Memiliki bingkai"
 
-#: gtk/gtkbutton.c:239 gtk/gtkmenubutton.c:414
+#: gtk/gtkbutton.c:243 gtk/gtkmenubutton.c:414
 msgid "Whether the button has a frame"
 msgstr "Apakah tombol memiliki bingkai"
 
-#: gtk/gtkbutton.c:245 gtk/gtkcellrendererpixbuf.c:209 gtk/gtkimage.c:211
+#: gtk/gtkbutton.c:249 gtk/gtkcellrendererpixbuf.c:209 gtk/gtkimage.c:211
 #: gtk/gtkmenubutton.c:392 gtk/gtkprinter.c:170 gtk/gtkwindow.c:822
 msgid "Icon Name"
 msgstr "Icon Name"
 
-#: gtk/gtkbutton.c:246 gtk/gtkmenubutton.c:393
+#: gtk/gtkbutton.c:250 gtk/gtkmenubutton.c:393
 msgid "The name of the icon used to automatically populate the button"
 msgstr "Nama ikon yang dipakai untuk mempopulasi tombol secara otomatis"
 
@@ -1398,8 +1398,9 @@ msgstr "Digit"
 msgid "The number of decimal places to display"
 msgstr "Jumlah tempat desimal yang ditampilkan"
 
-#: gtk/gtkcellrendererspinner.c:138 gtk/gtkmodelbutton.c:1130
-#: gtk/gtkmodelbutton.c:1131 gtk/gtkswitch.c:528 gtk/gtktogglebutton.c:208
+#: gtk/gtkcellrendererspinner.c:138 gtk/gtkcheckbutton.c:460
+#: gtk/gtkmodelbutton.c:1130 gtk/gtkmodelbutton.c:1131 gtk/gtkswitch.c:528
+#: gtk/gtktogglebutton.c:260
 msgid "Active"
 msgstr "Aktif"
 
@@ -1859,19 +1860,23 @@ msgstr "Pas Model"
 msgid "Whether to request enough space for every row in the model"
 msgstr "Apakah meminta cukup ruang untuk setiap baris dalam model"
 
-#: gtk/gtkcheckbutton.c:223
-msgid "Draw Indicator"
-msgstr "Indikator gambar"
+#: gtk/gtkcheckbutton.c:461 gtk/gtktogglebutton.c:261
+msgid "If the toggle button should be pressed in"
+msgstr "Apakah tombol jungkit harus ditekan ke dalam"
 
-#: gtk/gtkcheckbutton.c:224
-msgid "If the indicator part of the button is displayed"
-msgstr "Menentukan apakah bagian indikator tombol ditampilkan"
+#: gtk/gtkcheckbutton.c:466 gtk/gtktogglebutton.c:267
+msgid "Group"
+msgstr "Grup"
 
-#: gtk/gtkcheckbutton.c:230
+#: gtk/gtkcheckbutton.c:467
+msgid "The check button whose group this widget belongs to."
+msgstr "Tombol cek tempat grup widget ini berada."
+
+#: gtk/gtkcheckbutton.c:479
 msgid "Inconsistent"
 msgstr "Tidak konsisten"
 
-#: gtk/gtkcheckbutton.c:231
+#: gtk/gtkcheckbutton.c:480
 msgid "If the check button is in an “in between” state"
 msgstr "Menentukan apakah tombol centang ada dalam kondisi \"antara\""
 
@@ -4926,7 +4931,7 @@ msgstr "Pengaturan"
 msgid "Printer settings"
 msgstr "Tatanan pencetak"
 
-#: gtk/gtkprintjob.c:171 gtk/gtkprintjob.c:172 gtk/gtkprintunixdialog.c:382
+#: gtk/gtkprintjob.c:171 gtk/gtkprintjob.c:172 gtk/gtkprintunixdialog.c:381
 msgid "Page Setup"
 msgstr "Atur Halaman"
 
@@ -4950,11 +4955,11 @@ msgstr "Tatanan Halaman Baku"
 msgid "The GtkPageSetup used by default"
 msgstr "GtkPageSetup yang dipakai secara baku"
 
-#: gtk/gtkprintoperation.c:1093 gtk/gtkprintunixdialog.c:400
+#: gtk/gtkprintoperation.c:1093 gtk/gtkprintunixdialog.c:399
 msgid "Print Settings"
 msgstr "Tatanan Pencetakan"
 
-#: gtk/gtkprintoperation.c:1094 gtk/gtkprintunixdialog.c:401
+#: gtk/gtkprintoperation.c:1094 gtk/gtkprintunixdialog.c:400
 msgid "The GtkPrintSettings used for initializing the dialog"
 msgstr "GtkPrintSettings yang dipakai untuk menginisialisasi dialog"
 
@@ -4974,11 +4979,11 @@ msgstr "Cacah Halaman"
 msgid "The number of pages in the document."
 msgstr "Cacah halaman dalam dokumen."
 
-#: gtk/gtkprintoperation.c:1153 gtk/gtkprintunixdialog.c:390
+#: gtk/gtkprintoperation.c:1153 gtk/gtkprintunixdialog.c:389
 msgid "Current Page"
 msgstr "Halaman Kini"
 
-#: gtk/gtkprintoperation.c:1154 gtk/gtkprintunixdialog.c:391
+#: gtk/gtkprintoperation.c:1154 gtk/gtkprintunixdialog.c:390
 msgid "The current page in the document"
 msgstr "Halaman kini dalam dokumen"
 
@@ -5054,7 +5059,7 @@ msgstr "Label tab gubahan"
 msgid "Label for the tab containing custom widgets."
 msgstr "Label bagi tab yang memuat widget gubahan."
 
-#: gtk/gtkprintoperation.c:1330 gtk/gtkprintunixdialog.c:425
+#: gtk/gtkprintoperation.c:1330 gtk/gtkprintunixdialog.c:424
 msgid "Support Selection"
 msgstr "Mendukung Pilihan"
 
@@ -5062,7 +5067,7 @@ msgstr "Mendukung Pilihan"
 msgid "TRUE if the print operation will support print of selection."
 msgstr "TRUE bila operasi pencetakan akan mendukung pencetakan dari pilihan."
 
-#: gtk/gtkprintoperation.c:1345 gtk/gtkprintunixdialog.c:433
+#: gtk/gtkprintoperation.c:1345 gtk/gtkprintunixdialog.c:432
 msgid "Has Selection"
 msgstr "Memiliki Pilihan"
 
@@ -5070,11 +5075,11 @@ msgstr "Memiliki Pilihan"
 msgid "TRUE if a selection exists."
 msgstr "TRUE bila ada pilihan."
 
-#: gtk/gtkprintoperation.c:1359 gtk/gtkprintunixdialog.c:441
+#: gtk/gtkprintoperation.c:1359 gtk/gtkprintunixdialog.c:440
 msgid "Embed Page Setup"
 msgstr "Tanamkan Penyiapan Halaman"
 
-#: gtk/gtkprintoperation.c:1360 gtk/gtkprintunixdialog.c:442
+#: gtk/gtkprintoperation.c:1360 gtk/gtkprintunixdialog.c:441
 msgid "TRUE if page setup combos are embedded in GtkPrintUnixDialog"
 msgstr "TRUE bila kombo penyiapan halaman ditanamkan pada GtkPrintUnixDialog"
 
@@ -5086,31 +5091,31 @@ msgstr "Cacah Halaman Akan Dicetak"
 msgid "The number of pages that will be printed."
 msgstr "Cacah halaman yang akan dicetak."
 
-#: gtk/gtkprintunixdialog.c:383
+#: gtk/gtkprintunixdialog.c:382
 msgid "The GtkPageSetup to use"
 msgstr "GtkPageSetup yang akan dipakai"
 
-#: gtk/gtkprintunixdialog.c:408
+#: gtk/gtkprintunixdialog.c:407
 msgid "Selected Printer"
 msgstr "Pencetak Terpilih"
 
-#: gtk/gtkprintunixdialog.c:409
+#: gtk/gtkprintunixdialog.c:408
 msgid "The GtkPrinter which is selected"
 msgstr "GtkPrinter yang dipilih"
 
-#: gtk/gtkprintunixdialog.c:416
+#: gtk/gtkprintunixdialog.c:415
 msgid "Manual Capabilities"
 msgstr "Kapabilitas Manual"
 
-#: gtk/gtkprintunixdialog.c:417
+#: gtk/gtkprintunixdialog.c:416
 msgid "Capabilities the application can handle"
 msgstr "Kapabilitas yang dapat ditangani aplikasi"
 
-#: gtk/gtkprintunixdialog.c:426
+#: gtk/gtkprintunixdialog.c:425
 msgid "Whether the dialog supports selection"
 msgstr "Apakah dialog mendukung pilihan"
 
-#: gtk/gtkprintunixdialog.c:434
+#: gtk/gtkprintunixdialog.c:433
 msgid "Whether the application has a selection"
 msgstr "Apakah aplikasi memiliki pilihan"
 
@@ -5167,14 +5172,6 @@ msgstr "Objek"
 msgid "The root object"
 msgstr "Objek root"
 
-#: gtk/gtkradiobutton.c:203
-msgid "Group"
-msgstr "Grup"
-
-#: gtk/gtkradiobutton.c:204
-msgid "The radio button whose group this widget belongs to."
-msgstr "Tombol radio tempat Grup widget ini berada."
-
 #: gtk/gtkrange.c:366
 msgid "The GtkAdjustment that contains the current value of this range object"
 msgstr "GtkAdjustment yang berisi nilai sekarang pada obyek jangkauan"
@@ -6956,9 +6953,9 @@ msgstr "Jenis Jendela"
 msgid "The GtkTextWindowType"
 msgstr "GtkTextWindowType"
 
-#: gtk/gtktogglebutton.c:209
-msgid "If the toggle button should be pressed in"
-msgstr "Apakah tombol jungkit harus ditekan ke dalam"
+#: gtk/gtktogglebutton.c:268
+msgid "The toggle button whose group this widget belongs to."
+msgstr "Tombol jungkitkan tempat grup widget ini berada."
 
 #: gtk/gtktreeexpander.c:460
 msgid "The child widget with the actual contents"
@@ -7763,3 +7760,9 @@ msgstr "Judul Profil Warna"
 #: modules/printbackends/gtkprintercups.c:94
 msgid "The title of the color profile to use"
 msgstr "Judul profil warna yang akan dipakai"
+
+#~ msgid "Draw Indicator"
+#~ msgstr "Indikator gambar"
+
+#~ msgid "If the indicator part of the button is displayed"
+#~ msgstr "Menentukan apakah bagian indikator tombol ditampilkan"

po-properties/sl.po

@@ -1,4 +1,4 @@
-#'gtk/po-properties/
+# 'gtk/po-properties/
 # Slovenian translation of gtk+-properties.
 # Copyright (C) 1999-2011 Free Software Foundation, Inc.
 # This file is distributed under the same license as the gtk+-properties package.
@@ -15,7 +15,7 @@ msgstr ""
 "Project-Id-Version: gtk+-properties master\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2020-08-31 16:18+0000\n"
-"PO-Revision-Date: 2020-08-31 21:45+0200\n"
+"PO-Revision-Date: 2020-09-08 20:56+0200\n"
 "Last-Translator: Matej Urbančič <mateju@svn.gnome.org>\n"
 "Language-Team: Slovenščina <gnome-si@googlegroups.com>\n"
 "Language: sl\n"
@@ -25,7 +25,7 @@ msgstr ""
 "Plural-Forms: nplurals=4; plural=(n%100==1 ? 1 : n%100==2 ? 2 : n%100==3 || n"
 "%100==4 ? 3 : 0);\n"
 "X-Poedit-SourceCharset: utf-8\n"
-"X-Generator: Poedit 2.3\n"
+"X-Generator: Poedit 2.4.1\n"
 
 #: gdk/gdkapplaunchcontext.c:133 gdk/gdkdrawcontext.c:155 gdk/gdkseat.c:201
 #: gdk/gdkseat.c:202 gdk/gdksurface.c:508 gdk/gdksurface.c:509
@@ -154,50 +154,36 @@ msgid "Whether the keyboard has bidi layouts"
 msgstr "Ali ima označba levo težnost"
 
 #: gdk/gdkdevice.c:260
-#, fuzzy
-#| msgid "Caps Lock warning"
 msgid "Caps lock state"
-msgstr "Opozorilo velikih črk"
+msgstr "Stanje tipke zaklepa velikih črk"
 
 #: gdk/gdkdevice.c:261
-#, fuzzy
-#| msgid "Whether the cell background color is set"
 msgid "Whether the keyboard caps lock is on"
-msgstr "Ali naj bo določena barva ozadja celice"
+msgstr "Ali je tipka za zaklep tipkovnice pritisnjena"
 
 #: gdk/gdkdevice.c:267
 msgid "Num lock state"
-msgstr ""
+msgstr "Stanje zaklepa številčnice"
 
 #: gdk/gdkdevice.c:268
-#, fuzzy
-#| msgid "Whether the view is loading locations"
 msgid "Whether the keyboard num lock is on"
-msgstr "Ali pogled nalaga omrežna mesta"
+msgstr "Ali je tipka za zaklep številčne tipkovnice pritisnjena"
 
 #: gdk/gdkdevice.c:274
-#, fuzzy
-#| msgid "Scroll offset"
 msgid "Scroll lock state"
-msgstr "Drsni odmik"
+msgstr "Stanje zaklepa drsnika"
 
 #: gdk/gdkdevice.c:275
-#, fuzzy
-#| msgid "Whether the border should be shown"
 msgid "Whether the keyboard scroll lock is on"
-msgstr "Ali naj bo obroba prikazana"
+msgstr "Ali je tipka za zaklep drsnika pritisnjena"
 
 #: gdk/gdkdevice.c:281
-#, fuzzy
-#| msgid "Radio state"
 msgid "Modifier state"
-msgstr "Stanje izbirnega gumba"
+msgstr "Stanje spremenilne tipke"
 
 #: gdk/gdkdevice.c:282
-#, fuzzy
-#| msgid "The modifier mask of the accelerator"
 msgid "The modifier state of the keyboard"
-msgstr "Maska spremenilnika za pospeševalnik"
+msgstr "Stanje spremenilne tipke tipkovnice"
 
 #: gdk/gdkdisplay.c:180 gdk/gdkdisplay.c:181
 #, fuzzy
@@ -210,10 +196,8 @@ msgid "RGBA"
 msgstr "RGBA"
 
 #: gdk/gdkdisplay.c:206 gdk/gdkdisplay.c:207
-#, fuzzy
-#| msgid "Input source"
 msgid "Input shapes"
-msgstr "Dovodni vir"
+msgstr ""
 
 #: gdk/gdkdisplaymanager.c:171
 msgid "Default Display"
@@ -273,7 +257,7 @@ msgstr "Ura okna"
 
 #: gdk/gdksurface.c:522 gdk/gdksurface.c:523
 msgid "Mapped"
-msgstr ""
+msgstr "Preslikano"
 
 #: gdk/gdksurface.c:529 gdk/gdksurface.c:530 gtk/gtktreeviewcolumn.c:294
 msgid "Width"
@@ -301,10 +285,8 @@ msgid "The display that will use this cursor"
 msgstr "Prikaz kazalke"
 
 #: gdk/win32/gdkcursor-win32.c:241
-#, fuzzy
-#| msgid "Wide Handle"
 msgid "Handle"
-msgstr "Široka ročica"
+msgstr "Ročica"
 
 #: gdk/win32/gdkcursor-win32.c:242
 #, fuzzy
@@ -839,11 +821,11 @@ msgstr "Atributi"
 
 #: gtk/gtkbookmarklist.c:236 gtk/gtkdirectorylist.c:302
 msgid "IO priority"
-msgstr ""
+msgstr "Prednost V/I"
 
 #: gtk/gtkbookmarklist.c:237 gtk/gtkdirectorylist.c:303
 msgid "Priority used when loading"
-msgstr ""
+msgstr "Prednost, upoštevana med nalaganjem"
 
 #: gtk/gtkbookmarklist.c:248 gtk/gtkdirectorylist.c:326
 msgid "loading"
@@ -898,7 +880,7 @@ msgstr "Položaj z osnovnico poravnanih gradnikov, kadar je prostor na voljo"
 
 #: gtk/gtkboxlayout.c:709
 msgid "Distribute space homogeneously"
-msgstr ""
+msgstr "Porazdeli prostor homogeno"
 
 #: gtk/gtkboxlayout.c:723
 msgid "Spacing between widgets"
@@ -933,7 +915,7 @@ msgstr "Stanje opravila tiskanja"
 
 #: gtk/gtkbuilderlistitemfactory.c:269
 msgid "Bytes"
-msgstr ""
+msgstr "Bajti"
 
 #: gtk/gtkbuilderlistitemfactory.c:270
 #, fuzzy
@@ -2055,10 +2037,8 @@ msgid "Columns"
 msgstr "Stolpci"
 
 #: gtk/gtkcolumnview.c:622
-#, fuzzy
-#| msgid "List of classes"
 msgid "List of columns"
-msgstr "Seznam razredov"
+msgstr "Seznam stolpcev"
 
 #: gtk/gtkcolumnview.c:634 gtk/gtkgridview.c:1094 gtk/gtklistview.c:841
 #, fuzzy
@@ -2074,7 +2054,7 @@ msgstr "Pokaži okraske"
 
 #: gtk/gtkcolumnview.c:646 gtk/gtklistbox.c:513 gtk/gtklistview.c:853
 msgid "Show separators between rows"
-msgstr ""
+msgstr "Pokaži ločilnike med vrsticami"
 
 #: gtk/gtkcolumnview.c:657
 #, fuzzy
@@ -2090,10 +2070,8 @@ msgstr "Prostor, vstavljen med stolpce mreže"
 
 #: gtk/gtkcolumnview.c:669 gtk/gtkcolumnviewcolumn.c:277
 #: gtk/gtksortlistmodel.c:820 gtk/gtktreelistrowsorter.c:544
-#, fuzzy
-#| msgid "Sort order"
 msgid "Sorter"
-msgstr "Vrstni red"
+msgstr "Razvrščevalnik"
 
 #: gtk/gtkcolumnview.c:670
 msgid "Sorter with sorting choices of the user"
@@ -2101,11 +2079,9 @@ msgstr ""
 
 #: gtk/gtkcolumnview.c:681 gtk/gtkgridview.c:1105 gtk/gtklistview.c:864
 msgid "Single click activate"
-msgstr ""
+msgstr "Omogočanje z enim klikom"
 
 #: gtk/gtkcolumnview.c:682 gtk/gtkgridview.c:1106 gtk/gtklistview.c:865
-#, fuzzy
-#| msgid "Activate row on a single click"
 msgid "Activate rows on single click"
 msgstr "Omogoči vrstico ob enojnem kliku"
 
@@ -2115,10 +2091,8 @@ msgid "Reorderable"
 msgstr "Preuredljivo"
 
 #: gtk/gtkcolumnview.c:694
-#, fuzzy
-#| msgid "Whether the column can be reordered around the headers"
 msgid "Whether columns are reorderable"
-msgstr "Ali je lahko stolpec pri glavah drugače urejen"
+msgstr "Ali je stolpce mogoče prerazporediti"
 
 #: gtk/gtkcolumnview.c:705 gtk/gtkgridview.c:1117 gtk/gtklistview.c:876
 #, fuzzy
@@ -2136,10 +2110,8 @@ msgstr ""
 "Ali naj bo z vleko miškinega kazalca omogočena izbira več datotek hkrati"
 
 #: gtk/gtkcolumnviewcolumn.c:241
-#, fuzzy
-#| msgid "Columns"
 msgid "Column view"
-msgstr "Stolpci"
+msgstr "Stolpčni pogled"
 
 #: gtk/gtkcolumnviewcolumn.c:242
 msgid "Column view this column is a part of"
@@ -2156,10 +2128,8 @@ msgid "Factory for populating list items"
 msgstr ""
 
 #: gtk/gtkcolumnviewcolumn.c:266
-#, fuzzy
-#| msgid "Text to be displayed in the progress bar"
 msgid "Title displayed in the header"
-msgstr "Besedilo, ki je prikazano v vrstici napredka."
+msgstr "Naziv, ki naj se pojavi v glavi"
 
 #: gtk/gtkcolumnviewcolumn.c:278
 msgid "Sorter for sorting items according to this column"
@@ -2171,10 +2141,8 @@ msgid "Visible"
 msgstr "Vidno"
 
 #: gtk/gtkcolumnviewcolumn.c:290
-#, fuzzy
-#| msgid "Whether the action is visible."
 msgid "Whether this column is visible"
-msgstr "Ali naj bo dejanje vidno."
+msgstr "Ali naj bo stolpec viden"
 
 #: gtk/gtkcolumnviewcolumn.c:301
 msgid "Header menu"
@@ -2654,11 +2622,11 @@ msgstr "Ali naj se pokaže določilo razvrščanja"
 
 #: gtk/gtkdropdown.c:509
 msgid "Expression to determine strings to search for"
-msgstr ""
+msgstr "Izraz za določanje iskalnega niza"
 
 #: gtk/gtkdroptargetasync.c:401 gtk/gtkdroptarget.c:602
 msgid "Formats"
-msgstr ""
+msgstr "Zapisi"
 
 #: gtk/gtkdroptarget.c:579
 msgid "The actions supported by this drop target"
@@ -2672,11 +2640,11 @@ msgstr "Trenutna barva"
 
 #: gtk/gtkdroptarget.c:603
 msgid "The supported formats"
-msgstr ""
+msgstr "Podprti zapisi"
 
 #: gtk/gtkdroptarget.c:630
 msgid "Preload"
-msgstr ""
+msgstr "Predhodno nalaganje"
 
 #: gtk/gtkdroptarget.c:631
 #, fuzzy
@@ -2708,7 +2676,7 @@ msgstr "Omogoči razveljavitve"
 
 #: gtk/gtkeditable.c:386
 msgid "If undo/redo should be enabled for the editable"
-msgstr ""
+msgstr "Ali naj bo možnost razveljavitve omogočena za ta uredljivi predmet"
 
 #: gtk/gtkeditable.c:392
 msgid "Selection Bound"
@@ -3391,7 +3359,7 @@ msgstr "Povečanje koraka"
 
 #: gtk/gtkfilterlistmodel.c:578
 msgid "Filter items incrementally"
-msgstr ""
+msgstr "Filtriraj predmete naraščajoče"
 
 #: gtk/gtkfilterlistmodel.c:590 gtk/gtkselectionfiltermodel.c:228
 #, fuzzy
@@ -3413,7 +3381,7 @@ msgstr "Število nedavno uporabljenih datotek"
 
 #: gtk/gtkfixedlayout.c:155
 msgid "transform"
-msgstr ""
+msgstr "preoblikuj"
 
 #: gtk/gtkfixedlayout.c:156
 msgid "The transform of a child of a fixed layout"
@@ -4170,11 +4138,11 @@ msgstr "Pokaži okraske"
 
 #: gtk/gtklistbox.c:3449
 msgid "Whether this row can be activated"
-msgstr "Ali je vrstico mogoče omogočiti?"
+msgstr "Ali je vrstico mogoče omogočiti"
 
 #: gtk/gtklistbox.c:3461
 msgid "Whether this row can be selected"
-msgstr "Ali je to vrstico mogoče izbrati?"
+msgstr "Ali je to vrstico mogoče izbrati"
 
 #: gtk/gtklistitem.c:174
 #, fuzzy
@@ -4303,11 +4271,11 @@ msgstr "Način za iskanje zadetkov"
 
 #: gtk/gtkmediacontrols.c:276 gtk/gtkvideo.c:320
 msgid "Media Stream"
-msgstr ""
+msgstr "Predstavni pretok"
 
 #: gtk/gtkmediacontrols.c:277
 msgid "The media stream managed"
-msgstr ""
+msgstr "Upravljan predstavni pretok"
 
 #: gtk/gtkmediafile.c:162
 msgid "File being played back"
@@ -4993,10 +4961,8 @@ msgid "The GdkPaintable to display"
 msgstr "Naslov za prikaz"
 
 #: gtk/gtkpicture.c:328
-#, fuzzy
-#| msgid "Filename to load and display"
 msgid "File to load and display"
-msgstr "Ime datoteke, ki naj se naloži in prikaže"
+msgstr "Datoteka, ki naj se naloži in prikaže"
 
 #: gtk/gtkpicture.c:339
 #, fuzzy
@@ -5009,10 +4975,8 @@ msgid "The alternative textual description"
 msgstr ""
 
 #: gtk/gtkpicture.c:352
-#, fuzzy
-#| msgid "Cursor line aspect ratio"
 msgid "Keep aspect ratio"
-msgstr "Razmerje vrstice kazalke"
+msgstr "Ohrani razmerja velikosti"
 
 #: gtk/gtkpicture.c:353
 msgid "Render contents respecting the aspect ratio"
@@ -5059,8 +5023,6 @@ msgid "Whether the sidebar includes a builtin shortcut for recent files"
 msgstr "Ali bočno okno vključuje tudi vgrajeno bližnjico do nedavnih datotek"
 
 #: gtk/gtkplacessidebar.c:4362
-#, fuzzy
-#| msgid "Show 'Desktop'"
 msgid "Show “Desktop”"
 msgstr "Pokaži »Namizje«"
 
@@ -5069,8 +5031,6 @@ msgid "Whether the sidebar includes a builtin shortcut to the Desktop folder"
 msgstr "Ali naj bočno okno vključuje tudi bližnico do mape namizja"
 
 #: gtk/gtkplacessidebar.c:4368
-#, fuzzy
-#| msgid "Show “Starred Location”"
 msgid "Show “Enter Location”"
 msgstr "Pokaži »Mesta z zvezdico«"
 
@@ -5088,8 +5048,6 @@ msgid "Whether the sidebar includes a builtin shortcut to the Trash location"
 msgstr "Ali bočno okno vključuje tudi vgrajeno bližnjico do Smeti"
 
 #: gtk/gtkplacessidebar.c:4380
-#, fuzzy
-#| msgid "Show 'Other locations'"
 msgid "Show “Other locations”"
 msgstr "Pokaži »Druga mesta«"
 
@@ -5190,28 +5148,20 @@ msgid "Whether to dismiss the popover on outside clicks"
 msgstr "Ali naj se pojavna okna prekličejo ob kliku izven polja okna"
 
 #: gtk/gtkpopover.c:1649 gtk/gtkwindow.c:907
-#, fuzzy
-#| msgid "Default Width"
 msgid "Default widget"
-msgstr "Privzeta širina"
+msgstr "Privzeti gradnik"
 
 #: gtk/gtkpopover.c:1650 gtk/gtkwindow.c:908
-#, fuzzy
-#| msgid "The name of the widget"
 msgid "The default widget"
-msgstr "Ime gradnika"
+msgstr "Privzeti gradnik"
 
 #: gtk/gtkpopover.c:1656
-#, fuzzy
-#| msgid "Show Arrow"
 msgid "Has Arrow"
-msgstr "Pokaži puščico"
+msgstr "Prikaz puščice"
 
 #: gtk/gtkpopover.c:1657
-#, fuzzy
-#| msgid "Whether to show an icon for Emoji"
 msgid "Whether to draw an arrow"
-msgstr "Ali naj se pokaže sličica izraznih ikon"
+msgstr "Ali naj bo prikazana puščica"
 
 #: gtk/gtkpopover.c:1663
 #, fuzzy
@@ -6487,10 +6437,8 @@ msgid "The name of the action"
 msgstr "Ime dejanja"
 
 #: gtk/gtkshortcuttrigger.c:659 gtk/gtkshortcuttrigger.c:915
-#, fuzzy
-#| msgid "The value"
 msgid "Key value"
-msgstr "Vrednost"
+msgstr "Ključna vrednost"
 
 #: gtk/gtkshortcuttrigger.c:660 gtk/gtkshortcuttrigger.c:916
 #, fuzzy
@@ -6793,16 +6741,12 @@ msgid "If exact matches are necessary or if substrings are allowed"
 msgstr ""
 
 #: gtk/gtkstringfilter.c:288
-#, fuzzy
-#| msgid "Search mode"
 msgid "Search"
-msgstr "Iskalni način"
+msgstr "Iskanje"
 
 #: gtk/gtkstringfilter.c:289
-#, fuzzy
-#| msgid "The selected year"
 msgid "The search term"
-msgstr "Izbrano leto"
+msgstr "Iskalni niz"
 
 #: gtk/gtkstylecontext.c:146
 #, fuzzy
@@ -6848,19 +6792,21 @@ msgstr "Ali medpomnilnik trenutno vsebuje izbrano besedilo"
 
 #: gtk/gtktextbuffer.c:490
 msgid "Can Undo"
-msgstr ""
+msgstr "Podpora razveljavitve"
 
 #: gtk/gtktextbuffer.c:491
 msgid "If the buffer can have the last action undone"
-msgstr ""
+msgstr "Ali naj predpomnilnik omogoči razveljavitev zadnjega dejanja"
 
 #: gtk/gtktextbuffer.c:503
 msgid "Can Redo"
-msgstr ""
+msgstr "Podpora ponovne uveljavitve"
 
 #: gtk/gtktextbuffer.c:504
 msgid "If the buffer can have the last undone action reapplied"
 msgstr ""
+"Ali naj predpomnilnik omogoči ponovno uveljavitev nazadnje razveljavljenega "
+"dejanja"
 
 #: gtk/gtktextbuffer.c:530
 msgid "Cursor position"
@@ -7210,10 +7156,8 @@ msgid "Whether breaks are allowed."
 msgstr "Ali naj se uporabijo nadomestne pisave."
 
 #: gtk/gtktexttag.c:658
-#, fuzzy
-#| msgid "Show Expanders"
 msgid "Show spaces"
-msgstr "Pokaži razširjevalnike"
+msgstr "Pokaži presledne znake"
 
 #: gtk/gtktexttag.c:659
 #, fuzzy
@@ -7223,7 +7167,7 @@ msgstr "Nevidni znak"
 
 #: gtk/gtktexttag.c:667
 msgid "Insert hyphens"
-msgstr ""
+msgstr "Vstavi vezaje"
 
 #: gtk/gtktexttag.c:668
 #, fuzzy
@@ -7421,7 +7365,7 @@ msgstr "Ali naj ta oznaka vpliva na barvo podčrtanega"
 
 #: gtk/gtktexttag.c:844
 msgid "Insert hyphens set"
-msgstr ""
+msgstr "Vstavi nabor vezajev"
 
 #: gtk/gtktexttag.c:845
 #, fuzzy
@@ -7521,7 +7465,7 @@ msgstr "Ali naj bo preklopni gumb pritisnjen"
 
 #: gtk/gtktreeexpander.c:460
 msgid "The child widget with the actual contents"
-msgstr ""
+msgstr "Podrejeni gradnik z dejansko vsebino"
 
 #: gtk/gtktreeexpander.c:472
 #, fuzzy
@@ -8158,16 +8102,12 @@ msgid "The name of this widget in the CSS tree"
 msgstr "Ime gradnika v drevesni strukturi CSS"
 
 #: gtk/gtkwidget.c:1307
-#, fuzzy
-#| msgid "Style Classes"
 msgid "CSS Style Classes"
-msgstr "Razredi slogov"
+msgstr "Razredi slogov CSS"
 
 #: gtk/gtkwidget.c:1308
-#, fuzzy
-#| msgid "List of classes"
 msgid "List of CSS classes"
-msgstr "Seznam razredov"
+msgstr "Seznam razredov CSS"
 
 #: gtk/gtkwidget.c:1320
 #, fuzzy
@@ -8274,7 +8214,7 @@ msgstr "Ime tematske ikone tega okna"
 
 #: gtk/gtkwindow.c:830
 msgid "The display that will display this window"
-msgstr ""
+msgstr "Zaslon, na katerem naj bo prikazano okno"
 
 #: gtk/gtkwindow.c:836
 msgid "Is Active"
@@ -8349,10 +8289,8 @@ msgid "Whether the widget has any window buttons"
 msgstr "Ali vključuje gradnik vnosno dejavnost"
 
 #: modules/media/gtkgstsink.c:241
-#, fuzzy
-#| msgid "Editable"
 msgid "paintable"
-msgstr "Uredljivo"
+msgstr "izrisljivo"
 
 #: modules/media/gtkgstsink.c:242
 msgid "Paintable providing the picture"