ui/theme.c

Bug Summary

File:	ui/theme.c
Warning:	line 6794, column 10 This statement is never executed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name theme.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/src -resource-dir /usr/lib/llvm-14/lib/clang/14.0.6 -D HAVE_CONFIG_H -I . -I .. -I ./include -D CROMA_LIBEXECDIR="/usr/local/libexec" -D HOST_ALIAS="" -D CROMA_LOCALEDIR="/usr/local/share/locale" -D CROMA_PKGDATADIR="/usr/local/share/croma" -D CROMA_DATADIR="/usr/local/share" -D G_LOG_DOMAIN="croma" -D SN_API_NOT_YET_FROZEN=1 -I /usr/include/ctk-3.0 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/uuid -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -D _REENTRANT -D _REENTRANT -I /usr/include/startup-notification-1.0 -I /usr/include/libgtop-2.0 -D PIC -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.6/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/12/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir=/rootdir/src -ferror-limit 19 -fgnuc-version=4.2.1 -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2022-12-30-180607-30189-1 -x c ui/theme.c

1	/* -- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -- */
2
3	/* Croma Theme Rendering */
4
5	/*
6	* Copyright (C) 2001 Havoc Pennington
7	*
8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License as
10	* published by the Free Software Foundation; either version 2 of the
11	* License, or (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful, but
14	* WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16	* General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21	* 02110-1301, USA.
22	*/
23
24	/**
25	* \file theme.c Making Croma look pretty
26	*
27	* The window decorations drawn by Croma are described by files on disk
28	* known internally as "themes" (externally as "window border themes" on
29	* http://art.gnome.org/themes/croma/ or "Croma themes"). This file
30	* contains most of the code necessary to support themes; it does not
31	* contain the XML parser, which is in theme-parser.c.
32	*
33	* \bug This is a big file with lots of different subsystems, which might
34	* be better split out into separate files.
35	*/
36
37	/**
38	* \defgroup tokenizer The theme expression tokenizer
39	*
40	* Themes can use a simple expression language to represent the values of
41	* things. This is the tokeniser used for that language.
42	*
43	* \bug We could remove almost all this code by using GScanner instead,
44	* but we would also have to find every expression in every existing theme
45	* we could and make sure the parse trees were the same.
46	*/
47
48	/**
49	* \defgroup parser The theme expression parser
50	*
51	* Themes can use a simple expression language to represent the values of
52	* things. This is the parser used for that language.
53	*/
54
55	#include <config.h>
56	#include "prefs.h"
57	#include "theme.h"
58	#include "theme-parser.h"
59	#include "util.h"
60	#include "gradient.h"
61	#include <ctk/ctk.h>
62	#include <string.h>
63	#include <stdlib.h>
64	#define __USE_XOPEN
65	#include <math.h>
66
67	#define CDK_COLOR_RGBA(color)((guint32) (0xff \| ((int)((color).red * 255) << 24) \| ( (int)((color).green * 255) << 16) \| ((int)((color).blue * 255) << 8))) \
68	((guint32) (0xff \| \
69	((int)((color).red * 255) << 24) \| \
70	((int)((color).green * 255) << 16) \| \
71	((int)((color).blue * 255) << 8)))
72
73	#define CDK_COLOR_RGB(color)((guint32) (((int)((color).red * 255) << 16) \| ((int)(( color).green * 255) << 8) \| ((int)((color).blue * 255)) )) \
74	((guint32) (((int)((color).red * 255) << 16) \| \
75	((int)((color).green * 255) << 8) \| \
76	((int)((color).blue * 255))))
77
78	#define ALPHA_TO_UCHAR(d)((unsigned char) ((d) * 255)) ((unsigned char) ((d) * 255))
79
80	#define DEBUG_FILL_STRUCT(s)memset ((s), 0xef, sizeof ((s))) memset ((s), 0xef, sizeof ((s)))
81	#define CLAMP_UCHAR(v)((guchar) ((((((int)v)) > ((int)255)) ? ((int)255) : ((((( int)v)) < ((int)0)) ? ((int)0) : (((int)v)))))) ((guchar) (CLAMP (((int)v), (int)0, (int)255)(((((int)v)) > ((int)255)) ? ((int)255) : (((((int)v)) < ((int)0)) ? ((int)0) : (((int)v))))))
82	#define INTENSITY(r, g, b)((r) * 0.30 + (g) * 0.59 + (b) * 0.11) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
83
84	static void ctk_style_shade (CdkRGBA *a,
85	CdkRGBA *b,
86	gdouble k);
87	static void rgb_to_hls (gdouble *r,
88	gdouble *g,
89	gdouble *b);
90	static void hls_to_rgb (gdouble *h,
91	gdouble *l,
92	gdouble *s);
93
94	/**
95	* The current theme. (Themes are singleton.)
96	*/
97	static MetaTheme meta_current_theme = NULL((void)0);
98
99	static cairo_surface_t *
100	scale_surface (cairo_surface_t *surface,
101	gdouble old_width,
102	gdouble old_height,
103	gdouble new_width,
104	gdouble new_height,
105	gboolean vertical_stripes,
106	gboolean horizontal_stripes)
107	{
108	gdouble scale_x;
109	gdouble scale_y;
110	cairo_content_t content;
111	gint width;
112	gint height;
113	cairo_surface_t *scaled;
114	cairo_t *cr;
115
116	scale_x = new_width / old_width;
117	scale_y = new_height / old_height;
118
119	if (horizontal_stripes && !vertical_stripes)
120	{
121	new_width = old_width;
122	scale_x = 1.0;
123	}
124	else if (vertical_stripes && !horizontal_stripes)
125	{
126	new_height = old_height;
127	scale_y = 1.0;
128	}
129
130	content = CAIRO_CONTENT_COLOR_ALPHA;
131	width = ceil (new_width);
132	height = ceil (new_height);
133
134	scaled = cairo_surface_create_similar (surface, content, width, height);
135	cr = cairo_create (scaled);
136
137	cairo_scale (cr, scale_x, scale_y);
138	cairo_set_source_surface (cr, surface, 0, 0);
139
140	cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_PAD);
141
142	cairo_paint (cr);
143	cairo_destroy (cr);
144
145	return scaled;
146	}
147
148	static cairo_surface_t *
149	get_surface_from_pixbuf (GdkPixbuf *pixbuf,
150	MetaImageFillType fill_type,
151	gdouble width,
152	gdouble height,
153	gboolean vertical_stripes,
154	gboolean horizontal_stripes)
155	{
156	gdouble pixbuf_width;
157	gdouble pixbuf_height;
158	cairo_surface_t *surface;
159	cairo_content_t content;
160	cairo_surface_t *copy;
161	cairo_t *cr;
162
163	pixbuf_width = gdk_pixbuf_get_width (pixbuf);
164	pixbuf_height = gdk_pixbuf_get_height (pixbuf);
165	surface = cdk_cairo_surface_create_from_pixbuf (pixbuf, 1, NULL((void*)0));
166
167	if (pixbuf_width == width && pixbuf_height == height)
168	{
169	return surface;
170	}
171
172	if (fill_type != META_IMAGE_FILL_TILE)
173	{
174	cairo_surface_t *scaled;
175
176	scaled = scale_surface (surface, pixbuf_width, pixbuf_height,
177	width, height, vertical_stripes,
178	horizontal_stripes);
179
180	cairo_surface_destroy (surface);
181	surface = scaled;
182	}
183
184	content = CAIRO_CONTENT_COLOR_ALPHA;
185	width = ceil (width);
186	height = ceil (height);
187
188	copy = cairo_surface_create_similar (surface, content, width, height);
189	cr = cairo_create (copy);
190
191	cairo_set_source_surface (cr, surface, 0, 0);
192
193	if (fill_type == META_IMAGE_FILL_TILE \|\|
194	vertical_stripes \|\| horizontal_stripes)
195	{
196	cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
197	}
198
199	cairo_paint (cr);
200	cairo_destroy (cr);
201
202	cairo_surface_destroy (surface);
203
204	return copy;
205	}
206
207	static GdkPixbuf *
208	colorize_pixbuf (GdkPixbuf *orig,
209	CdkRGBA *new_color)
210	{
211	GdkPixbuf *pixbuf;
212	double intensity;
213	int x, y;
214	const guchar *src;
215	int orig_rowstride;
216	int dest_rowstride;
217	int width, height;
218	gboolean has_alpha;
219	const guchar *src_pixels;
220	guchar *dest_pixels;
221
222	pixbuf = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (orig), gdk_pixbuf_get_has_alpha (orig),
223	gdk_pixbuf_get_bits_per_sample (orig),
224	gdk_pixbuf_get_width (orig), gdk_pixbuf_get_height (orig));
225
226	if (pixbuf == NULL((void*)0))
227	return NULL((void*)0);
228
229	orig_rowstride = gdk_pixbuf_get_rowstride (orig);
230	dest_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
231	width = gdk_pixbuf_get_width (pixbuf);
232	height = gdk_pixbuf_get_height (pixbuf);
233	has_alpha = gdk_pixbuf_get_has_alpha (orig);
234	src_pixels = gdk_pixbuf_get_pixels (orig);
235	dest_pixels = gdk_pixbuf_get_pixels (pixbuf);
236
237	for (y = 0; y < height; y++)
238	{
239	guchar *dest;
240
241	src = src_pixels + y * orig_rowstride;
242	dest = dest_pixels + y * dest_rowstride;
243
244	for (x = 0; x < width; x++)
245	{
246	double dr, dg, db;
247
248	intensity = INTENSITY (src[0], src[1], src[2])((src[0]) * 0.30 + (src[1]) * 0.59 + (src[2]) * 0.11) / 255.0;
249
250	if (intensity <= 0.5)
251	{
252	/* Go from black at intensity = 0.0 to new_color at intensity = 0.5 */
253	dr = new_color->red * intensity * 2.0;
254	dg = new_color->green * intensity * 2.0;
255	db = new_color->blue * intensity * 2.0;
256	}
257	else
258	{
259	/* Go from new_color at intensity = 0.5 to white at intensity = 1.0 */
260	dr = new_color->red + (1.0 - new_color->red) * (intensity - 0.5) * 2.0;
261	dg = new_color->green + (1.0 - new_color->green) * (intensity - 0.5) * 2.0;
262	db = new_color->blue + (1.0 - new_color->blue) * (intensity - 0.5) * 2.0;
263	}
264
265	dest[0] = CLAMP_UCHAR (255 * dr)((guchar) ((((((int)255 * dr)) > ((int)255)) ? ((int)255) : (((((int)255 * dr)) < ((int)0)) ? ((int)0) : (((int)255 * dr))))));
266	dest[1] = CLAMP_UCHAR (255 * dg)((guchar) ((((((int)255 * dg)) > ((int)255)) ? ((int)255) : (((((int)255 * dg)) < ((int)0)) ? ((int)0) : (((int)255 * dg))))));
267	dest[2] = CLAMP_UCHAR (255 * db)((guchar) ((((((int)255 * db)) > ((int)255)) ? ((int)255) : (((((int)255 * db)) < ((int)0)) ? ((int)0) : (((int)255 * db))))));
268
269	if (has_alpha)
270	{
271	dest[3] = src[3];
272	src += 4;
273	dest += 4;
274	}
275	else
276	{
277	src += 3;
278	dest += 3;
279	}
280	}
281	}
282
283	return pixbuf;
284	}
285
286	static void
287	color_composite (const CdkRGBA *bg,
288	const CdkRGBA *fg,
289	double alpha,
290	CdkRGBA *color)
291	{
292	color = bg;
293	color->red = color->red + (fg->red - color->red) * alpha;
294	color->green = color->green + (fg->green - color->green) * alpha;
295	color->blue = color->blue + (fg->blue - color->blue) * alpha;
296	}
297
298	/**
299	* Sets all the fields of a border to dummy values.
300	*
301	* \param border The border whose fields should be reset.
302	*/
303	static void
304	init_border (CtkBorder *border)
305	{
306	border->top = -1;
307	border->bottom = -1;
308	border->left = -1;
309	border->right = -1;
310	}
311
312	/**
313	* Creates a new, empty MetaFrameLayout. The fields will be set to dummy
314	* values.
315	*
316	* \return The newly created MetaFrameLayout.
317	*/
318	MetaFrameLayout*
319	meta_frame_layout_new (void)
320	{
321	MetaFrameLayout *layout;
322
323	layout = g_new0 (MetaFrameLayout, 1)((MetaFrameLayout *) g_malloc0_n ((1), sizeof (MetaFrameLayout )));
324
325	layout->refcount = 1;
326
327	/* Fill with -1 values to detect invalid themes */
328	layout->left_width = -1;
329	layout->right_width = -1;
330	layout->bottom_height = -1;
331
332	layout->invisible_border.left = 10;
333	layout->invisible_border.right = 10;
334	layout->invisible_border.bottom = 10;
335	layout->invisible_border.top = 10;
336
337	init_border (&layout->title_border);
338
339	layout->title_vertical_pad = -1;
340
341	layout->right_titlebar_edge = -1;
342	layout->left_titlebar_edge = -1;
343
344	layout->button_sizing = META_BUTTON_SIZING_LAST;
345	layout->button_aspect = 1.0;
346	layout->button_width = -1;
347	layout->button_height = -1;
348
349	layout->has_title = TRUE(!(0));
350	layout->title_scale = 1.0;
351
352	init_border (&layout->button_border);
353
354	return layout;
355	}
356
357	/**
358	*
359	*/
360	static gboolean
361	validate_border (const CtkBorder *border,
362	const char **bad)
363	{
364	bad = NULL((void)0);
365
366	if (border->top < 0)
367	*bad = _("top")dgettext ("croma", "top");
368	else if (border->bottom < 0)
369	*bad = _("bottom")dgettext ("croma", "bottom");
370	else if (border->left < 0)
371	*bad = _("left")dgettext ("croma", "left");
372	else if (border->right < 0)
373	*bad = _("right")dgettext ("croma", "right");
374
375	return bad == NULL((void)0);
376	}
377
378	/**
379	* Ensures that the theme supplied a particular dimension. When a
380	* MetaFrameLayout is created, all its integer fields are set to -1
381	* by meta_frame_layout_new(). After an instance of this type
382	* should have been initialised, this function checks that
383	* a given field is not still at -1. It is never called directly, but
384	* rather via the CHECK_GEOMETRY_VALUE and CHECK_GEOMETRY_BORDER
385	* macros.
386	*
387	* \param val The value to check
388	* \param name The name to use in the error message
389	* \param[out] error Set to an error if val was not initialised
390	*/
391	static gboolean
392	validate_geometry_value (int val,
393	const char *name,
394	GError **error)
395	{
396	if (val < 0)
397	{
398	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
399	META_THEME_ERROR_FRAME_GEOMETRY,
400	_("frame geometry does not specify \"%s\" dimension")dgettext ("croma", "frame geometry does not specify \"%s\" dimension" ),
401	name);
402	return FALSE(0);
403	}
404	else
405	return TRUE(!(0));
406	}
407
408	static gboolean
409	validate_geometry_border (const CtkBorder *border,
410	const char *name,
411	GError **error)
412	{
413	const char *bad;
414
415	if (!validate_border (border, &bad))
416	{
417	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
418	META_THEME_ERROR_FRAME_GEOMETRY,
419	_("frame geometry does not specify dimension \"%s\" for border \"%s\"")dgettext ("croma", "frame geometry does not specify dimension \"%s\" for border \"%s\"" ),
420	bad, name);
421	return FALSE(0);
422	}
423	else
424	return TRUE(!(0));
425	}
426
427	gboolean
428	meta_frame_layout_validate (const MetaFrameLayout *layout,
429	GError **error)
430	{
431	g_return_val_if_fail (layout != NULL, FALSE)do { if ((layout != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "layout != NULL"); return ((0)); } } while (0);
432
433	#define CHECK_GEOMETRY_VALUE(vname)if (!validate_geometry_value (layout->vname, "vname", error )) return (0) if (!validate_geometry_value (layout->vname, #vname, error)) return FALSE(0)
434
435	#define CHECK_GEOMETRY_BORDER(bname)if (!validate_geometry_border (&layout->bname, "bname" , error)) return (0) if (!validate_geometry_border (&layout->bname, #bname, error)) return FALSE(0)
436
437	CHECK_GEOMETRY_VALUE (left_width)if (!validate_geometry_value (layout->left_width, "left_width" , error)) return (0);
438	CHECK_GEOMETRY_VALUE (right_width)if (!validate_geometry_value (layout->right_width, "right_width" , error)) return (0);
439	CHECK_GEOMETRY_VALUE (bottom_height)if (!validate_geometry_value (layout->bottom_height, "bottom_height" , error)) return (0);
440
441	CHECK_GEOMETRY_BORDER (title_border)if (!validate_geometry_border (&layout->title_border, "title_border" , error)) return (0);
442
443	CHECK_GEOMETRY_VALUE (title_vertical_pad)if (!validate_geometry_value (layout->title_vertical_pad, "title_vertical_pad" , error)) return (0);
444
445	CHECK_GEOMETRY_VALUE (right_titlebar_edge)if (!validate_geometry_value (layout->right_titlebar_edge, "right_titlebar_edge", error)) return (0);
446	CHECK_GEOMETRY_VALUE (left_titlebar_edge)if (!validate_geometry_value (layout->left_titlebar_edge, "left_titlebar_edge" , error)) return (0);
447
448	switch (layout->button_sizing)
449	{
450	case META_BUTTON_SIZING_ASPECT:
451	if (layout->button_aspect < (0.1) \|\|
452	layout->button_aspect > (15.0))
453	{
454	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
455	META_THEME_ERROR_FRAME_GEOMETRY,
456	_("Button aspect ratio %g is not reasonable")dgettext ("croma", "Button aspect ratio %g is not reasonable" ),
457	layout->button_aspect);
458	return FALSE(0);
459	}
460	break;
461	case META_BUTTON_SIZING_FIXED:
462	CHECK_GEOMETRY_VALUE (button_width)if (!validate_geometry_value (layout->button_width, "button_width" , error)) return (0);
463	CHECK_GEOMETRY_VALUE (button_height)if (!validate_geometry_value (layout->button_height, "button_height" , error)) return (0);
464	break;
465	case META_BUTTON_SIZING_LAST:
466	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
467	META_THEME_ERROR_FRAME_GEOMETRY,
468	_("Frame geometry does not specify size of buttons")dgettext ("croma", "Frame geometry does not specify size of buttons" ));
469	return FALSE(0);
470	}
471
472	CHECK_GEOMETRY_BORDER (button_border)if (!validate_geometry_border (&layout->button_border, "button_border", error)) return (0);
473
474	return TRUE(!(0));
475	}
476
477	MetaFrameLayout*
478	meta_frame_layout_copy (const MetaFrameLayout *src)
479	{
480	MetaFrameLayout *layout;
481
482	layout = g_new0 (MetaFrameLayout, 1)((MetaFrameLayout *) g_malloc0_n ((1), sizeof (MetaFrameLayout )));
483
484	layout = src;
485
486	layout->refcount = 1;
487
488	return layout;
489	}
490
491	void
492	meta_frame_layout_ref (MetaFrameLayout *layout)
493	{
494	g_return_if_fail (layout != NULL)do { if ((layout != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "layout != NULL"); return ; } } while (0);
495
496	layout->refcount += 1;
497	}
498
499	void
500	meta_frame_layout_unref (MetaFrameLayout *layout)
501	{
502	g_return_if_fail (layout != NULL)do { if ((layout != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "layout != NULL"); return ; } } while (0);
503	g_return_if_fail (layout->refcount > 0)do { if ((layout->refcount > 0)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "layout->refcount > 0" ); return; } } while (0);
504
505	layout->refcount -= 1;
506
507	if (layout->refcount == 0)
508	{
509	DEBUG_FILL_STRUCT (layout)memset ((layout), 0xef, sizeof (*(layout)));
510	g_free (layout);
511	}
512	}
513
514	void
515	meta_frame_layout_get_borders (const MetaFrameLayout *layout,
516	int text_height,
517	MetaFrameFlags flags,
518	MetaFrameBorders *borders)
519	{
520	int buttons_height, title_height;
521
522	meta_frame_borders_clear (borders);
523
524	/* For a full-screen window, we don't have any borders, visible or not. */
525	if (flags & META_FRAME_FULLSCREEN)
526	return;
527
528	g_return_if_fail (layout != NULL)do { if ((layout != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "layout != NULL"); return ; } } while (0);
529
530	if (!layout->has_title)
531	text_height = 0;
532
533	buttons_height = layout->button_height +
534	layout->button_border.top + layout->button_border.bottom;
535	title_height = text_height +
536	layout->title_vertical_pad +
537	layout->title_border.top + layout->title_border.bottom;
538
539	borders->visible.top = MAX (buttons_height, title_height)(((buttons_height) > (title_height)) ? (buttons_height) : ( title_height));
540	borders->visible.left = layout->left_width;
541	borders->visible.right = layout->right_width;
542	borders->visible.bottom = layout->bottom_height;
543
544	if (flags & META_FRAME_ALLOWS_HORIZONTAL_RESIZE)
545	{
546	borders->invisible.left = layout->invisible_border.left;
547	borders->invisible.right = layout->invisible_border.right;
548	}
549
550	if (flags & META_FRAME_ALLOWS_VERTICAL_RESIZE)
551	{
552	borders->invisible.bottom = layout->invisible_border.bottom;
553	borders->invisible.top = layout->invisible_border.top;
554	}
555
556	if (flags & META_FRAME_SHADED)
557	borders->visible.bottom = borders->invisible.bottom = 0;
558
559	borders->total.left = borders->invisible.left + borders->visible.left;
560	borders->total.right = borders->invisible.right + borders->visible.right;
561	borders->total.bottom = borders->invisible.bottom + borders->visible.bottom;
562	borders->total.top = borders->invisible.top + borders->visible.top;
563	}
564
565	static MetaButtonType
566	map_button_function_to_type (MetaButtonFunction function)
567	{
568	switch (function)
569	{
570	case META_BUTTON_FUNCTION_SHADE:
571	return META_BUTTON_TYPE_SHADE;
572	case META_BUTTON_FUNCTION_ABOVE:
573	return META_BUTTON_TYPE_ABOVE;
574	case META_BUTTON_FUNCTION_STICK:
575	return META_BUTTON_TYPE_STICK;
576	case META_BUTTON_FUNCTION_UNSHADE:
577	return META_BUTTON_TYPE_UNSHADE;
578	case META_BUTTON_FUNCTION_UNABOVE:
579	return META_BUTTON_TYPE_UNABOVE;
580	case META_BUTTON_FUNCTION_UNSTICK:
581	return META_BUTTON_TYPE_UNSTICK;
582	case META_BUTTON_FUNCTION_MENU:
583	return META_BUTTON_TYPE_MENU;
584	case META_BUTTON_FUNCTION_APPMENU:
585	return META_BUTTON_TYPE_APPMENU;
586	case META_BUTTON_FUNCTION_MINIMIZE:
587	return META_BUTTON_TYPE_MINIMIZE;
588	case META_BUTTON_FUNCTION_MAXIMIZE:
589	return META_BUTTON_TYPE_MAXIMIZE;
590	case META_BUTTON_FUNCTION_CLOSE:
591	return META_BUTTON_TYPE_CLOSE;
592	case META_BUTTON_FUNCTION_LAST:
593	return META_BUTTON_TYPE_LAST;
594	}
595
596	return META_BUTTON_TYPE_LAST;
597	}
598
599	static MetaButtonSpace*
600	rect_for_function (MetaFrameGeometry *fgeom,
601	MetaFrameFlags flags,
602	MetaButtonFunction function,
603	MetaTheme *theme)
604	{
605
606	/* Firstly, check version-specific things. */
607
608	if (META_THEME_ALLOWS(theme, META_THEME_SHADE_STICK_ABOVE_BUTTONS)(theme->format_version >= 2))
609	{
610	switch (function)
611	{
612	case META_BUTTON_FUNCTION_SHADE:
613	if ((flags & META_FRAME_ALLOWS_SHADE) && !(flags & META_FRAME_SHADED))
614	return &fgeom->shade_rect;
615	else
616	return NULL((void*)0);
617	case META_BUTTON_FUNCTION_ABOVE:
618	if (!(flags & META_FRAME_ABOVE))
619	return &fgeom->above_rect;
620	else
621	return NULL((void*)0);
622	case META_BUTTON_FUNCTION_STICK:
623	if (!(flags & META_FRAME_STUCK))
624	return &fgeom->stick_rect;
625	else
626	return NULL((void*)0);
627	case META_BUTTON_FUNCTION_UNSHADE:
628	if ((flags & META_FRAME_ALLOWS_SHADE) && (flags & META_FRAME_SHADED))
629	return &fgeom->unshade_rect;
630	else
631	return NULL((void*)0);
632	case META_BUTTON_FUNCTION_UNABOVE:
633	if (flags & META_FRAME_ABOVE)
634	return &fgeom->unabove_rect;
635	else
636	return NULL((void*)0);
637	case META_BUTTON_FUNCTION_UNSTICK:
638	if (flags & META_FRAME_STUCK)
639	return &fgeom->unstick_rect;
640	default:
641	/* just go on to the next switch block */;
642	}
643	}
644
645	/* now consider the buttons which exist in all versions */
646
647	switch (function)
648	{
649	case META_BUTTON_FUNCTION_MENU:
650	if (flags & META_FRAME_ALLOWS_MENU)
651	return &fgeom->menu_rect;
652	else
653	return NULL((void*)0);
654	case META_BUTTON_FUNCTION_APPMENU:
655	if (flags & META_FRAME_ALLOWS_APPMENU)
656	return &fgeom->appmenu_rect;
657	else
658	return NULL((void*)0);
659	case META_BUTTON_FUNCTION_MINIMIZE:
660	if (flags & META_FRAME_ALLOWS_MINIMIZE)
661	return &fgeom->min_rect;
662	else
663	return NULL((void*)0);
664	case META_BUTTON_FUNCTION_MAXIMIZE:
665	if (flags & META_FRAME_ALLOWS_MAXIMIZE)
666	return &fgeom->max_rect;
667	else
668	return NULL((void*)0);
669	case META_BUTTON_FUNCTION_CLOSE:
670	if (flags & META_FRAME_ALLOWS_DELETE)
671	return &fgeom->close_rect;
672	else
673	return NULL((void*)0);
674	case META_BUTTON_FUNCTION_STICK:
675	case META_BUTTON_FUNCTION_SHADE:
676	case META_BUTTON_FUNCTION_ABOVE:
677	case META_BUTTON_FUNCTION_UNSTICK:
678	case META_BUTTON_FUNCTION_UNSHADE:
679	case META_BUTTON_FUNCTION_UNABOVE:
680	/* we are being asked for a >v1 button which hasn't been handled yet,
681	* so obviously we're not in a theme which supports that version.
682	* therefore, we don't show the button. return NULL and all will
683	* be well.
684	*/
685	return NULL((void*)0);
686
687	case META_BUTTON_FUNCTION_LAST:
688	return NULL((void*)0);
689	}
690
691	return NULL((void*)0);
692	}
693
694	static gboolean
695	strip_button (MetaButtonSpace *func_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST],
696	CdkRectangle *bg_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST],
697	int *n_rects,
698	MetaButtonSpace *to_strip)
699	{
700	int i;
701
702	i = 0;
703	while (i < *n_rects)
704	{
705	if (func_rects[i] == to_strip)
706	{
707	*n_rects -= 1;
708
709	/* shift the other rects back in the array */
710	while (i < *n_rects)
711	{
712	func_rects[i] = func_rects[i+1];
713	bg_rects[i] = bg_rects[i+1];
714
715	++i;
716	}
717
718	func_rects[i] = NULL((void*)0);
719	bg_rects[i] = NULL((void*)0);
720
721	return TRUE(!(0));
722	}
723
724	++i;
725	}
726
727	return FALSE(0); /* did not strip anything */
728	}
729
730	void
731	meta_frame_layout_calc_geometry (const MetaFrameLayout *layout,
732	int text_height,
733	MetaFrameFlags flags,
734	int client_width,
735	int client_height,
736	const MetaButtonLayout *button_layout,
737	MetaFrameGeometry *fgeom,
738	MetaTheme *theme)
739	{
740	int i, n_left, n_right, n_left_spacers, n_right_spacers;
741	int x;
742	int button_y;
743	int title_right_edge;
744	int width, height;
745	int button_width, button_height;
746	int min_size_for_rounding;
747
748	/* the left/right rects in order; the max # of rects
749	* is the number of button functions
750	*/
751	MetaButtonSpace *left_func_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
752	MetaButtonSpace *right_func_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
753	CdkRectangle *left_bg_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
754	gboolean left_buttons_has_spacer[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
755	CdkRectangle *right_bg_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
756	gboolean right_buttons_has_spacer[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
757
758	MetaFrameBorders borders;
759
760	meta_frame_layout_get_borders (layout, text_height,
761	flags,
762	&borders);
763
764	fgeom->borders = borders;
765
766	width = client_width + borders.total.left + borders.total.right;
767
768	height = ((flags & META_FRAME_SHADED) ? 0: client_height) +
769	borders.total.top + borders.total.bottom;
770
771	fgeom->width = width;
772	fgeom->height = height;
773
774	fgeom->top_titlebar_edge = layout->title_border.top;
775	fgeom->bottom_titlebar_edge = layout->title_border.bottom;
776	fgeom->left_titlebar_edge = layout->left_titlebar_edge;
777	fgeom->right_titlebar_edge = layout->right_titlebar_edge;
778
779	switch (layout->button_sizing)
780	{
781	case META_BUTTON_SIZING_ASPECT:
782	button_height = borders.visible.top - layout->button_border.top - layout->button_border.bottom;
783	button_width = button_height / layout->button_aspect;
784	break;
785	case META_BUTTON_SIZING_FIXED:
786	button_width = layout->button_width;
787	button_height = layout->button_height;
788	break;
789	case META_BUTTON_SIZING_LAST:
790	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 790, (( const char) (__func__)), ((void)0)); } while (0);
791	default:
792	button_width = -1;
793	button_height = -1;
794	}
795
796	/* FIXME all this code sort of pretends that duplicate buttons
797	* with the same function are allowed, but that breaks the
798	* code in frames.c, so isn't really allowed right now.
799	* Would need left_close_rect, right_close_rect, etc.
800	*/
801
802	/* Init all button rects to 0, lame hack */
803	memset (ADDRESS_OF_BUTTON_RECTS (fgeom)(((char*)(fgeom)) + ((glong) __builtin_offsetof(MetaFrameGeometry , close_rect))), '\0',
804	LENGTH_OF_BUTTON_RECTS(((glong) __builtin_offsetof(MetaFrameGeometry, right_single_background )) + sizeof (CdkRectangle) - ((glong) __builtin_offsetof(MetaFrameGeometry , close_rect))));
805
806	n_left = 0;
807	n_right = 0;
808	n_left_spacers = 0;
809	n_right_spacers = 0;
810
811	if (!layout->hide_buttons)
812	{
813	/* Try to fill in rects */
814	for (i = 0; i < MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST && button_layout->left_buttons[i] != META_BUTTON_FUNCTION_LAST; i++)
815	{
816	left_func_rects[n_left] = rect_for_function (fgeom, flags,
817	button_layout->left_buttons[i],
818	theme);
819	if (left_func_rects[n_left] != NULL((void*)0))
820	{
821	left_buttons_has_spacer[n_left] = button_layout->left_buttons_has_spacer[i];
822	if (button_layout->left_buttons_has_spacer[i])
823	++n_left_spacers;
824
825	++n_left;
826	}
827	}
828
829	for (i = 0; i < MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST && button_layout->right_buttons[i] != META_BUTTON_FUNCTION_LAST; i++)
830	{
831	right_func_rects[n_right] = rect_for_function (fgeom, flags,
832	button_layout->right_buttons[i],
833	theme);
834	if (right_func_rects[n_right] != NULL((void*)0))
835	{
836	right_buttons_has_spacer[n_right] = button_layout->right_buttons_has_spacer[i];
837	if (button_layout->right_buttons_has_spacer[i])
838	++n_right_spacers;
839
840	++n_right;
841	}
842	}
843	}
844
845	for (i = 0; i < MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST; i++)
846	{
847	left_bg_rects[i] = NULL((void*)0);
848	right_bg_rects[i] = NULL((void*)0);
849	}
850
851	for (i = 0; i < n_left; i++)
852	{
853	if (n_left == 1)
854	left_bg_rects[i] = &fgeom->left_single_background;
855	else if (i == 0)
856	left_bg_rects[i] = &fgeom->left_left_background;
857	else if (i == (n_left - 1))
858	left_bg_rects[i] = &fgeom->left_right_background;
859	else
860	left_bg_rects[i] = &fgeom->left_middle_backgrounds[i - 1];
861	}
862
863	for (i = 0; i < n_right; i++)
864	{
865	if (n_right == 1)
866	right_bg_rects[i] = &fgeom->right_single_background;
867	else if (i == (n_right - 1))
868	right_bg_rects[i] = &fgeom->right_right_background;
869	else if (i == 0)
870	right_bg_rects[i] = &fgeom->right_left_background;
871	else
872	right_bg_rects[i] = &fgeom->right_middle_backgrounds[i - 1];
873	}
874
875	/* Be sure buttons fit */
876	while (n_left > 0 \|\| n_right > 0)
877	{
878	int space_used_by_buttons;
879	int space_available;
880
881	space_available = fgeom->width - layout->left_titlebar_edge - layout->right_titlebar_edge;
882
883	space_used_by_buttons = 0;
884
885	space_used_by_buttons += button_width * n_left;
886	space_used_by_buttons += (button_width * 0.75) * n_left_spacers;
887	space_used_by_buttons += layout->button_border.left * n_left;
888	space_used_by_buttons += layout->button_border.right * n_left;
889
890	space_used_by_buttons += button_width * n_right;
891	space_used_by_buttons += (button_width * 0.75) * n_right_spacers;
892	space_used_by_buttons += layout->button_border.left * n_right;
893	space_used_by_buttons += layout->button_border.right * n_right;
894
895	if (space_used_by_buttons <= space_available)
896	break; /* Everything fits, bail out */
897
898	/* First try to remove separators */
899	if (n_left_spacers > 0)
900	{
901	left_buttons_has_spacer[--n_left_spacers] = FALSE(0);
902	continue;
903	}
904	else if (n_right_spacers > 0)
905	{
906	right_buttons_has_spacer[--n_right_spacers] = FALSE(0);
907	continue;
908	}
909
910	/* Otherwise we need to shave out a button. Shave
911	* above, stick, shade, min, max, close, then menu (menu is most useful);
912	* prefer the default button locations.
913	*/
914	if (strip_button (left_func_rects, left_bg_rects,
915	&n_left, &fgeom->above_rect))
916	continue;
917	else if (strip_button (right_func_rects, right_bg_rects,
918	&n_right, &fgeom->above_rect))
919	continue;
920	else if (strip_button (left_func_rects, left_bg_rects,
921	&n_left, &fgeom->stick_rect))
922	continue;
923	else if (strip_button (right_func_rects, right_bg_rects,
924	&n_right, &fgeom->stick_rect))
925	continue;
926	else if (strip_button (left_func_rects, left_bg_rects,
927	&n_left, &fgeom->shade_rect))
928	continue;
929	else if (strip_button (right_func_rects, right_bg_rects,
930	&n_right, &fgeom->shade_rect))
931	continue;
932	else if (strip_button (left_func_rects, left_bg_rects,
933	&n_left, &fgeom->min_rect))
934	continue;
935	else if (strip_button (right_func_rects, right_bg_rects,
936	&n_right, &fgeom->min_rect))
937	continue;
938	else if (strip_button (left_func_rects, left_bg_rects,
939	&n_left, &fgeom->max_rect))
940	continue;
941	else if (strip_button (right_func_rects, right_bg_rects,
942	&n_right, &fgeom->max_rect))
943	continue;
944	else if (strip_button (left_func_rects, left_bg_rects,
945	&n_left, &fgeom->close_rect))
946	continue;
947	else if (strip_button (right_func_rects, right_bg_rects,
948	&n_right, &fgeom->close_rect))
949	continue;
950	else if (strip_button (right_func_rects, right_bg_rects,
951	&n_right, &fgeom->menu_rect))
952	continue;
953	else if (strip_button (left_func_rects, left_bg_rects,
954	&n_left, &fgeom->menu_rect))
955	continue;
956	else if (strip_button (right_func_rects, right_bg_rects,
957	&n_right, &fgeom->appmenu_rect))
958	continue;
959	else if (strip_button (left_func_rects, left_bg_rects,
960	&n_left, &fgeom->appmenu_rect))
961	continue;
962	else
963	{
964	meta_bug ("Could not find a button to strip. n_left = %d n_right = %d\n",
965	n_left, n_right);
966	}
967	}
968
969	/* Save the button layout */
970	fgeom->button_layout = *button_layout;
971	fgeom->n_left_buttons = n_left;
972	fgeom->n_right_buttons = n_right;
973
974	/* center buttons vertically */
975	button_y = (borders.visible.top -
976	(button_height + layout->button_border.top + layout->button_border.bottom)) / 2 + layout->button_border.top + borders.invisible.top;
977
978	/* right edge of farthest-right button */
979	x = width - layout->right_titlebar_edge - borders.invisible.right;
980
981	i = n_right - 1;
982	while (i >= 0)
983	{
984	MetaButtonSpace *rect;
985
986	if (x < 0) /* if we go negative, leave the buttons we don't get to as 0-width */
987	break;
988
989	rect = right_func_rects[i];
990	rect->visible.x = x - layout->button_border.right - button_width;
991	if (right_buttons_has_spacer[i])
992	rect->visible.x -= (button_width * 0.75);
993
994	rect->visible.y = button_y;
995	rect->visible.width = button_width;
996	rect->visible.height = button_height;
997
998	if (flags & META_FRAME_MAXIMIZED \|\|
999	flags & META_FRAME_TILED_LEFT \|\|
1000	flags & META_FRAME_TILED_RIGHT)
1001	{
1002	rect->clickable.x = rect->visible.x;
1003	rect->clickable.y = rect->visible.y;
1004	rect->clickable.width = button_width;
1005	rect->clickable.height = button_height;
1006
1007	if (i == n_right - 1)
1008	rect->clickable.width += layout->right_titlebar_edge + layout->right_width + layout->button_border.right;
1009
1010	}
1011	else
1012	memmove (&(rect->clickable), &(rect->visible), sizeof(rect->clickable));
1013
1014	*(right_bg_rects[i]) = rect->visible;
1015
1016	x = rect->visible.x - layout->button_border.left;
1017
1018	--i;
1019	}
1020
1021	/* save right edge of titlebar for later use */
1022	title_right_edge = x - layout->title_border.right;
1023
1024	/* Now x changes to be position from the left and we go through
1025	* the left-side buttons
1026	*/
1027	x = layout->left_titlebar_edge + borders.invisible.left;
1028	for (i = 0; i < n_left; i++)
1029	{
1030	MetaButtonSpace *rect;
1031
1032	rect = left_func_rects[i];
1033
1034	rect->visible.x = x + layout->button_border.left;
1035	rect->visible.y = button_y;
1036	rect->visible.width = button_width;
1037	rect->visible.height = button_height;
1038
1039	if (flags & META_FRAME_MAXIMIZED)
1040	{
1041	rect->clickable.x = rect->visible.x;
1042	rect->clickable.y = rect->visible.y;
1043	rect->clickable.width = button_width;
1044	rect->clickable.height = button_height;
1045	}
1046	else
1047	memmove (&(rect->clickable), &(rect->visible), sizeof(rect->clickable));
1048
1049	x = rect->visible.x + rect->visible.width + layout->button_border.right;
1050	if (left_buttons_has_spacer[i])
1051	x += (button_width * 0.75);
1052
1053	*(left_bg_rects[i]) = rect->visible;
1054	}
1055
1056	/* We always fill as much vertical space as possible with title rect,
1057	* rather than centering it like the buttons
1058	*/
1059	fgeom->title_rect.x = x + layout->title_border.left;
1060	fgeom->title_rect.y = layout->title_border.top + borders.invisible.top;
1061	fgeom->title_rect.width = title_right_edge - fgeom->title_rect.x;
1062	fgeom->title_rect.height = borders.visible.top - layout->title_border.top - layout->title_border.bottom;
1063
1064	/* Nuke title if it won't fit */
1065	if (fgeom->title_rect.width < 0 \|\|
1066	fgeom->title_rect.height < 0)
1067	{
1068	fgeom->title_rect.width = 0;
1069	fgeom->title_rect.height = 0;
1070	}
1071
1072	if (flags & META_FRAME_SHADED)
1073	min_size_for_rounding = 0;
1074	else
1075	min_size_for_rounding = 5;
1076
1077	fgeom->top_left_corner_rounded_radius = 0;
1078	fgeom->top_right_corner_rounded_radius = 0;
1079	fgeom->bottom_left_corner_rounded_radius = 0;
1080	fgeom->bottom_right_corner_rounded_radius = 0;
1081
1082	if (borders.visible.top + borders.visible.left >= min_size_for_rounding)
1083	fgeom->top_left_corner_rounded_radius = layout->top_left_corner_rounded_radius;
1084	if (borders.visible.top + borders.visible.right >= min_size_for_rounding)
1085	fgeom->top_right_corner_rounded_radius = layout->top_right_corner_rounded_radius;
1086
1087	if (borders.visible.bottom + borders.visible.left >= min_size_for_rounding)
1088	fgeom->bottom_left_corner_rounded_radius = layout->bottom_left_corner_rounded_radius;
1089	if (borders.visible.bottom + borders.visible.right >= min_size_for_rounding)
1090	fgeom->bottom_right_corner_rounded_radius = layout->bottom_right_corner_rounded_radius;
1091	}
1092
1093	MetaGradientSpec*
1094	meta_gradient_spec_new (MetaGradientType type)
1095	{
1096	MetaGradientSpec *spec;
1097
1098	spec = g_new (MetaGradientSpec, 1)((MetaGradientSpec *) g_malloc_n ((1), sizeof (MetaGradientSpec )));
1099
1100	spec->type = type;
1101	spec->color_specs = NULL((void*)0);
1102
1103	return spec;
1104	}
1105
1106	static cairo_pattern_t *
1107	create_cairo_pattern_from_gradient_spec (const MetaGradientSpec *spec,
1108	const MetaAlphaGradientSpec *alpha_spec,
1109	CtkStyleContext *context)
1110	{
1111	gint n_colors;
1112	cairo_pattern_t *pattern;
1113	GSList *tmp;
1114	gint i;
1115
1116	n_colors = g_slist_length (spec->color_specs);
1117	if (n_colors == 0)
1118	return NULL((void*)0);
1119
1120	if (alpha_spec != NULL((void*)0) && alpha_spec->n_alphas != 1)
1121	g_assert (n_colors == alpha_spec->n_alphas)do { if (n_colors == alpha_spec->n_alphas) ; else g_assertion_message_expr ("croma", "ui/theme.c", 1121, ((const char*) (__func__)), "n_colors == alpha_spec->n_alphas" ); } while (0);
1122
1123	if (spec->type == META_GRADIENT_HORIZONTAL)
1124	pattern = cairo_pattern_create_linear (0, 0, 1, 0);
1125	else if (spec->type == META_GRADIENT_VERTICAL)
1126	pattern = cairo_pattern_create_linear (0, 0, 0, 1);
1127	else if (spec->type == META_GRADIENT_DIAGONAL)
1128	pattern = cairo_pattern_create_linear (0, 0, 1, 1);
1129	else
1130	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 1130, ( (const char) (__func__)), ((void)0)); } while (0);
1131
1132	i = 0;
1133	tmp = spec->color_specs;
1134	while (tmp != NULL((void*)0))
1135	{
1136	CdkRGBA color;
1137
1138	meta_color_spec_render (tmp->data, context, &color);
1139
1140	if (alpha_spec != NULL((void*)0))
1141	{
1142	gdouble alpha;
1143
1144	if (alpha_spec->n_alphas == 1)
1145	alpha = alpha_spec->alphas[0] / 255.0;
1146	else
1147	alpha = alpha_spec->alphas[i] / 255.0;
1148
1149	cairo_pattern_add_color_stop_rgba (pattern, i / (gfloat) (n_colors - 1),
1150	color.red, color.green, color.blue,
1151	alpha);
1152	}
1153	else
1154	cairo_pattern_add_color_stop_rgb (pattern, i / (gfloat) (n_colors - 1),
1155	color.red, color.green, color.blue);
1156
1157	tmp = tmp->next;
1158	++i;
1159	}
1160
1161	if (cairo_pattern_status (pattern) != CAIRO_STATUS_SUCCESS)
1162	{
1163	cairo_pattern_destroy (pattern);
1164	return NULL((void*)0);
1165	}
1166
1167	return pattern;
1168	}
1169
1170	static void
1171	free_color_spec (gpointer spec, gpointer user_data)
1172	{
1173	meta_color_spec_free (spec);
1174	}
1175
1176	void
1177	meta_gradient_spec_free (MetaGradientSpec *spec)
1178	{
1179	g_return_if_fail (spec != NULL)do { if ((spec != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "spec != NULL"); return ; } } while (0);
1180
1181	g_slist_foreach (spec->color_specs, free_color_spec, NULL((void*)0));
1182	g_slist_free (spec->color_specs);
1183
1184	DEBUG_FILL_STRUCT (spec)memset ((spec), 0xef, sizeof (*(spec)));
1185	g_free (spec);
1186	}
1187
1188	void
1189	meta_gradient_spec_render (const MetaGradientSpec *spec,
1190	const MetaAlphaGradientSpec *alpha_spec,
1191	cairo_t *cr,
1192	CtkStyleContext *context,
1193	gint x,
1194	gint y,
1195	gint width,
1196	gint height)
1197	{
1198	cairo_pattern_t *pattern;
1199
1200	pattern = create_cairo_pattern_from_gradient_spec (spec, alpha_spec, context);
1201	if (pattern == NULL((void*)0))
1202	return;
1203
1204	cairo_save (cr);
1205
1206	cairo_rectangle (cr, x, y, width, height);
1207
1208	cairo_translate (cr, x, y);
1209	cairo_scale (cr, width, height);
1210
1211	cairo_set_source (cr, pattern);
1212	cairo_fill (cr);
1213	cairo_pattern_destroy (pattern);
1214
1215	cairo_restore (cr);
1216	}
1217
1218	gboolean
1219	meta_gradient_spec_validate (MetaGradientSpec *spec,
1220	GError **error)
1221	{
1222	g_return_val_if_fail (spec != NULL, FALSE)do { if ((spec != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "spec != NULL"); return ((0)); } } while (0);
1223
1224	if (g_slist_length (spec->color_specs) < 2)
1225	{
1226	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1227	META_THEME_ERROR_FAILED,
1228	_("Gradients should have at least two colors")dgettext ("croma", "Gradients should have at least two colors" ));
1229	return FALSE(0);
1230	}
1231
1232	return TRUE(!(0));
1233	}
1234
1235	MetaAlphaGradientSpec*
1236	meta_alpha_gradient_spec_new (MetaGradientType type,
1237	int n_alphas)
1238	{
1239	MetaAlphaGradientSpec *spec;
1240
1241	g_return_val_if_fail (n_alphas > 0, NULL)do { if ((n_alphas > 0)) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "n_alphas > 0"); return (((void)0)); } } while (0);
1242
1243	spec = g_new0 (MetaAlphaGradientSpec, 1)((MetaAlphaGradientSpec *) g_malloc0_n ((1), sizeof (MetaAlphaGradientSpec )));
1244
1245	spec->type = type;
1246	spec->alphas = g_new0 (unsigned char, n_alphas)((unsigned char *) g_malloc0_n ((n_alphas), sizeof (unsigned char )));
1247	spec->n_alphas = n_alphas;
1248
1249	return spec;
1250	}
1251
1252	void
1253	meta_alpha_gradient_spec_free (MetaAlphaGradientSpec *spec)
1254	{
1255	g_return_if_fail (spec != NULL)do { if ((spec != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "spec != NULL"); return ; } } while (0);
1256
1257	g_free (spec->alphas);
1258	g_free (spec);
1259	}
1260
1261	cairo_pattern_t *
1262	meta_alpha_gradient_spec_get_mask (const MetaAlphaGradientSpec *spec)
1263	{
1264	gint n_alphas;
1265	cairo_pattern_t *pattern;
1266	gint i;
1267
1268	/* Hardcoded in theme-parser.c */
1269	g_assert (spec->type == META_GRADIENT_HORIZONTAL)do { if (spec->type == META_GRADIENT_HORIZONTAL) ; else g_assertion_message_expr ("croma", "ui/theme.c", 1269, ((const char*) (__func__)), "spec->type == META_GRADIENT_HORIZONTAL" ); } while (0);
1270
1271	n_alphas = spec->n_alphas;
1272	if (n_alphas == 0)
1273	return NULL((void*)0);
1274
1275	if (n_alphas == 1)
1276	return cairo_pattern_create_rgba (0, 0, 0, spec->alphas[0] / 255.0);
1277
1278	pattern = cairo_pattern_create_linear (0, 0, 1, 0);
1279
1280	for (i = 0; i < n_alphas; i++)
1281	cairo_pattern_add_color_stop_rgba (pattern, i / (gfloat) (n_alphas - 1),
1282	0, 0, 0, spec->alphas[i] / 255.0);
1283
1284	if (cairo_pattern_status (pattern) != CAIRO_STATUS_SUCCESS)
1285	{
1286	cairo_pattern_destroy (pattern);
1287	return NULL((void*)0);
1288	}
1289
1290	return pattern;
1291	}
1292
1293	MetaColorSpec*
1294	meta_color_spec_new (MetaColorSpecType type)
1295	{
1296	MetaColorSpec *spec;
1297	MetaColorSpec dummy;
1298	int size;
1299
1300	size = G_STRUCT_OFFSET (MetaColorSpec, data)((glong) __builtin_offsetof(MetaColorSpec, data));
1301
1302	switch (type)
1303	{
1304	case META_COLOR_SPEC_BASIC:
1305	size += sizeof (dummy.data.basic);
1306	break;
1307
1308	case META_COLOR_SPEC_CTK:
1309	size += sizeof (dummy.data.ctk);
1310	break;
1311
1312	case META_COLOR_SPEC_CTK_CUSTOM:
1313	size += sizeof (dummy.data.ctkcustom);
1314	break;
1315
1316	case META_COLOR_SPEC_BLEND:
1317	size += sizeof (dummy.data.blend);
1318	break;
1319
1320	case META_COLOR_SPEC_SHADE:
1321	size += sizeof (dummy.data.shade);
1322	break;
1323	}
1324
1325	spec = g_malloc0 (size);
1326
1327	spec->type = type;
1328
1329	return spec;
1330	}
1331
1332	void
1333	meta_color_spec_free (MetaColorSpec *spec)
1334	{
1335	g_return_if_fail (spec != NULL)do { if ((spec != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "spec != NULL"); return ; } } while (0);
1336
1337	switch (spec->type)
1338	{
1339	case META_COLOR_SPEC_BASIC:
1340	DEBUG_FILL_STRUCT (&spec->data.basic)memset ((&spec->data.basic), 0xef, sizeof (*(&spec ->data.basic)));
1341	break;
1342
1343	case META_COLOR_SPEC_CTK:
1344	DEBUG_FILL_STRUCT (&spec->data.ctk)memset ((&spec->data.ctk), 0xef, sizeof (*(&spec-> data.ctk)));
1345	break;
1346
1347	case META_COLOR_SPEC_CTK_CUSTOM:
1348	if (spec->data.ctkcustom.color_name)
1349	g_free (spec->data.ctkcustom.color_name);
1350	if (spec->data.ctkcustom.fallback)
1351	meta_color_spec_free (spec->data.ctkcustom.fallback);
1352	DEBUG_FILL_STRUCT (&spec->data.ctkcustom)memset ((&spec->data.ctkcustom), 0xef, sizeof (*(& spec->data.ctkcustom)));
1353	break;
1354
1355	case META_COLOR_SPEC_BLEND:
1356	if (spec->data.blend.foreground)
1357	meta_color_spec_free (spec->data.blend.foreground);
1358	if (spec->data.blend.background)
1359	meta_color_spec_free (spec->data.blend.background);
1360	DEBUG_FILL_STRUCT (&spec->data.blend)memset ((&spec->data.blend), 0xef, sizeof (*(&spec ->data.blend)));
1361	break;
1362
1363	case META_COLOR_SPEC_SHADE:
1364	if (spec->data.shade.base)
1365	meta_color_spec_free (spec->data.shade.base);
1366	DEBUG_FILL_STRUCT (&spec->data.shade)memset ((&spec->data.shade), 0xef, sizeof (*(&spec ->data.shade)));
1367	break;
1368	}
1369
1370	g_free (spec);
1371	}
1372
1373	MetaColorSpec*
1374	meta_color_spec_new_from_string (const char *str,
1375	GError **err)
1376	{
1377	MetaColorSpec *spec;
1378
1379	spec = NULL((void*)0);
1380
1381	if (strncmp (str, "ctk:custom", 10) == 0)
1382	{
1383	const char color_name_start, fallback_str_start, *end;
1384	char *color_name;
1385	MetaColorSpec fallback = NULL((void)0);
1386	static gboolean debug, debug_set = FALSE(0);
1387
1388	if (!debug_set)
1389	{
1390	debug = g_getenv ("CROMA_DISABLE_FALLBACK_COLOR") != NULL((void*)0);
1391	debug_set = TRUE(!(0));
1392	}
1393
1394	if (str[10] != '(')
1395	{
1396	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1397	META_THEME_ERROR_FAILED,
1398	_("CTK custom color specification must have color name and fallback in parentheses, e.g. ctk:custom(foo,bar); could not parse \"%s\"")dgettext ("croma", "CTK custom color specification must have color name and fallback in parentheses, e.g. ctk:custom(foo,bar); could not parse \"%s\"" ),
1399	str);
1400	return NULL((void*)0);
1401	}
1402
1403	color_name_start = str + 11;
1404
1405	fallback_str_start = color_name_start;
1406	while (fallback_str_start && fallback_str_start != ',')
1407	{
1408	if (!(g_ascii_isalnum (fallback_str_start)((g_ascii_table[(guchar) (fallback_str_start)] & G_ASCII_ALNUM ) != 0)
1409	\|\| *fallback_str_start == '-'
1410	\|\| *fallback_str_start == '_'))
1411	{
1412	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1413	META_THEME_ERROR_FAILED,
1414	_("Invalid character '%c' in color_name parameter of ctk:custom, only A-Za-z0-9-_ are valid")dgettext ("croma", "Invalid character '%c' in color_name parameter of ctk:custom, only A-Za-z0-9-_ are valid" ),
1415	*fallback_str_start);
1416	return NULL((void*)0);
1417	}
1418	fallback_str_start++;
1419	}
1420	fallback_str_start++;
1421
1422	end = strrchr (str, ')');
1423
1424	if (color_name_start == NULL((void)0) \|\| fallback_str_start == NULL((void)0) \|\| end == NULL((void*)0))
1425	{
1426	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1427	META_THEME_ERROR_FAILED,
1428	_("Ctk:custom format is \"ctk:custom(color_name,fallback)\", \"%s\" does not fit the format")dgettext ("croma", "Ctk:custom format is \"ctk:custom(color_name,fallback)\", \"%s\" does not fit the format" ),
1429	str);
1430	return NULL((void*)0);
1431	}
1432
1433	if (!debug)
1434	{
1435	char *fallback_str;
1436	fallback_str = g_strndup (fallback_str_start,
1437	end - fallback_str_start);
1438	fallback = meta_color_spec_new_from_string (fallback_str, err);
1439	g_free (fallback_str);
1440	}
1441	else
1442	{
1443	fallback = meta_color_spec_new_from_string ("pink", err);
1444	}
1445
1446	if (fallback == NULL((void*)0))
1447	return NULL((void*)0);
1448
1449	color_name = g_strndup (color_name_start, fallback_str_start - color_name_start - 1);
1450
1451	spec = meta_color_spec_new (META_COLOR_SPEC_CTK_CUSTOM);
1452	spec->data.ctkcustom.color_name = color_name;
1453	spec->data.ctkcustom.fallback = fallback;
1454	}
1455	else if (strncmp (str, "ctk:", 4) == 0)
1456	{
1457	/* CTK color */
1458	const char *bracket;
1459	const char *end_bracket;
1460	char *tmp;
1461	CtkStateFlags state;
1462	MetaCtkColorComponent component;
1463
1464	bracket = str;
1465	while (bracket && bracket != '[')
1466	++bracket;
1467
1468	if (*bracket == '\0')
1469	{
1470	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1471	META_THEME_ERROR_FAILED,
1472	_("CTK color specification must have the state in brackets, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\"")dgettext ("croma", "CTK color specification must have the state in brackets, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\"" ),
1473	str);
1474	return NULL((void*)0);
1475	}
1476
1477	end_bracket = bracket;
1478	++end_bracket;
1479	while (end_bracket && end_bracket != ']')
1480	++end_bracket;
1481
1482	if (*end_bracket == '\0')
1483	{
1484	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1485	META_THEME_ERROR_FAILED,
1486	_("CTK color specification must have a close bracket after the state, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\"")dgettext ("croma", "CTK color specification must have a close bracket after the state, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\"" ),
1487	str);
1488	return NULL((void*)0);
1489	}
1490
1491	tmp = g_strndup (bracket + 1, end_bracket - bracket - 1);
1492	state = meta_ctk_state_from_string (tmp);
1493	if (((int) state) == -1)
1494	{
1495	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1496	META_THEME_ERROR_FAILED,
1497	_("Did not understand state \"%s\" in color specification")dgettext ("croma", "Did not understand state \"%s\" in color specification" ),
1498	tmp);
1499	g_free (tmp);
1500	return NULL((void*)0);
1501	}
1502	g_free (tmp);
1503
1504	tmp = g_strndup (str + 4, bracket - str - 4);
1505	component = meta_color_component_from_string (tmp);
1506	if (component == META_CTK_COLOR_LAST)
1507	{
1508	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1509	META_THEME_ERROR_FAILED,
1510	_("Did not understand color component \"%s\" in color specification")dgettext ("croma", "Did not understand color component \"%s\" in color specification" ),
1511	tmp);
1512	g_free (tmp);
1513	return NULL((void*)0);
1514	}
1515	g_free (tmp);
1516
1517	spec = meta_color_spec_new (META_COLOR_SPEC_CTK);
1518	spec->data.ctk.state = state;
1519	spec->data.ctk.component = component;
1520	g_assert (spec->data.ctk.component < META_CTK_COLOR_LAST)do { if (spec->data.ctk.component < META_CTK_COLOR_LAST ) ; else g_assertion_message_expr ("croma", "ui/theme.c", 1520 , ((const char*) (__func__)), "spec->data.ctk.component < META_CTK_COLOR_LAST" ); } while (0);
1521	}
1522	else if (strncmp (str, "blend/", 6) == 0)
1523	{
1524	/* blend */
1525	char **split;
1526	double alpha;
1527	char *end;
1528	MetaColorSpec *fg;
1529	MetaColorSpec *bg;
1530
1531	split = g_strsplit (str, "/", 4);
1532
1533	if (split[0] == NULL((void)0) \|\| split[1] == NULL((void)0) \|\|
1534	split[2] == NULL((void)0) \|\| split[3] == NULL((void)0))
1535	{
1536	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1537	META_THEME_ERROR_FAILED,
1538	_("Blend format is \"blend/bg_color/fg_color/alpha\", \"%s\" does not fit the format")dgettext ("croma", "Blend format is \"blend/bg_color/fg_color/alpha\", \"%s\" does not fit the format" ),
1539	str);
1540	g_strfreev (split);
1541	return NULL((void*)0);
1542	}
1543
1544	alpha = g_ascii_strtod (split[3], &end);
1545	if (end == split[3])
1546	{
1547	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1548	META_THEME_ERROR_FAILED,
1549	_("Could not parse alpha value \"%s\" in blended color")dgettext ("croma", "Could not parse alpha value \"%s\" in blended color" ),
1550	split[3]);
1551	g_strfreev (split);
1552	return NULL((void*)0);
1553	}
1554
1555	if (alpha < (0.0 - 1e6) \|\| alpha > (1.0 + 1e6))
1556	{
1557	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1558	META_THEME_ERROR_FAILED,
1559	_("Alpha value \"%s\" in blended color is not between 0.0 and 1.0")dgettext ("croma", "Alpha value \"%s\" in blended color is not between 0.0 and 1.0" ),
1560	split[3]);
1561	g_strfreev (split);
1562	return NULL((void*)0);
1563	}
1564
1565	fg = NULL((void*)0);
1566	bg = NULL((void*)0);
1567
1568	bg = meta_color_spec_new_from_string (split[1], err);
1569	if (bg == NULL((void*)0))
1570	{
1571	g_strfreev (split);
1572	return NULL((void*)0);
1573	}
1574
1575	fg = meta_color_spec_new_from_string (split[2], err);
1576	if (fg == NULL((void*)0))
1577	{
1578	meta_color_spec_free (bg);
1579	g_strfreev (split);
1580	return NULL((void*)0);
1581	}
1582
1583	g_strfreev (split);
1584
1585	spec = meta_color_spec_new (META_COLOR_SPEC_BLEND);
1586	spec->data.blend.alpha = alpha;
1587	spec->data.blend.background = bg;
1588	spec->data.blend.foreground = fg;
1589	}
1590	else if (strncmp (str, "shade/", 6) == 0)
1591	{
1592	/* shade */
1593	char **split;
1594	double factor;
1595	char *end;
1596	MetaColorSpec *base;
1597
1598	split = g_strsplit (str, "/", 3);
1599
1600	if (split[0] == NULL((void)0) \|\| split[1] == NULL((void)0) \|\|
1601	split[2] == NULL((void*)0))
1602	{
1603	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1604	META_THEME_ERROR_FAILED,
1605	_("Shade format is \"shade/base_color/factor\", \"%s\" does not fit the format")dgettext ("croma", "Shade format is \"shade/base_color/factor\", \"%s\" does not fit the format" ),
1606	str);
1607	g_strfreev (split);
1608	return NULL((void*)0);
1609	}
1610
1611	factor = g_ascii_strtod (split[2], &end);
1612	if (end == split[2])
1613	{
1614	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1615	META_THEME_ERROR_FAILED,
1616	_("Could not parse shade factor \"%s\" in shaded color")dgettext ("croma", "Could not parse shade factor \"%s\" in shaded color" ),
1617	split[2]);
1618	g_strfreev (split);
1619	return NULL((void*)0);
1620	}
1621
1622	if (factor < (0.0 - 1e6))
1623	{
1624	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1625	META_THEME_ERROR_FAILED,
1626	_("Shade factor \"%s\" in shaded color is negative")dgettext ("croma", "Shade factor \"%s\" in shaded color is negative" ),
1627	split[2]);
1628	g_strfreev (split);
1629	return NULL((void*)0);
1630	}
1631
1632	base = NULL((void*)0);
1633
1634	base = meta_color_spec_new_from_string (split[1], err);
1635	if (base == NULL((void*)0))
1636	{
1637	g_strfreev (split);
1638	return NULL((void*)0);
1639	}
1640
1641	g_strfreev (split);
1642
1643	spec = meta_color_spec_new (META_COLOR_SPEC_SHADE);
1644	spec->data.shade.factor = factor;
1645	spec->data.shade.base = base;
1646	}
1647	else
1648	{
1649	spec = meta_color_spec_new (META_COLOR_SPEC_BASIC);
1650
1651	if (!cdk_rgba_parse (&spec->data.basic.color, str))
1652	{
1653	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
1654	META_THEME_ERROR_FAILED,
1655	_("Could not parse color \"%s\"")dgettext ("croma", "Could not parse color \"%s\""),
1656	str);
1657	meta_color_spec_free (spec);
1658	return NULL((void*)0);
1659	}
1660	}
1661
1662	g_assert (spec)do { if (spec) ; else g_assertion_message_expr ("croma", "ui/theme.c" , 1662, ((const char*) (__func__)), "spec"); } while (0);
1663
1664	return spec;
1665	}
1666
1667	MetaColorSpec*
1668	meta_color_spec_new_ctk (MetaCtkColorComponent component,
1669	CtkStateFlags state)
1670	{
1671	MetaColorSpec *spec;
1672
1673	spec = meta_color_spec_new (META_COLOR_SPEC_CTK);
1674
1675	spec->data.ctk.component = component;
1676	spec->data.ctk.state = state;
1677
1678	return spec;
1679	}
1680
1681	static void
1682	get_background_color_real (CtkStyleContext *context,
1683	CtkStateFlags state,
1684	CdkRGBA *color)
1685	{
1686	CdkRGBA *c;
1687
1688	g_return_if_fail (color != NULL)do { if ((color != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "color != NULL"); return ; } } while (0);
1689	g_return_if_fail (CTK_IS_STYLE_CONTEXT (context))do { if (((((__extension__ ({ GTypeInstance __inst = (GTypeInstance ) ((context)); GType __t = ((ctk_style_context_get_type ())) ; gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0) ); else __r = g_type_check_instance_is_a (__inst, __t); __r; } )))))) { } else { g_return_if_fail_warning ("croma", ((const char *) (__func__)), "CTK_IS_STYLE_CONTEXT (context)"); return; } } while (0);
1690
1691	ctk_style_context_get (context,
1692	state,
1693	"background-color", &c,
1694	NULL((void*)0));
1695
1696	color = c;
1697	cdk_rgba_free (c);
1698	}
1699
1700	static void
1701	get_background_color (CtkStyleContext *context,
1702	CtkStateFlags state,
1703	CdkRGBA *color)
1704	{
1705	CdkRGBA empty = { 0.0, 0.0, 0.0, 0.0 };
1706	CdkRGBA rgba;
1707
1708	get_background_color_real (context, state, &rgba);
1709
1710	if (cdk_rgba_equal (&rgba, &empty))
1711	{
1712	CtkWidget *toplevel;
1713	CtkStyleContext *tmp;
1714
1715	toplevel = ctk_window_new (CTK_WINDOW_TOPLEVEL);
1716	tmp = ctk_widget_get_style_context (toplevel);
1717
1718	get_background_color_real (tmp, state, &rgba);
1719
1720	ctk_widget_destroy (toplevel);
1721	}
1722
1723	*color = rgba;
1724	}
1725
1726	/* Based on set_color() in ctkstyle.c */
1727	#define LIGHTNESS_MULT1.3 1.3
1728	#define DARKNESS_MULT0.7 0.7
1729	void
1730	meta_ctk_style_get_light_color (CtkStyleContext *style,
1731	CtkStateFlags state,
1732	CdkRGBA *color)
1733	{
1734	get_background_color (style, state, color);
1735	ctk_style_shade (color, color, LIGHTNESS_MULT1.3);
1736	}
1737
1738	void
1739	meta_ctk_style_get_dark_color (CtkStyleContext *style,
1740	CtkStateFlags state,
1741	CdkRGBA *color)
1742	{
1743	get_background_color (style, state, color);
1744	ctk_style_shade (color, color, DARKNESS_MULT0.7);
1745	}
1746
1747	static void
1748	meta_set_color_from_style (CdkRGBA *color,
1749	CtkStyleContext *context,
1750	CtkStateFlags state,
1751	MetaCtkColorComponent component)
1752	{
1753	CdkRGBA other;
1754
1755	/* Add background class to context to get the correct colors from the CTK+
1756	theme instead of white text over black background. */
1757	ctk_style_context_add_class (context, CTK_STYLE_CLASS_BACKGROUND"background");
1758
1759	switch (component)
1760	{
1761	case META_CTK_COLOR_BG:
1762	case META_CTK_COLOR_BASE:
1763	get_background_color (context, state, color);
1764	break;
1765	case META_CTK_COLOR_FG:
1766	case META_CTK_COLOR_TEXT:
1767	ctk_style_context_get_color (context, state, color);
1768	break;
1769	case META_CTK_COLOR_TEXT_AA:
1770	ctk_style_context_get_color (context, state, color);
1771	meta_set_color_from_style (&other, context, state, META_CTK_COLOR_BASE);
1772
1773	color->red = (color->red + other.red) / 2;
1774	color->green = (color->green + other.green) / 2;
1775	color->blue = (color->blue + other.blue) / 2;
1776	break;
1777	case META_CTK_COLOR_MID:
1778	meta_ctk_style_get_light_color (context, state, color);
1779	meta_ctk_style_get_dark_color (context, state, &other);
1780
1781	color->red = (color->red + other.red) / 2;
1782	color->green = (color->green + other.green) / 2;
1783	color->blue = (color->blue + other.blue) / 2;
1784	break;
1785	case META_CTK_COLOR_LIGHT:
1786	meta_ctk_style_get_light_color (context, state, color);
1787	break;
1788	case META_CTK_COLOR_DARK:
1789	meta_ctk_style_get_dark_color (context, state, color);
1790	break;
1791	case META_CTK_COLOR_LAST:
1792	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 1792, ( (const char) (__func__)), ((void)0)); } while (0);
1793	break;
1794	}
1795	}
1796
1797	static void
1798	meta_set_custom_color_from_style (CdkRGBA *color,
1799	CtkStyleContext *context,
1800	char *color_name,
1801	MetaColorSpec *fallback)
1802	{
1803	if (!ctk_style_context_lookup_color (context, color_name, color))
1804	meta_color_spec_render (fallback, context, color);
1805	}
1806
1807	void
1808	meta_color_spec_render (MetaColorSpec *spec,
1809	CtkStyleContext *style,
1810	CdkRGBA *color)
1811	{
1812	g_return_if_fail (spec != NULL)do { if ((spec != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "spec != NULL"); return ; } } while (0);
1813
1814	g_return_if_fail (CTK_IS_STYLE_CONTEXT (style))do { if (((((__extension__ ({ GTypeInstance __inst = (GTypeInstance ) ((style)); GType __t = ((ctk_style_context_get_type ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__ )), "CTK_IS_STYLE_CONTEXT (style)"); return; } } while (0);
1815
1816	switch (spec->type)
1817	{
1818	case META_COLOR_SPEC_BASIC:
1819	*color = spec->data.basic.color;
1820	break;
1821
1822	case META_COLOR_SPEC_CTK:
1823	meta_set_color_from_style (color,
1824	style,
1825	spec->data.ctk.state,
1826	spec->data.ctk.component);
1827	break;
1828
1829	case META_COLOR_SPEC_CTK_CUSTOM:
1830	meta_set_custom_color_from_style (color,
1831	style,
1832	spec->data.ctkcustom.color_name,
1833	spec->data.ctkcustom.fallback);
1834	break;
1835
1836	case META_COLOR_SPEC_BLEND:
1837	{
1838	CdkRGBA bg, fg;
1839
1840	meta_color_spec_render (spec->data.blend.background, style, &bg);
1841	meta_color_spec_render (spec->data.blend.foreground, style, &fg);
1842
1843	color_composite (&bg, &fg, spec->data.blend.alpha,
1844	&spec->data.blend.color);
1845
1846	*color = spec->data.blend.color;
1847	}
1848	break;
1849
1850	case META_COLOR_SPEC_SHADE:
1851	{
1852	meta_color_spec_render (spec->data.shade.base, style,
1853	&spec->data.shade.color);
1854
1855	ctk_style_shade (&spec->data.shade.color,
1856	&spec->data.shade.color, spec->data.shade.factor);
1857
1858	*color = spec->data.shade.color;
1859	}
1860	break;
1861	}
1862	}
1863
1864	/**
1865	* Represents an operation as a string.
1866	*
1867	* \param type an operation, such as addition
1868	* \return a string, such as "+"
1869	*/
1870	static const char*
1871	op_name (PosOperatorType type)
1872	{
1873	switch (type)
1874	{
1875	case POS_OP_ADD:
1876	return "+";
1877	case POS_OP_SUBTRACT:
1878	return "-";
1879	case POS_OP_MULTIPLY:
1880	return "*";
1881	case POS_OP_DIVIDE:
1882	return "/";
1883	case POS_OP_MOD:
1884	return "%";
1885	case POS_OP_MAX:
1886	return "`max`";
1887	case POS_OP_MIN:
1888	return "`min`";
1889	case POS_OP_NONE:
1890	break;
1891	}
1892
1893	return "<unknown>";
1894	}
1895
1896	/**
1897	* Parses a string and returns an operation.
1898	*
1899	* \param p a pointer into a string representing an operation; part of an
1900	* expression somewhere, so not null-terminated
1901	* \param len set to the length of the string found. Set to 0 if none is.
1902	* \return the operation found. If none was, returns POS_OP_NONE.
1903	*/
1904	static PosOperatorType
1905	op_from_string (const char *p,
1906	int *len)
1907	{
1908	*len = 0;
1909
1910	switch (*p)
1911	{
1912	case '+':
1913	*len = 1;
1914	return POS_OP_ADD;
1915	case '-':
1916	*len = 1;
1917	return POS_OP_SUBTRACT;
1918	case '*':
1919	*len = 1;
1920	return POS_OP_MULTIPLY;
1921	case '/':
1922	*len = 1;
1923	return POS_OP_DIVIDE;
1924	case '%':
1925	*len = 1;
1926	return POS_OP_MOD;
1927
1928	case '`':
1929	if (strncmp (p, "`max`", 5) == 0)
1930	{
1931	*len = 5;
1932	return POS_OP_MAX;
1933	}
1934	else if (strncmp (p, "`min`", 5) == 0)
1935	{
1936	*len = 5;
1937	return POS_OP_MIN;
1938	}
1939	}
1940
1941	return POS_OP_NONE;
1942	}
1943
1944	/**
1945	* Frees an array of tokens. All the tokens and their associated memory
1946	* will be freed.
1947	*
1948	* \param tokens an array of tokens to be freed
1949	* \param n_tokens how many tokens are in the array.
1950	*/
1951	static void
1952	free_tokens (PosToken *tokens,
1953	int n_tokens)
1954	{
1955	int i;
1956
1957	/* n_tokens can be 0 since tokens may have been allocated more than
1958	* it was initialized
1959	*/
1960
1961	for (i = 0; i < n_tokens; i++)
1962	if (tokens[i].type == POS_TOKEN_VARIABLE)
1963	g_free (tokens[i].d.v.name);
1964
1965	g_free (tokens);
1966	}
1967
1968	/**
1969	* Tokenises a number in an expression.
1970	*
1971	* \param p a pointer into a string representing an operation; part of an
1972	* expression somewhere, so not null-terminated
1973	* \param end_return set to a pointer to the end of the number found; but
1974	* not updated if no number was found at all
1975	* \param next set to either an integer or a float token
1976	* \param[out] err set to the problem if there was a problem
1977	* \return TRUE if a valid number was found, FALSE otherwise (and "err" will
1978	* have been set)
1979	*
1980	* \bug The "while (*start)..." part: what's wrong with strchr-ish things?
1981	* \bug The name is wrong: it doesn't parse anything.
1982	* \ingroup tokenizer
1983	*/
1984	static gboolean
1985	parse_number (const char *p,
1986	const char **end_return,
1987	PosToken *next,
1988	GError **err)
1989	{
1990	const char *start = p;
1991	char *end;
1992	gboolean is_float;
1993	char *num_str;
1994
1995	while (p && (p == '.' \|\| g_ascii_isdigit (p)((g_ascii_table[(guchar) (p)] & G_ASCII_DIGIT) != 0)))
1996	++p;
1997
1998	if (p == start)
1999	{
2000	char buf[7] = { '\0' };
2001	buf[g_unichar_to_utf8 (g_utf8_get_char (p), buf)] = '\0';
2002	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2003	META_THEME_ERROR_BAD_CHARACTER,
2004	_("Coordinate expression contains character '%s' which is not allowed")dgettext ("croma", "Coordinate expression contains character '%s' which is not allowed" ),
2005	buf);
2006	return FALSE(0);
2007	}
2008
2009	*end_return = p;
2010
2011	/* we need this to exclude floats like "1e6" */
2012	num_str = g_strndup (start, p - start);
2013	start = num_str;
2014	is_float = FALSE(0);
2015	while (*start)
2016	{
2017	if (*start == '.')
2018	is_float = TRUE(!(0));
2019	++start;
2020	}
2021
2022	if (is_float)
2023	{
2024	next->type = POS_TOKEN_DOUBLE;
2025	next->d.d.val = g_ascii_strtod (num_str, &end);
2026
2027	if (end == num_str)
2028	{
2029	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2030	META_THEME_ERROR_FAILED,
2031	_("Coordinate expression contains floating point number '%s' which could not be parsed")dgettext ("croma", "Coordinate expression contains floating point number '%s' which could not be parsed" ),
2032	num_str);
2033	g_free (num_str);
2034	return FALSE(0);
2035	}
2036	}
2037	else
2038	{
2039	next->type = POS_TOKEN_INT;
2040	next->d.i.val = strtol (num_str, &end, 10);
2041	if (end == num_str)
2042	{
2043	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2044	META_THEME_ERROR_FAILED,
2045	_("Coordinate expression contains integer '%s' which could not be parsed")dgettext ("croma", "Coordinate expression contains integer '%s' which could not be parsed" ),
2046	num_str);
2047	g_free (num_str);
2048	return FALSE(0);
2049	}
2050	}
2051
2052	g_free (num_str);
2053
2054	g_assert (next->type == POS_TOKEN_INT \|\| next->type == POS_TOKEN_DOUBLE)do { if (next->type == POS_TOKEN_INT \|\| next->type == POS_TOKEN_DOUBLE ) ; else g_assertion_message_expr ("croma", "ui/theme.c", 2054 , ((const char*) (__func__)), "next->type == POS_TOKEN_INT \|\| next->type == POS_TOKEN_DOUBLE" ); } while (0);
2055
2056	return TRUE(!(0));
2057	}
2058
2059	/**
2060	* Whether a variable can validly appear as part of the name of a variable.
2061	*/
2062	#define IS_VARIABLE_CHAR(c)(((g_ascii_table[(guchar) ((c))] & G_ASCII_ALPHA) != 0) \|\| (c) == '_') (g_ascii_isalpha ((c))((g_ascii_table[(guchar) ((c))] & G_ASCII_ALPHA) != 0) \|\| (c) == '_')
2063
2064	#if 0
2065	static void
2066	debug_print_tokens (PosToken *tokens,
2067	int n_tokens)
2068	{
2069	int i;
2070
2071	for (i = 0; i < n_tokens; i++)
2072	{
2073	PosToken *t = &tokens[i];
2074
2075	g_print (" ");
2076
2077	switch (t->type)
2078	{
2079	case POS_TOKEN_INT:
2080	g_print ("\"%d\"", t->d.i.val);
2081	break;
2082	case POS_TOKEN_DOUBLE:
2083	g_print ("\"%g\"", t->d.d.val);
2084	break;
2085	case POS_TOKEN_OPEN_PAREN:
2086	g_print ("\"(\"");
2087	break;
2088	case POS_TOKEN_CLOSE_PAREN:
2089	g_print ("\")\"");
2090	break;
2091	case POS_TOKEN_VARIABLE:
2092	g_print ("\"%s\"", t->d.v.name);
2093	break;
2094	case POS_TOKEN_OPERATOR:
2095	g_print ("\"%s\"", op_name (t->d.o.op));
2096	break;
2097	}
2098	}
2099
2100	g_print ("\n");
2101	}
2102	#endif
2103
2104	/**
2105	* Tokenises an expression.
2106	*
2107	* \param expr The expression
2108	* \param[out] tokens_p The resulting tokens
2109	* \param[out] n_tokens_p The number of resulting tokens
2110	* \param[out] err set to the problem if there was a problem
2111	*
2112	* \return True if the expression was successfully tokenised; false otherwise.
2113	*
2114	* \ingroup tokenizer
2115	*/
2116	static gboolean
2117	pos_tokenize (const char *expr,
2118	PosToken **tokens_p,
2119	int *n_tokens_p,
2120	GError **err)
2121	{
2122	PosToken *tokens;
2123	int n_tokens;
2124	int allocated;
2125	const char *p;
2126
2127	tokens_p = NULL((void)0);
2128	*n_tokens_p = 0;
2129
2130	allocated = 3;
2131	n_tokens = 0;
2132	tokens = g_new (PosToken, allocated)((PosToken *) g_malloc_n ((allocated), sizeof (PosToken)));
2133
2134	p = expr;
2135	while (*p)
2136	{
2137	PosToken *next;
2138	int len;
2139
2140	if (n_tokens == allocated)
2141	{
2142	allocated *= 2;
2143	tokens = g_renew (PosToken, tokens, allocated)((PosToken *) g_realloc_n (tokens, (allocated), sizeof (PosToken )));
2144	}
2145
2146	next = &tokens[n_tokens];
2147
2148	switch (*p)
2149	{
2150	case '*':
2151	case '/':
2152	case '+':
2153	case '-': /* negative numbers aren't allowed so this is easy */
2154	case '%':
2155	case '`':
2156	next->type = POS_TOKEN_OPERATOR;
2157	next->d.o.op = op_from_string (p, &len);
2158	if (next->d.o.op != POS_OP_NONE)
2159	{
2160	++n_tokens;
2161	p = p + (len - 1); /* -1 since we ++p later */
2162	}
2163	else
2164	{
2165	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2166	META_THEME_ERROR_FAILED,
2167	_("Coordinate expression contained unknown operator at the start of this text: \"%s\"")dgettext ("croma", "Coordinate expression contained unknown operator at the start of this text: \"%s\"" ),
2168	p);
2169
2170	goto error;
2171	}
2172	break;
2173
2174	case '(':
2175	next->type = POS_TOKEN_OPEN_PAREN;
2176	++n_tokens;
2177	break;
2178
2179	case ')':
2180	next->type = POS_TOKEN_CLOSE_PAREN;
2181	++n_tokens;
2182	break;
2183
2184	case ' ':
2185	case '\t':
2186	case '\n':
2187	break;
2188
2189	default:
2190	if (IS_VARIABLE_CHAR (p)(((g_ascii_table[(guchar) ((p))] & G_ASCII_ALPHA) != 0) \|\| (*p) == '_'))
2191	{
2192	/* Assume variable */
2193	const char *start = p;
2194	while (p && IS_VARIABLE_CHAR (p)(((g_ascii_table[(guchar) ((p))] & G_ASCII_ALPHA) != 0) \|\| (p) == '_'))
2195	++p;
2196	g_assert (p != start)do { if (p != start) ; else g_assertion_message_expr ("croma" , "ui/theme.c", 2196, ((const char*) (__func__)), "p != start" ); } while (0);
2197	next->type = POS_TOKEN_VARIABLE;
2198	next->d.v.name = g_strndup (start, p - start);
2199	++n_tokens;
2200	--p; /* since we ++p again at the end of while loop */
2201	}
2202	else
2203	{
2204	/* Assume number */
2205	const char *end;
2206
2207	if (!parse_number (p, &end, next, err))
2208	goto error;
2209
2210	++n_tokens;
2211	p = end - 1; /* -1 since we ++p again at the end of while loop */
2212	}
2213
2214	break;
2215	}
2216
2217	++p;
2218	}
2219
2220	if (n_tokens == 0)
2221	{
2222	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2223	META_THEME_ERROR_FAILED,
2224	_("Coordinate expression was empty or not understood")dgettext ("croma", "Coordinate expression was empty or not understood" ));
2225
2226	goto error;
2227	}
2228
2229	*tokens_p = tokens;
2230	*n_tokens_p = n_tokens;
2231
2232	return TRUE(!(0));
2233
2234	error:
2235	g_assert (err == NULL \|\| err != NULL)do { if (err == ((void)0) \|\| err != ((void)0)) ; else g_assertion_message_expr ("croma", "ui/theme.c", 2235, ((const char) (__func__)), "err == NULL \|\| err != NULL" ); } while (0);
2236
2237	free_tokens (tokens, n_tokens);
2238	return FALSE(0);
2239	}
2240
2241	/**
2242	* The type of a PosExpr: either integer, double, or an operation.
2243	* \ingroup parser
2244	*/
2245	typedef enum
2246	{
2247	POS_EXPR_INT,
2248	POS_EXPR_DOUBLE,
2249	POS_EXPR_OPERATOR
2250	} PosExprType;
2251
2252	/**
2253	* Type and value of an expression in a parsed sequence. We don't
2254	* keep expressions in a tree; if this is of type POS_EXPR_OPERATOR,
2255	* the arguments of the operator will be in the array positions
2256	* immediately preceding and following this operator; they cannot
2257	* themselves be operators.
2258	*
2259	* \bug operator is char; it should really be of PosOperatorType.
2260	* \ingroup parser
2261	*/
2262	typedef struct
2263	{
2264	PosExprType type;
2265	union
2266	{
2267	double double_val;
2268	int int_val;
2269	char operator;
2270	} d;
2271	} PosExpr;
2272
2273	#if 0
2274	static void
2275	debug_print_exprs (PosExpr *exprs,
2276	int n_exprs)
2277	{
2278	int i;
2279
2280	for (i = 0; i < n_exprs; i++)
2281	{
2282	switch (exprs[i].type)
2283	{
2284	case POS_EXPR_INT:
2285	g_print (" %d", exprs[i].d.int_val);
2286	break;
2287	case POS_EXPR_DOUBLE:
2288	g_print (" %g", exprs[i].d.double_val);
2289	break;
2290	case POS_EXPR_OPERATOR:
2291	g_print (" %s", op_name (exprs[i].d.operator));
2292	break;
2293	}
2294	}
2295	g_print ("\n");
2296	}
2297	#endif
2298
2299	static gboolean
2300	do_operation (PosExpr *a,
2301	PosExpr *b,
2302	PosOperatorType op,
2303	GError **err)
2304	{
2305	/* Promote types to double if required */
2306	if (a->type == POS_EXPR_DOUBLE \|\|
2307	b->type == POS_EXPR_DOUBLE)
2308	{
2309	if (a->type != POS_EXPR_DOUBLE)
2310	{
2311	a->type = POS_EXPR_DOUBLE;
2312	a->d.double_val = a->d.int_val;
2313	}
2314	if (b->type != POS_EXPR_DOUBLE)
2315	{
2316	b->type = POS_EXPR_DOUBLE;
2317	b->d.double_val = b->d.int_val;
2318	}
2319	}
2320
2321	g_assert (a->type == b->type)do { if (a->type == b->type) ; else g_assertion_message_expr ("croma", "ui/theme.c", 2321, ((const char*) (__func__)), "a->type == b->type" ); } while (0);
2322
2323	if (a->type == POS_EXPR_INT)
2324	{
2325	switch (op)
2326	{
2327	case POS_OP_MULTIPLY:
2328	a->d.int_val = a->d.int_val * b->d.int_val;
2329	break;
2330	case POS_OP_DIVIDE:
2331	if (b->d.int_val == 0)
2332	{
2333	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2334	META_THEME_ERROR_DIVIDE_BY_ZERO,
2335	_("Coordinate expression results in division by zero")dgettext ("croma", "Coordinate expression results in division by zero" ));
2336	return FALSE(0);
2337	}
2338	a->d.int_val = a->d.int_val / b->d.int_val;
2339	break;
2340	case POS_OP_MOD:
2341	if (b->d.int_val == 0)
2342	{
2343	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2344	META_THEME_ERROR_DIVIDE_BY_ZERO,
2345	_("Coordinate expression results in division by zero")dgettext ("croma", "Coordinate expression results in division by zero" ));
2346	return FALSE(0);
2347	}
2348	a->d.int_val = a->d.int_val % b->d.int_val;
2349	break;
2350	case POS_OP_ADD:
2351	a->d.int_val = a->d.int_val + b->d.int_val;
2352	break;
2353	case POS_OP_SUBTRACT:
2354	a->d.int_val = a->d.int_val - b->d.int_val;
2355	break;
2356	case POS_OP_MAX:
2357	a->d.int_val = MAX (a->d.int_val, b->d.int_val)(((a->d.int_val) > (b->d.int_val)) ? (a->d.int_val ) : (b->d.int_val));
2358	break;
2359	case POS_OP_MIN:
2360	a->d.int_val = MIN (a->d.int_val, b->d.int_val)(((a->d.int_val) < (b->d.int_val)) ? (a->d.int_val ) : (b->d.int_val));
2361	break;
2362	case POS_OP_NONE:
2363	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2363, ( (const char) (__func__)), ((void)0)); } while (0);
2364	break;
2365	}
2366	}
2367	else if (a->type == POS_EXPR_DOUBLE)
2368	{
2369	switch (op)
2370	{
2371	case POS_OP_MULTIPLY:
2372	a->d.double_val = a->d.double_val * b->d.double_val;
2373	break;
2374	case POS_OP_DIVIDE:
2375	if (b->d.double_val == 0.0)
2376	{
2377	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2378	META_THEME_ERROR_DIVIDE_BY_ZERO,
2379	_("Coordinate expression results in division by zero")dgettext ("croma", "Coordinate expression results in division by zero" ));
2380	return FALSE(0);
2381	}
2382	a->d.double_val = a->d.double_val / b->d.double_val;
2383	break;
2384	case POS_OP_MOD:
2385	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2386	META_THEME_ERROR_MOD_ON_FLOAT,
2387	_("Coordinate expression tries to use mod operator on a floating-point number")dgettext ("croma", "Coordinate expression tries to use mod operator on a floating-point number" ));
2388	return FALSE(0);
2389	case POS_OP_ADD:
2390	a->d.double_val = a->d.double_val + b->d.double_val;
2391	break;
2392	case POS_OP_SUBTRACT:
2393	a->d.double_val = a->d.double_val - b->d.double_val;
2394	break;
2395	case POS_OP_MAX:
2396	a->d.double_val = MAX (a->d.double_val, b->d.double_val)(((a->d.double_val) > (b->d.double_val)) ? (a->d. double_val) : (b->d.double_val));
2397	break;
2398	case POS_OP_MIN:
2399	a->d.double_val = MIN (a->d.double_val, b->d.double_val)(((a->d.double_val) < (b->d.double_val)) ? (a->d. double_val) : (b->d.double_val));
2400	break;
2401	case POS_OP_NONE:
2402	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2402, ( (const char) (__func__)), ((void)0)); } while (0);
2403	break;
2404	}
2405	}
2406	else
2407	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2407, ( (const char) (__func__)), ((void)0)); } while (0);
2408
2409	return TRUE(!(0));
2410	}
2411
2412	static gboolean
2413	do_operations (PosExpr *exprs,
2414	int *n_exprs,
2415	int precedence,
2416	GError **err)
2417	{
2418	int i;
2419
2420	#if 0
2421	g_print ("Doing prec %d ops on %d exprs\n", precedence, *n_exprs);
2422	debug_print_exprs (exprs, *n_exprs);
2423	#endif
2424
2425	i = 1;
2426	while (i < *n_exprs)
2427	{
2428	gboolean compress;
2429
2430	/* exprs[i-1] first operand
2431	* exprs[i] operator
2432	* exprs[i+1] second operand
2433	*
2434	* we replace first operand with result of mul/div/mod,
2435	* or skip over operator and second operand if we have
2436	* an add/subtract
2437	*/
2438
2439	if (exprs[i-1].type == POS_EXPR_OPERATOR)
2440	{
2441	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2442	META_THEME_ERROR_FAILED,
2443	_("Coordinate expression has an operator \"%s\" where an operand was expected")dgettext ("croma", "Coordinate expression has an operator \"%s\" where an operand was expected" ),
2444	op_name (exprs[i-1].d.operator));
2445	return FALSE(0);
2446	}
2447
2448	if (exprs[i].type != POS_EXPR_OPERATOR)
2449	{
2450	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2451	META_THEME_ERROR_FAILED,
2452	_("Coordinate expression had an operand where an operator was expected")dgettext ("croma", "Coordinate expression had an operand where an operator was expected" ));
2453	return FALSE(0);
2454	}
2455
2456	if (i == (*n_exprs - 1))
2457	{
2458	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2459	META_THEME_ERROR_FAILED,
2460	_("Coordinate expression ended with an operator instead of an operand")dgettext ("croma", "Coordinate expression ended with an operator instead of an operand" ));
2461	return FALSE(0);
2462	}
2463
2464	g_assert ((i+1) < n_exprs)do { if ((i+1) < n_exprs) ; else g_assertion_message_expr ("croma", "ui/theme.c", 2464, ((const char) (__func__)), "(i+1) < n_exprs" ); } while (0);
2465
2466	if (exprs[i+1].type == POS_EXPR_OPERATOR)
2467	{
2468	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2469	META_THEME_ERROR_FAILED,
2470	_("Coordinate expression has operator \"%c\" following operator \"%c\" with no operand in between")dgettext ("croma", "Coordinate expression has operator \"%c\" following operator \"%c\" with no operand in between" ),
2471	exprs[i+1].d.operator,
2472	exprs[i].d.operator);
2473	return FALSE(0);
2474	}
2475
2476	compress = FALSE(0);
2477
2478	switch (precedence)
2479	{
2480	case 2:
2481	switch (exprs[i].d.operator)
2482	{
2483	case POS_OP_DIVIDE:
2484	case POS_OP_MOD:
2485	case POS_OP_MULTIPLY:
2486	compress = TRUE(!(0));
2487	if (!do_operation (&exprs[i-1], &exprs[i+1],
2488	exprs[i].d.operator,
2489	err))
2490	return FALSE(0);
2491	break;
2492	}
2493	break;
2494	case 1:
2495	switch (exprs[i].d.operator)
2496	{
2497	case POS_OP_ADD:
2498	case POS_OP_SUBTRACT:
2499	compress = TRUE(!(0));
2500	if (!do_operation (&exprs[i-1], &exprs[i+1],
2501	exprs[i].d.operator,
2502	err))
2503	return FALSE(0);
2504	break;
2505	}
2506	break;
2507	/* I have no rationale at all for making these low-precedence */
2508	case 0:
2509	switch (exprs[i].d.operator)
2510	{
2511	case POS_OP_MAX:
2512	case POS_OP_MIN:
2513	compress = TRUE(!(0));
2514	if (!do_operation (&exprs[i-1], &exprs[i+1],
2515	exprs[i].d.operator,
2516	err))
2517	return FALSE(0);
2518	break;
2519	}
2520	break;
2521	}
2522
2523	if (compress)
2524	{
2525	/* exprs[i-1] first operand (now result)
2526	* exprs[i] operator
2527	* exprs[i+1] second operand
2528	* exprs[i+2] new operator
2529	*
2530	* we move new operator just after first operand
2531	*/
2532	if ((i+2) < *n_exprs)
2533	{
2534	memmove (&exprs[i], &exprs[i+2],
2535	sizeof (PosExpr) * (*n_exprs - i - 2));
2536	}
2537
2538	*n_exprs -= 2;
2539	}
2540	else
2541	{
2542	/* Skip operator and next operand */
2543	i += 2;
2544	}
2545	}
2546
2547	return TRUE(!(0));
2548	}
2549
2550	/**
2551	* There is a predefined set of variables which can appear in an expression.
2552	* Here we take a token representing a variable, and return the current value
2553	* of that variable in a particular environment.
2554	* (The value is always an integer.)
2555	*
2556	* There are supposedly some circumstances in which this function can be
2557	* called from outside Croma, in which case env->theme will be NULL, and
2558	* therefore we can't use it to find out quark values, so we do the comparison
2559	* using strcmp, which is slower.
2560	*
2561	* \param t The token representing a variable
2562	* \param[out] result The value of that variable; not set if the token did
2563	* not represent a known variable
2564	* \param env The environment within which t should be evaluated
2565	* \param[out] err set to the problem if there was a problem
2566	*
2567	* \return true if we found the variable asked for, false if we didn't
2568	*
2569	* \bug shouldn't t be const?
2570	* \bug we should perhaps consider some sort of lookup arrangement into an
2571	* array; also, the duplication of code is unlovely; perhaps using glib
2572	* string hashes instead of quarks would fix both problems?
2573	* \ingroup parser
2574	*/
2575	static gboolean
2576	pos_eval_get_variable (PosToken *t,
2577	int *result,
2578	const MetaPositionExprEnv *env,
2579	GError **err)
2580	{
2581	if (env->theme)
2582	{
2583	if (t->d.v.name_quark == env->theme->quark_width)
2584	*result = env->rect.width;
2585	else if (t->d.v.name_quark == env->theme->quark_height)
2586	*result = env->rect.height;
2587	else if (env->object_width >= 0 &&
2588	t->d.v.name_quark == env->theme->quark_object_width)
2589	*result = env->object_width;
2590	else if (env->object_height >= 0 &&
2591	t->d.v.name_quark == env->theme->quark_object_height)
2592	*result = env->object_height;
2593	else if (t->d.v.name_quark == env->theme->quark_left_width)
2594	*result = env->left_width;
2595	else if (t->d.v.name_quark == env->theme->quark_right_width)
2596	*result = env->right_width;
2597	else if (t->d.v.name_quark == env->theme->quark_top_height)
2598	*result = env->top_height;
2599	else if (t->d.v.name_quark == env->theme->quark_bottom_height)
2600	*result = env->bottom_height;
2601	else if (t->d.v.name_quark == env->theme->quark_mini_icon_width)
2602	*result = env->mini_icon_width;
2603	else if (t->d.v.name_quark == env->theme->quark_mini_icon_height)
2604	*result = env->mini_icon_height;
2605	else if (t->d.v.name_quark == env->theme->quark_icon_width)
2606	*result = env->icon_width;
2607	else if (t->d.v.name_quark == env->theme->quark_icon_height)
2608	*result = env->icon_height;
2609	else if (t->d.v.name_quark == env->theme->quark_title_width)
2610	*result = env->title_width;
2611	else if (t->d.v.name_quark == env->theme->quark_title_height)
2612	*result = env->title_height;
2613	else if (t->d.v.name_quark == env->theme->quark_frame_x_center)
2614	*result = env->frame_x_center;
2615	else if (t->d.v.name_quark == env->theme->quark_frame_y_center)
2616	*result = env->frame_y_center;
2617	else
2618	{
2619	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2620	META_THEME_ERROR_UNKNOWN_VARIABLE,
2621	_("Coordinate expression had unknown variable or constant \"%s\"")dgettext ("croma", "Coordinate expression had unknown variable or constant \"%s\"" ),
2622	t->d.v.name);
2623	return FALSE(0);
2624	}
2625	}
2626	else
2627	{
2628	if (strcmp (t->d.v.name, "width") == 0)
2629	*result = env->rect.width;
2630	else if (strcmp (t->d.v.name, "height") == 0)
2631	*result = env->rect.height;
2632	else if (env->object_width >= 0 &&
2633	strcmp (t->d.v.name, "object_width") == 0)
2634	*result = env->object_width;
2635	else if (env->object_height >= 0 &&
2636	strcmp (t->d.v.name, "object_height") == 0)
2637	*result = env->object_height;
2638	else if (strcmp (t->d.v.name, "left_width") == 0)
2639	*result = env->left_width;
2640	else if (strcmp (t->d.v.name, "right_width") == 0)
2641	*result = env->right_width;
2642	else if (strcmp (t->d.v.name, "top_height") == 0)
2643	*result = env->top_height;
2644	else if (strcmp (t->d.v.name, "bottom_height") == 0)
2645	*result = env->bottom_height;
2646	else if (strcmp (t->d.v.name, "mini_icon_width") == 0)
2647	*result = env->mini_icon_width;
2648	else if (strcmp (t->d.v.name, "mini_icon_height") == 0)
2649	*result = env->mini_icon_height;
2650	else if (strcmp (t->d.v.name, "icon_width") == 0)
2651	*result = env->icon_width;
2652	else if (strcmp (t->d.v.name, "icon_height") == 0)
2653	*result = env->icon_height;
2654	else if (strcmp (t->d.v.name, "title_width") == 0)
2655	*result = env->title_width;
2656	else if (strcmp (t->d.v.name, "title_height") == 0)
2657	*result = env->title_height;
2658	else if (strcmp (t->d.v.name, "frame_x_center") == 0)
2659	*result = env->frame_x_center;
2660	else if (strcmp (t->d.v.name, "frame_y_center") == 0)
2661	*result = env->frame_y_center;
2662	else
2663	{
2664	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2665	META_THEME_ERROR_UNKNOWN_VARIABLE,
2666	_("Coordinate expression had unknown variable or constant \"%s\"")dgettext ("croma", "Coordinate expression had unknown variable or constant \"%s\"" ),
2667	t->d.v.name);
2668	return FALSE(0);
2669	}
2670	}
2671
2672	return TRUE(!(0));
2673	}
2674
2675	/**
2676	* Evaluates a sequence of tokens within a particular environment context,
2677	* and returns the current value. May recur if parantheses are found.
2678	*
2679	* \param tokens A list of tokens to evaluate.
2680	* \param n_tokens How many tokens are in the list.
2681	* \param env The environment context in which to evaluate the expression.
2682	* \param[out] result The current value of the expression
2683	*
2684	* \bug Yes, we really do reparse the expression every time it's evaluated.
2685	* We should keep the parse tree around all the time and just
2686	* run the new values through it.
2687	* \ingroup parser
2688	*/
2689	static gboolean
2690	pos_eval_helper (PosToken *tokens,
2691	int n_tokens,
2692	const MetaPositionExprEnv *env,
2693	PosExpr *result,
2694	GError **err)
2695	{
2696	/* Lazy-ass hardcoded limit on number of terms in expression */
2697	#define MAX_EXPRS32 32
2698	int paren_level;
2699	int first_paren;
2700	int i;
2701	PosExpr exprs[MAX_EXPRS32];
2702	int n_exprs;
2703	int precedence;
2704
2705	/* Our first goal is to get a list of PosExpr, essentially
2706	* substituting variables and handling parentheses.
2707	*/
2708
2709	first_paren = 0;
2710	paren_level = 0;
2711	n_exprs = 0;
2712	for (i = 0; i < n_tokens; i++)
2713	{
2714	PosToken *t = &tokens[i];
2715
2716	if (n_exprs >= MAX_EXPRS32)
2717	{
2718	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2719	META_THEME_ERROR_FAILED,
2720	_("Coordinate expression parser overflowed its buffer.")dgettext ("croma", "Coordinate expression parser overflowed its buffer." ));
2721	return FALSE(0);
2722	}
2723
2724	if (paren_level == 0)
2725	{
2726	switch (t->type)
2727	{
2728	case POS_TOKEN_INT:
2729	exprs[n_exprs].type = POS_EXPR_INT;
2730	exprs[n_exprs].d.int_val = t->d.i.val;
2731	++n_exprs;
2732	break;
2733
2734	case POS_TOKEN_DOUBLE:
2735	exprs[n_exprs].type = POS_EXPR_DOUBLE;
2736	exprs[n_exprs].d.double_val = t->d.d.val;
2737	++n_exprs;
2738	break;
2739
2740	case POS_TOKEN_OPEN_PAREN:
2741	++paren_level;
2742	if (paren_level == 1)
2743	first_paren = i;
2744	break;
2745
2746	case POS_TOKEN_CLOSE_PAREN:
2747	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2748	META_THEME_ERROR_BAD_PARENS,
2749	_("Coordinate expression had a close parenthesis with no open parenthesis")dgettext ("croma", "Coordinate expression had a close parenthesis with no open parenthesis" ));
2750	return FALSE(0);
2751
2752	case POS_TOKEN_VARIABLE:
2753	exprs[n_exprs].type = POS_EXPR_INT;
2754
2755	/* FIXME we should just dump all this crap
2756	* in a hash, maybe keep width/height out
2757	* for optimization purposes
2758	*/
2759	if (!pos_eval_get_variable (t, &exprs[n_exprs].d.int_val, env, err))
2760	return FALSE(0);
2761
2762	++n_exprs;
2763	break;
2764
2765	case POS_TOKEN_OPERATOR:
2766	exprs[n_exprs].type = POS_EXPR_OPERATOR;
2767	exprs[n_exprs].d.operator = t->d.o.op;
2768	++n_exprs;
2769	break;
2770	}
2771	}
2772	else
2773	{
2774	g_assert (paren_level > 0)do { if (paren_level > 0) ; else g_assertion_message_expr ( "croma", "ui/theme.c", 2774, ((const char*) (__func__)), "paren_level > 0" ); } while (0);
2775
2776	switch (t->type)
2777	{
2778	case POS_TOKEN_INT:
2779	case POS_TOKEN_DOUBLE:
2780	case POS_TOKEN_VARIABLE:
2781	case POS_TOKEN_OPERATOR:
2782	break;
2783
2784	case POS_TOKEN_OPEN_PAREN:
2785	++paren_level;
2786	break;
2787
2788	case POS_TOKEN_CLOSE_PAREN:
2789	if (paren_level == 1)
2790	{
2791	/* We closed a toplevel paren group, so recurse */
2792	if (!pos_eval_helper (&tokens[first_paren+1],
2793	i - first_paren - 1,
2794	env,
2795	&exprs[n_exprs],
2796	err))
2797	return FALSE(0);
2798
2799	++n_exprs;
2800	}
2801
2802	--paren_level;
2803	break;
2804
2805	}
2806	}
2807	}
2808
2809	if (paren_level > 0)
2810	{
2811	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2812	META_THEME_ERROR_BAD_PARENS,
2813	_("Coordinate expression had an open parenthesis with no close parenthesis")dgettext ("croma", "Coordinate expression had an open parenthesis with no close parenthesis" ));
2814	return FALSE(0);
2815	}
2816
2817	/* Now we have no parens and no vars; so we just do all the multiplies
2818	* and divides, then all the add and subtract.
2819	*/
2820	if (n_exprs == 0)
2821	{
2822	g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
2823	META_THEME_ERROR_FAILED,
2824	_("Coordinate expression doesn't seem to have any operators or operands")dgettext ("croma", "Coordinate expression doesn't seem to have any operators or operands" ));
2825	return FALSE(0);
2826	}
2827
2828	/* precedence 1 ops */
2829	precedence = 2;
2830	while (precedence >= 0)
2831	{
2832	if (!do_operations (exprs, &n_exprs, precedence, err))
2833	return FALSE(0);
2834	--precedence;
2835	}
2836
2837	g_assert (n_exprs == 1)do { if (n_exprs == 1) ; else g_assertion_message_expr ("croma" , "ui/theme.c", 2837, ((const char*) (__func__)), "n_exprs == 1" ); } while (0);
2838
2839	result = exprs;
2840
2841	return TRUE(!(0));
2842	}
2843
2844	/*
2845	* expr = int \| double \| expr * expr \| expr / expr \|
2846	* expr + expr \| expr - expr \| (expr)
2847	*
2848	* so very not worth fooling with bison, yet so very painful by hand.
2849	*/
2850	/**
2851	* Evaluates an expression.
2852	*
2853	* \param spec The expression to evaluate.
2854	* \param env The environment context to evaluate the expression in.
2855	* \param[out] val_p The integer value of the expression; if the expression
2856	* is of type float, this will be rounded. If we return
2857	* FALSE because the expression is invalid, this will be
2858	* zero.
2859	* \param[out] err The error, if anything went wrong.
2860	*
2861	* \return True if we evaluated the expression successfully; false otherwise.
2862	*
2863	* \bug Shouldn't spec be const?
2864	* \ingroup parser
2865	*/
2866	static gboolean
2867	pos_eval (MetaDrawSpec *spec,
2868	const MetaPositionExprEnv *env,
2869	int *val_p,
2870	GError **err)
2871	{
2872	PosExpr expr;
2873
2874	*val_p = 0;
2875
2876	if (pos_eval_helper (spec->tokens, spec->n_tokens, env, &expr, err))
2877	{
2878	switch (expr.type)
2879	{
2880	case POS_EXPR_INT:
2881	*val_p = expr.d.int_val;
2882	break;
2883	case POS_EXPR_DOUBLE:
2884	*val_p = expr.d.double_val;
2885	break;
2886	case POS_EXPR_OPERATOR:
2887	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2887, ( (const char) (__func__)), ((void)0)); } while (0);
2888	break;
2889	}
2890	return TRUE(!(0));
2891	}
2892	else
2893	{
2894	return FALSE(0);
2895	}
2896	}
2897
2898	/* We always return both X and Y, but only one will be meaningful in
2899	* most contexts.
2900	*/
2901
2902	gboolean
2903	meta_parse_position_expression (MetaDrawSpec *spec,
2904	const MetaPositionExprEnv *env,
2905	int *x_return,
2906	int *y_return,
2907	GError **err)
2908	{
2909	/* All positions are in a coordinate system with x, y at the origin.
2910	* The expression can have -, +, *, / as operators, floating point
2911	* or integer constants, and the variables "width" and "height" and
2912	* optionally "object_width" and object_height". Negative numbers
2913	* aren't allowed.
2914	*/
2915	int val;
2916
2917	if (spec->constant)
2918	val = spec->value;
2919	else
2920	{
2921	if (pos_eval (spec, env, &spec->value, err) == FALSE(0))
2922	{
2923	g_assert (err == NULL \|\| err != NULL)do { if (err == ((void)0) \|\| err != ((void)0)) ; else g_assertion_message_expr ("croma", "ui/theme.c", 2923, ((const char) (__func__)), "err == NULL \|\| err != NULL" ); } while (0);
2924	return FALSE(0);
2925	}
2926
2927	val = spec->value;
2928	}
2929
2930	if (x_return)
2931	*x_return = env->rect.x + val;
2932	if (y_return)
2933	*y_return = env->rect.y + val;
2934
2935	return TRUE(!(0));
2936	}
2937
2938
2939	gboolean
2940	meta_parse_size_expression (MetaDrawSpec *spec,
2941	const MetaPositionExprEnv *env,
2942	int *val_return,
2943	GError **err)
2944	{
2945	int val;
2946
2947	if (spec->constant)
2948	val = spec->value;
2949	else
2950	{
2951	if (pos_eval (spec, env, &spec->value, err) == FALSE(0))
2952	{
2953	g_assert (err == NULL \|\| err != NULL)do { if (err == ((void)0) \|\| err != ((void)0)) ; else g_assertion_message_expr ("croma", "ui/theme.c", 2953, ((const char) (__func__)), "err == NULL \|\| err != NULL" ); } while (0);
2954	return FALSE(0);
2955	}
2956
2957	val = spec->value;
2958	}
2959
2960	if (val_return)
2961	val_return = MAX (val, 1)(((val) > (1)) ? (val) : (1)); / require that sizes be at least 1x1 */
2962
2963	return TRUE(!(0));
2964	}
2965
2966	/* To do this we tokenize, replace variable tokens
2967	* that are constants, then reassemble. The purpose
2968	* here is to optimize expressions so we don't do hash
2969	* lookups to eval them. Obviously it's a tradeoff that
2970	* slows down theme load times.
2971	*/
2972	gboolean
2973	meta_theme_replace_constants (MetaTheme *theme,
2974	PosToken *tokens,
2975	int n_tokens,
2976	GError **err)
2977	{
2978	int i;
2979	double dval;
2980	int ival;
2981	gboolean is_constant = TRUE(!(0));
2982
2983	/* Loop through tokenized string looking for variables to replace */
2984	for (i = 0; i < n_tokens; i++)
2985	{
2986	PosToken *t = &tokens[i];
2987
2988	if (t->type == POS_TOKEN_VARIABLE)
2989	{
2990	if (meta_theme_lookup_int_constant (theme, t->d.v.name, &ival))
2991	{
2992	g_free (t->d.v.name);
2993	t->type = POS_TOKEN_INT;
2994	t->d.i.val = ival;
2995	}
2996	else if (meta_theme_lookup_float_constant (theme, t->d.v.name, &dval))
2997	{
2998	g_free (t->d.v.name);
2999	t->type = POS_TOKEN_DOUBLE;
3000	t->d.d.val = dval;
3001	}
3002	else
3003	{
3004	/* If we've found a variable that cannot be replaced then the
3005	expression is not a constant expression and we want to
3006	replace it with a GQuark */
3007
3008	t->d.v.name_quark = g_quark_from_string (t->d.v.name);
3009	is_constant = FALSE(0);
3010	}
3011	}
3012	}
3013
3014	return is_constant;
3015	}
3016
3017	static int
3018	parse_x_position_unchecked (MetaDrawSpec *spec,
3019	const MetaPositionExprEnv *env)
3020	{
3021	int retval;
3022	GError *error;
3023
3024	retval = 0;
3025	error = NULL((void*)0);
3026	if (!meta_parse_position_expression (spec, env, &retval, NULL((void*)0), &error))
3027	{
3028	meta_warning (_("Theme contained an expression that resulted in an error: %s\n")dgettext ("croma", "Theme contained an expression that resulted in an error: %s\n" ),
3029	error->message);
3030
3031	g_error_free (error);
3032	}
3033
3034	return retval;
3035	}
3036
3037	static int
3038	parse_y_position_unchecked (MetaDrawSpec *spec,
3039	const MetaPositionExprEnv *env)
3040	{
3041	int retval;
3042	GError *error;
3043
3044	retval = 0;
3045	error = NULL((void*)0);
3046	if (!meta_parse_position_expression (spec, env, NULL((void*)0), &retval, &error))
3047	{
3048	meta_warning (_("Theme contained an expression that resulted in an error: %s\n")dgettext ("croma", "Theme contained an expression that resulted in an error: %s\n" ),
3049	error->message);
3050
3051	g_error_free (error);
3052	}
3053
3054	return retval;
3055	}
3056
3057	static int
3058	parse_size_unchecked (MetaDrawSpec *spec,
3059	MetaPositionExprEnv *env)
3060	{
3061	int retval;
3062	GError *error;
3063
3064	retval = 0;
3065	error = NULL((void*)0);
3066	if (!meta_parse_size_expression (spec, env, &retval, &error))
3067	{
3068	meta_warning (_("Theme contained an expression that resulted in an error: %s\n")dgettext ("croma", "Theme contained an expression that resulted in an error: %s\n" ),
3069	error->message);
3070
3071	g_error_free (error);
3072	}
3073
3074	return retval;
3075	}
3076
3077	void
3078	meta_draw_spec_free (MetaDrawSpec *spec)
3079	{
3080	if (!spec) return;
3081	free_tokens (spec->tokens, spec->n_tokens);
3082	g_slice_free (MetaDrawSpec, spec)do { if (1) g_slice_free1 (sizeof (MetaDrawSpec), (spec)); else (void) ((MetaDrawSpec*) 0 == (spec)); } while (0);
3083	}
3084
3085	MetaDrawSpec *
3086	meta_draw_spec_new (MetaTheme *theme,
3087	const char *expr,
3088	GError **error)
3089	{
3090	MetaDrawSpec *spec;
3091
3092	spec = g_slice_new0 (MetaDrawSpec)((MetaDrawSpec*) g_slice_alloc0 (sizeof (MetaDrawSpec)));
3093
3094	pos_tokenize (expr, &spec->tokens, &spec->n_tokens, NULL((void*)0));
3095
3096	spec->constant = meta_theme_replace_constants (theme, spec->tokens,
3097	spec->n_tokens, NULL((void*)0));
3098	if (spec->constant)
3099	{
3100	gboolean result;
3101
3102	result = pos_eval (spec, NULL((void*)0), &spec->value, error);
3103	if (result == FALSE(0))
3104	{
3105	meta_draw_spec_free (spec);
3106	return NULL((void*)0);
3107	}
3108	}
3109
3110	return spec;
3111	}
3112
3113	MetaDrawOp*
3114	meta_draw_op_new (MetaDrawType type)
3115	{
3116	MetaDrawOp *op;
3117	MetaDrawOp dummy;
3118	int size;
3119
3120	size = G_STRUCT_OFFSET (MetaDrawOp, data)((glong) __builtin_offsetof(MetaDrawOp, data));
3121
3122	switch (type)
3123	{
3124	case META_DRAW_LINE:
3125	size += sizeof (dummy.data.line);
3126	break;
3127
3128	case META_DRAW_RECTANGLE:
3129	size += sizeof (dummy.data.rectangle);
3130	break;
3131
3132	case META_DRAW_ARC:
3133	size += sizeof (dummy.data.arc);
3134	break;
3135
3136	case META_DRAW_CLIP:
3137	size += sizeof (dummy.data.clip);
3138	break;
3139
3140	case META_DRAW_TINT:
3141	size += sizeof (dummy.data.tint);
3142	break;
3143
3144	case META_DRAW_GRADIENT:
3145	size += sizeof (dummy.data.gradient);
3146	break;
3147
3148	case META_DRAW_IMAGE:
3149	size += sizeof (dummy.data.image);
3150	break;
3151
3152	case META_DRAW_CTK_ARROW:
3153	size += sizeof (dummy.data.ctk_arrow);
3154	break;
3155
3156	case META_DRAW_CTK_BOX:
3157	size += sizeof (dummy.data.ctk_box);
3158	break;
3159
3160	case META_DRAW_CTK_VLINE:
3161	size += sizeof (dummy.data.ctk_vline);
3162	break;
3163
3164	case META_DRAW_ICON:
3165	size += sizeof (dummy.data.icon);
3166	break;
3167
3168	case META_DRAW_TITLE:
3169	size += sizeof (dummy.data.title);
3170	break;
3171	case META_DRAW_OP_LIST:
3172	size += sizeof (dummy.data.op_list);
3173	break;
3174	case META_DRAW_TILE:
3175	size += sizeof (dummy.data.tile);
3176	break;
3177	}
3178
3179	op = g_malloc0 (size);
3180
3181	op->type = type;
3182
3183	return op;
3184	}
3185
3186	void
3187	meta_draw_op_free (MetaDrawOp *op)
3188	{
3189	g_return_if_fail (op != NULL)do { if ((op != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "op != NULL"); return; } } while (0);
3190
3191	switch (op->type)
3192	{
3193	case META_DRAW_LINE:
3194	if (op->data.line.color_spec)
3195	meta_color_spec_free (op->data.line.color_spec);
3196
3197	meta_draw_spec_free (op->data.line.x1);
3198	meta_draw_spec_free (op->data.line.y1);
3199	meta_draw_spec_free (op->data.line.x2);
3200	meta_draw_spec_free (op->data.line.y2);
3201	break;
3202
3203	case META_DRAW_RECTANGLE:
3204	if (op->data.rectangle.color_spec)
3205	g_free (op->data.rectangle.color_spec);
3206
3207	meta_draw_spec_free (op->data.rectangle.x);
3208	meta_draw_spec_free (op->data.rectangle.y);
3209	meta_draw_spec_free (op->data.rectangle.width);
3210	meta_draw_spec_free (op->data.rectangle.height);
3211	break;
3212
3213	case META_DRAW_ARC:
3214	if (op->data.arc.color_spec)
3215	g_free (op->data.arc.color_spec);
3216
3217	meta_draw_spec_free (op->data.arc.x);
3218	meta_draw_spec_free (op->data.arc.y);
3219	meta_draw_spec_free (op->data.arc.width);
3220	meta_draw_spec_free (op->data.arc.height);
3221	break;
3222
3223	case META_DRAW_CLIP:
3224	meta_draw_spec_free (op->data.clip.x);
3225	meta_draw_spec_free (op->data.clip.y);
3226	meta_draw_spec_free (op->data.clip.width);
3227	meta_draw_spec_free (op->data.clip.height);
3228	break;
3229
3230	case META_DRAW_TINT:
3231	if (op->data.tint.color_spec)
3232	meta_color_spec_free (op->data.tint.color_spec);
3233
3234	if (op->data.tint.alpha_spec)
3235	meta_alpha_gradient_spec_free (op->data.tint.alpha_spec);
3236
3237	meta_draw_spec_free (op->data.tint.x);
3238	meta_draw_spec_free (op->data.tint.y);
3239	meta_draw_spec_free (op->data.tint.width);
3240	meta_draw_spec_free (op->data.tint.height);
3241	break;
3242
3243	case META_DRAW_GRADIENT:
3244	if (op->data.gradient.gradient_spec)
3245	meta_gradient_spec_free (op->data.gradient.gradient_spec);
3246
3247	if (op->data.gradient.alpha_spec)
3248	meta_alpha_gradient_spec_free (op->data.gradient.alpha_spec);
3249
3250	meta_draw_spec_free (op->data.gradient.x);
3251	meta_draw_spec_free (op->data.gradient.y);
3252	meta_draw_spec_free (op->data.gradient.width);
3253	meta_draw_spec_free (op->data.gradient.height);
3254	break;
3255
3256	case META_DRAW_IMAGE:
3257	if (op->data.image.alpha_spec)
3258	meta_alpha_gradient_spec_free (op->data.image.alpha_spec);
3259
3260	if (op->data.image.pixbuf)
3261	g_object_unref (G_OBJECT (op->data.image.pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((op->data.image.pixbuf)), (((GType) ((20) << (2) ))))))));
3262
3263	if (op->data.image.colorize_spec)
3264	meta_color_spec_free (op->data.image.colorize_spec);
3265
3266	if (op->data.image.colorize_cache_pixbuf)
3267	g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((op->data.image.colorize_cache_pixbuf)), (((GType) ((20 ) << (2)))))))));
3268
3269	meta_draw_spec_free (op->data.image.x);
3270	meta_draw_spec_free (op->data.image.y);
3271	meta_draw_spec_free (op->data.image.width);
3272	meta_draw_spec_free (op->data.image.height);
3273	break;
3274
3275	case META_DRAW_CTK_ARROW:
3276	meta_draw_spec_free (op->data.ctk_arrow.x);
3277	meta_draw_spec_free (op->data.ctk_arrow.y);
3278	meta_draw_spec_free (op->data.ctk_arrow.width);
3279	meta_draw_spec_free (op->data.ctk_arrow.height);
3280	break;
3281
3282	case META_DRAW_CTK_BOX:
3283	meta_draw_spec_free (op->data.ctk_box.x);
3284	meta_draw_spec_free (op->data.ctk_box.y);
3285	meta_draw_spec_free (op->data.ctk_box.width);
3286	meta_draw_spec_free (op->data.ctk_box.height);
3287	break;
3288
3289	case META_DRAW_CTK_VLINE:
3290	meta_draw_spec_free (op->data.ctk_vline.x);
3291	meta_draw_spec_free (op->data.ctk_vline.y1);
3292	meta_draw_spec_free (op->data.ctk_vline.y2);
3293	break;
3294
3295	case META_DRAW_ICON:
3296	if (op->data.icon.alpha_spec)
3297	meta_alpha_gradient_spec_free (op->data.icon.alpha_spec);
3298
3299	meta_draw_spec_free (op->data.icon.x);
3300	meta_draw_spec_free (op->data.icon.y);
3301	meta_draw_spec_free (op->data.icon.width);
3302	meta_draw_spec_free (op->data.icon.height);
3303	break;
3304
3305	case META_DRAW_TITLE:
3306	if (op->data.title.color_spec)
3307	meta_color_spec_free (op->data.title.color_spec);
3308
3309	meta_draw_spec_free (op->data.title.x);
3310	meta_draw_spec_free (op->data.title.y);
3311	if (op->data.title.ellipsize_width)
3312	meta_draw_spec_free (op->data.title.ellipsize_width);
3313	break;
3314
3315	case META_DRAW_OP_LIST:
3316	if (op->data.op_list.op_list)
3317	meta_draw_op_list_unref (op->data.op_list.op_list);
3318
3319	meta_draw_spec_free (op->data.op_list.x);
3320	meta_draw_spec_free (op->data.op_list.y);
3321	meta_draw_spec_free (op->data.op_list.width);
3322	meta_draw_spec_free (op->data.op_list.height);
3323	break;
3324
3325	case META_DRAW_TILE:
3326	if (op->data.tile.op_list)
3327	meta_draw_op_list_unref (op->data.tile.op_list);
3328
3329	meta_draw_spec_free (op->data.tile.x);
3330	meta_draw_spec_free (op->data.tile.y);
3331	meta_draw_spec_free (op->data.tile.width);
3332	meta_draw_spec_free (op->data.tile.height);
3333	meta_draw_spec_free (op->data.tile.tile_xoffset);
3334	meta_draw_spec_free (op->data.tile.tile_yoffset);
3335	meta_draw_spec_free (op->data.tile.tile_width);
3336	meta_draw_spec_free (op->data.tile.tile_height);
3337	break;
3338	}
3339
3340	g_free (op);
3341	}
3342
3343	static GdkPixbuf*
3344	apply_alpha (GdkPixbuf *pixbuf,
3345	MetaAlphaGradientSpec *spec,
3346	gboolean force_copy)
3347	{
3348	GdkPixbuf *new_pixbuf;
3349	gboolean needs_alpha;
3350
3351	g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL)do { if (((((__extension__ ({ GTypeInstance __inst = (GTypeInstance ) ((pixbuf)); GType __t = ((gdk_pixbuf_get_type ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__ )), "GDK_IS_PIXBUF (pixbuf)"); return (((void)0)); } } while (0);
3352
3353	needs_alpha = spec && (spec->n_alphas > 1 \|\|
3354	spec->alphas[0] != 0xff);
3355
3356	if (!needs_alpha)
3357	return pixbuf;
3358
3359	if (!gdk_pixbuf_get_has_alpha (pixbuf))
3360	{
3361	new_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE(0), 0, 0, 0);
3362	g_object_unref (G_OBJECT (pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((pixbuf)), (((GType) ((20) << (2)))))))));
3363	pixbuf = new_pixbuf;
3364	}
3365	else if (force_copy)
3366	{
3367	new_pixbuf = gdk_pixbuf_copy (pixbuf);
3368	g_object_unref (G_OBJECT (pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((pixbuf)), (((GType) ((20) << (2)))))))));
3369	pixbuf = new_pixbuf;
3370	}
3371
3372	g_assert (gdk_pixbuf_get_has_alpha (pixbuf))do { if (gdk_pixbuf_get_has_alpha (pixbuf)) ; else g_assertion_message_expr ("croma", "ui/theme.c", 3372, ((const char*) (__func__)), "gdk_pixbuf_get_has_alpha (pixbuf)" ); } while (0);
3373
3374	meta_gradient_add_alpha (pixbuf, spec->alphas, spec->n_alphas, spec->type);
3375
3376	return pixbuf;
3377	}
3378
3379	static GdkPixbuf*
3380	pixbuf_tile (GdkPixbuf *tile,
3381	int width,
3382	int height)
3383	{
3384	GdkPixbuf *pixbuf;
3385	int tile_width;
3386	int tile_height;
3387	int i;
3388
3389	tile_width = gdk_pixbuf_get_width (tile);
3390	tile_height = gdk_pixbuf_get_height (tile);
3391
3392	pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
3393	gdk_pixbuf_get_has_alpha (tile),
3394	8, width, height);
3395
3396	i = 0;
3397	while (i < width)
3398	{
3399	int j;
3400
3401	j = 0;
3402	while (j < height)
3403	{
3404	int w, h;
3405
3406	w = MIN (tile_width, width - i)(((tile_width) < (width - i)) ? (tile_width) : (width - i) );
3407	h = MIN (tile_height, height - j)(((tile_height) < (height - j)) ? (tile_height) : (height - j));
3408
3409	gdk_pixbuf_copy_area (tile,
3410	0, 0,
3411	w, h,
3412	pixbuf,
3413	i, j);
3414
3415	j += tile_height;
3416	}
3417
3418	i += tile_width;
3419	}
3420
3421	return pixbuf;
3422	}
3423
3424	static GdkPixbuf *
3425	replicate_rows (GdkPixbuf *src,
3426	int src_x,
3427	int src_y,
3428	int width,
3429	int height)
3430	{
3431	unsigned int n_channels = gdk_pixbuf_get_n_channels (src);
3432	unsigned int src_rowstride = gdk_pixbuf_get_rowstride (src);
3433	unsigned char pixels = (gdk_pixbuf_get_pixels (src) + src_y src_rowstride + src_x
3434	* n_channels);
3435	unsigned char *dest_pixels;
3436	GdkPixbuf *result;
3437	unsigned int dest_rowstride;
3438	int i;
3439
3440	result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,
3441	width, height);
3442	dest_rowstride = gdk_pixbuf_get_rowstride (result);
3443	dest_pixels = gdk_pixbuf_get_pixels (result);
3444
3445	for (i = 0; i < height; i++)
3446	memcpy (dest_pixels + dest_rowstride * i, pixels, n_channels * width);
3447
3448	return result;
3449	}
3450
3451	static GdkPixbuf *
3452	replicate_cols (GdkPixbuf *src,
3453	int src_x,
3454	int src_y,
3455	int width,
3456	int height)
3457	{
3458	unsigned int n_channels = gdk_pixbuf_get_n_channels (src);
3459	unsigned int src_rowstride = gdk_pixbuf_get_rowstride (src);
3460	unsigned char pixels = (gdk_pixbuf_get_pixels (src) + src_y src_rowstride + src_x
3461	* n_channels);
3462	unsigned char *dest_pixels;
3463	GdkPixbuf *result;
3464	unsigned int dest_rowstride;
3465	int i, j;
3466
3467	result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,
3468	width, height);
3469	dest_rowstride = gdk_pixbuf_get_rowstride (result);
3470	dest_pixels = gdk_pixbuf_get_pixels (result);
3471
3472	for (i = 0; i < height; i++)
3473	{
3474	unsigned char p = dest_pixels + dest_rowstride i;
3475	unsigned char q = pixels + src_rowstride i;
3476
3477	unsigned char r = *(q++);
3478	unsigned char g = *(q++);
3479	unsigned char b = *(q++);
3480
3481	if (n_channels == 4)
3482	{
3483	unsigned char a;
3484
3485	a = *(q++);
3486
3487	for (j = 0; j < width; j++)
3488	{
3489	*(p++) = r;
3490	*(p++) = g;
3491	*(p++) = b;
3492	*(p++) = a;
3493	}
3494	}
3495	else
3496	{
3497	for (j = 0; j < width; j++)
3498	{
3499	*(p++) = r;
3500	*(p++) = g;
3501	*(p++) = b;
3502	}
3503	}
3504	}
3505
3506	return result;
3507	}
3508
3509	static GdkPixbuf*
3510	scale_and_alpha_pixbuf (GdkPixbuf *src,
3511	MetaAlphaGradientSpec *alpha_spec,
3512	MetaImageFillType fill_type,
3513	int width,
3514	int height,
3515	gboolean vertical_stripes,
3516	gboolean horizontal_stripes)
3517	{
3518	GdkPixbuf *pixbuf;
3519	GdkPixbuf *temp_pixbuf;
3520
3521	pixbuf = NULL((void*)0);
3522
3523	pixbuf = src;
3524
3525	if (gdk_pixbuf_get_width (pixbuf) == width &&
3526	gdk_pixbuf_get_height (pixbuf) == height)
3527	{
3528	g_object_ref (G_OBJECT (pixbuf))((__typeof__ (((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance) ((pixbuf)), (((GType) ((20) << (2))) ))))))) (g_object_ref) (((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance) ((pixbuf)), (((GType) ((20) << (2))) )))))));
3529	}
3530	else
3531	{
3532	if (fill_type == META_IMAGE_FILL_TILE)
3533	{
3534	pixbuf = pixbuf_tile (pixbuf, width, height);
3535	}
3536	else
3537	{
3538	int src_h, src_w, dest_h, dest_w;
3539	src_h = gdk_pixbuf_get_height (src);
3540	src_w = gdk_pixbuf_get_width (src);
3541
3542	/* prefer to replicate_cols if possible, as that
3543	* is faster (no memory reads)
3544	*/
3545	if (horizontal_stripes)
3546	{
3547	dest_w = gdk_pixbuf_get_width (src);
3548	dest_h = height;
3549	}
3550	else if (vertical_stripes)
3551	{
3552	dest_w = width;
3553	dest_h = gdk_pixbuf_get_height (src);
3554	}
3555
3556	else
3557	{
3558	dest_w = width;
3559	dest_h = height;
3560	}
3561
3562	if (dest_w == src_w && dest_h == src_h)
3563	{
3564	temp_pixbuf = src;
3565	g_object_ref (G_OBJECT (temp_pixbuf))((__typeof__ (((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance) ((temp_pixbuf)), (((GType) ((20) << ( 2)))))))))) (g_object_ref) (((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance) ((temp_pixbuf)), (((GType) ((20) << ( 2))))))))));
3566	}
3567	else
3568	{
3569	temp_pixbuf = gdk_pixbuf_scale_simple (src,
3570	dest_w, dest_h,
3571	GDK_INTERP_BILINEAR);
3572	}
3573
3574	/* prefer to replicate_cols if possible, as that
3575	* is faster (no memory reads)
3576	*/
3577	if (horizontal_stripes)
3578	{
3579	pixbuf = replicate_cols (temp_pixbuf, 0, 0, width, height);
3580	g_object_unref (G_OBJECT (temp_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((temp_pixbuf)), (((GType) ((20) << (2)))))))));
3581	}
3582	else if (vertical_stripes)
3583	{
3584	pixbuf = replicate_rows (temp_pixbuf, 0, 0, width, height);
3585	g_object_unref (G_OBJECT (temp_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((temp_pixbuf)), (((GType) ((20) << (2)))))))));
3586	}
3587	else
3588	{
3589	pixbuf = temp_pixbuf;
3590	}
3591	}
3592	}
3593
3594	if (pixbuf)
3595	pixbuf = apply_alpha (pixbuf, alpha_spec, pixbuf == src);
3596
3597	return pixbuf;
3598	}
3599
3600	static GdkPixbuf*
3601	draw_op_as_pixbuf (const MetaDrawOp *op,
3602	CtkStyleContext *style,
3603	const MetaDrawInfo *info,
3604	int width,
3605	int height)
3606	{
3607	/* Try to get the op as a pixbuf, assuming w/h in the op
3608	* matches the width/height passed in. return NULL
3609	* if the op can't be converted to an equivalent pixbuf.
3610	*/
3611	GdkPixbuf *pixbuf;
3612
3613	pixbuf = NULL((void*)0);
3614
3615	switch (op->type)
3616	{
3617	case META_DRAW_LINE:
3618	break;
3619
3620	case META_DRAW_RECTANGLE:
3621	if (op->data.rectangle.filled)
3622	{
3623	CdkRGBA color;
3624
3625	meta_color_spec_render (op->data.rectangle.color_spec,
3626	style,
3627	&color);
3628
3629	pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
3630	FALSE(0),
3631	8, width, height);
3632
3633	gdk_pixbuf_fill (pixbuf, CDK_COLOR_RGBA (color)((guint32) (0xff \| ((int)((color).red * 255) << 24) \| ( (int)((color).green * 255) << 16) \| ((int)((color).blue * 255) << 8))));
3634	}
3635	break;
3636
3637	case META_DRAW_ARC:
3638	break;
3639
3640	case META_DRAW_CLIP:
3641	break;
3642
3643	case META_DRAW_TINT:
3644	{
3645	CdkRGBA color;
3646	guint32 rgba;
3647	gboolean has_alpha;
3648
3649	meta_color_spec_render (op->data.rectangle.color_spec,
3650	style,
3651	&color);
3652
3653	has_alpha =
3654	op->data.tint.alpha_spec &&
3655	(op->data.tint.alpha_spec->n_alphas > 1 \|\|
3656	op->data.tint.alpha_spec->alphas[0] != 0xff);
3657
3658	pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
3659	has_alpha,
3660	8, width, height);
3661
3662	if (!has_alpha)
3663	{
3664	rgba = CDK_COLOR_RGBA (color)((guint32) (0xff \| ((int)((color).red * 255) << 24) \| ( (int)((color).green * 255) << 16) \| ((int)((color).blue * 255) << 8)));
3665
3666	gdk_pixbuf_fill (pixbuf, rgba);
3667	}
3668	else if (op->data.tint.alpha_spec->n_alphas == 1)
3669	{
3670	rgba = CDK_COLOR_RGBA (color)((guint32) (0xff \| ((int)((color).red * 255) << 24) \| ( (int)((color).green * 255) << 16) \| ((int)((color).blue * 255) << 8)));
3671	rgba &= ~0xff;
3672	rgba \|= op->data.tint.alpha_spec->alphas[0];
3673
3674	gdk_pixbuf_fill (pixbuf, rgba);
3675	}
3676	else
3677	{
3678	rgba = CDK_COLOR_RGBA (color)((guint32) (0xff \| ((int)((color).red * 255) << 24) \| ( (int)((color).green * 255) << 16) \| ((int)((color).blue * 255) << 8)));
3679
3680	gdk_pixbuf_fill (pixbuf, rgba);
3681
3682	meta_gradient_add_alpha (pixbuf,
3683	op->data.tint.alpha_spec->alphas,
3684	op->data.tint.alpha_spec->n_alphas,
3685	op->data.tint.alpha_spec->type);
3686	}
3687	}
3688	break;
3689
3690	case META_DRAW_IMAGE:
3691	{
3692	if (op->data.image.colorize_spec)
3693	{
3694	CdkRGBA color;
3695
3696	meta_color_spec_render (op->data.image.colorize_spec,
3697	style, &color);
3698
3699	if (op->data.image.colorize_cache_pixbuf == NULL((void*)0) \|\|
3700	op->data.image.colorize_cache_pixel != CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) \| ((int)(( color).green * 255) << 8) \| ((int)((color).blue * 255)) )))
3701	{
3702	if (op->data.image.colorize_cache_pixbuf)
3703	g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((op->data.image.colorize_cache_pixbuf)), (((GType) ((20 ) << (2)))))))));
3704
3705	/* const cast here */
3706	((MetaDrawOp*)op)->data.image.colorize_cache_pixbuf =
3707	colorize_pixbuf (op->data.image.pixbuf,
3708	&color);
3709	((MetaDrawOp*)op)->data.image.colorize_cache_pixel =
3710	CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) \| ((int)(( color).green * 255) << 8) \| ((int)((color).blue * 255)) ));
3711	}
3712
3713	if (op->data.image.colorize_cache_pixbuf)
3714	{
3715	pixbuf = scale_and_alpha_pixbuf (op->data.image.colorize_cache_pixbuf,
3716	op->data.image.alpha_spec,
3717	op->data.image.fill_type,
3718	width, height,
3719	op->data.image.vertical_stripes,
3720	op->data.image.horizontal_stripes);
3721	}
3722	}
3723	else
3724	{
3725	pixbuf = scale_and_alpha_pixbuf (op->data.image.pixbuf,
3726	op->data.image.alpha_spec,
3727	op->data.image.fill_type,
3728	width, height,
3729	op->data.image.vertical_stripes,
3730	op->data.image.horizontal_stripes);
3731	}
3732	break;
3733	}
3734
3735	case META_DRAW_GRADIENT:
3736	case META_DRAW_CTK_ARROW:
3737	case META_DRAW_CTK_BOX:
3738	case META_DRAW_CTK_VLINE:
3739	break;
3740
3741	case META_DRAW_ICON:
3742	if (info->mini_icon &&
3743	width <= gdk_pixbuf_get_width (info->mini_icon) &&
3744	height <= gdk_pixbuf_get_height (info->mini_icon))
3745	pixbuf = scale_and_alpha_pixbuf (info->mini_icon,
3746	op->data.icon.alpha_spec,
3747	op->data.icon.fill_type,
3748	width, height,
3749	FALSE(0), FALSE(0));
3750	else if (info->icon)
3751	pixbuf = scale_and_alpha_pixbuf (info->icon,
3752	op->data.icon.alpha_spec,
3753	op->data.icon.fill_type,
3754	width, height,
3755	FALSE(0), FALSE(0));
3756	break;
3757
3758	case META_DRAW_TITLE:
3759	break;
3760
3761	case META_DRAW_OP_LIST:
3762	break;
3763
3764	case META_DRAW_TILE:
3765	break;
3766	}
3767
3768	return pixbuf;
3769	}
3770
3771	static cairo_surface_t *
3772	draw_op_as_surface (const MetaDrawOp *op,
3773	CtkStyleContext *style,
3774	const MetaDrawInfo *info,
3775	gdouble width,
3776	gdouble height)
3777	{
3778	cairo_surface_t *surface;
3779
3780	surface = NULL((void*)0);
3781
3782	switch (op->type)
3783	{
3784	case META_DRAW_IMAGE:
3785	{
3786	if (op->data.image.colorize_spec)
3787	{
3788	CdkRGBA color;
3789
3790	meta_color_spec_render (op->data.image.colorize_spec,
3791	style, &color);
3792
3793	if (op->data.image.colorize_cache_pixbuf == NULL((void*)0) \|\|
3794	op->data.image.colorize_cache_pixel != CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) \| ((int)(( color).green * 255) << 8) \| ((int)((color).blue * 255)) )))
3795	{
3796	if (op->data.image.colorize_cache_pixbuf)
3797	g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((op->data.image.colorize_cache_pixbuf)), (((GType) ((20 ) << (2)))))))));
3798
3799	/* const cast here */
3800	((MetaDrawOp*)op)->data.image.colorize_cache_pixbuf =
3801	colorize_pixbuf (op->data.image.pixbuf,
3802	&color);
3803	((MetaDrawOp*)op)->data.image.colorize_cache_pixel =
3804	CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) \| ((int)(( color).green * 255) << 8) \| ((int)((color).blue * 255)) ));
3805	}
3806
3807	if (op->data.image.colorize_cache_pixbuf)
3808	{
3809	surface = get_surface_from_pixbuf (op->data.image.colorize_cache_pixbuf,
3810	op->data.image.fill_type,
3811	width, height,
3812	op->data.image.vertical_stripes,
3813	op->data.image.horizontal_stripes);
3814	}
3815	}
3816	else
3817	{
3818	surface = get_surface_from_pixbuf (op->data.image.pixbuf,
3819	op->data.image.fill_type,
3820	width, height,
3821	op->data.image.vertical_stripes,
3822	op->data.image.horizontal_stripes);
3823	}
3824	break;
3825	}
3826
3827	case META_DRAW_ICON:
3828	if (info->mini_icon &&
3829	width <= gdk_pixbuf_get_width (info->mini_icon) &&
3830	height <= gdk_pixbuf_get_height (info->mini_icon))
3831	surface = get_surface_from_pixbuf (info->mini_icon, op->data.icon.fill_type,
3832	width, height, FALSE(0), FALSE(0));
3833	else if (info->icon)
3834	surface = get_surface_from_pixbuf (info->icon, op->data.icon.fill_type,
3835	width, height, FALSE(0), FALSE(0));
3836	break;
3837
3838	case META_DRAW_TINT:
3839	case META_DRAW_LINE:
3840	case META_DRAW_RECTANGLE:
3841	case META_DRAW_ARC:
3842	case META_DRAW_CLIP:
3843	case META_DRAW_GRADIENT:
3844	case META_DRAW_CTK_ARROW:
3845	case META_DRAW_CTK_BOX:
3846	case META_DRAW_CTK_VLINE:
3847	case META_DRAW_TITLE:
3848	case META_DRAW_OP_LIST:
3849	case META_DRAW_TILE:
3850	break;
3851
3852	default:
3853	break;
3854	}
3855
3856	return surface;
3857	}
3858
3859	static void
3860	fill_env (MetaPositionExprEnv *env,
3861	const MetaDrawInfo *info,
3862	MetaRectangle logical_region)
3863	{
3864	/* FIXME this stuff could be raised into draw_op_list_draw() probably
3865	*/
3866	env->rect = logical_region;
3867	env->object_width = -1;
3868	env->object_height = -1;
3869	if (info->fgeom)
3870	{
3871	env->left_width = info->fgeom->borders.visible.left;
3872	env->right_width = info->fgeom->borders.visible.right;
3873	env->top_height = info->fgeom->borders.visible.top;
3874	env->bottom_height = info->fgeom->borders.visible.bottom;
3875	env->frame_x_center = info->fgeom->width / 2 - logical_region.x;
3876	env->frame_y_center = info->fgeom->height / 2 - logical_region.y;
3877	}
3878	else
3879	{
3880	env->left_width = 0;
3881	env->right_width = 0;
3882	env->top_height = 0;
3883	env->bottom_height = 0;
3884	env->frame_x_center = 0;
3885	env->frame_y_center = 0;
3886	}
3887
3888	env->mini_icon_width = info->mini_icon ? gdk_pixbuf_get_width (info->mini_icon) : 0;
3889	env->mini_icon_height = info->mini_icon ? gdk_pixbuf_get_height (info->mini_icon) : 0;
3890	env->icon_width = info->icon ? gdk_pixbuf_get_width (info->icon) : 0;
3891	env->icon_height = info->icon ? gdk_pixbuf_get_height (info->icon) : 0;
3892
3893	env->title_width = info->title_layout_width;
3894	env->title_height = info->title_layout_height;
3895	env->theme = meta_current_theme;
3896	}
3897
3898	/* This code was originally rendering anti-aliased using X primitives, and
3899	* now has been switched to draw anti-aliased using cairo. In general, the
3900	* closest correspondence between X rendering and cairo rendering is given
3901	* by offsetting the geometry by 0.5 pixels in both directions before rendering
3902	* with cairo. This is because X samples at the upper left corner of the
3903	* pixel while cairo averages over the entire pixel. However, in the cases
3904	* where the X rendering was an exact rectangle with no "jaggies"
3905	* we need to be a bit careful about applying the offset. We want to produce
3906	* the exact same pixel-aligned rectangle, rather than a rectangle with
3907	* fuzz around the edges.
3908	*/
3909	static void
3910	meta_draw_op_draw_with_env (const MetaDrawOp *op,
3911	CtkStyleContext *style_ctk,
3912	cairo_t *cr,
3913	const MetaDrawInfo *info,
3914	MetaRectangle rect,
3915	MetaPositionExprEnv *env)
3916	{
3917	CdkRGBA color;
3918
3919	cairo_save (cr);
3920	ctk_style_context_save (style_ctk);
3921
3922	cairo_set_line_width (cr, 1.0);
3923
3924	switch (op->type)
3925	{
3926	case META_DRAW_LINE:
3927	{
3928	int x1, y1;
3929
3930	meta_color_spec_render (op->data.line.color_spec, style_ctk, &color);
3931	cdk_cairo_set_source_rgba (cr, &color);
3932
3933	if (op->data.line.width > 0)
3934	cairo_set_line_width (cr, op->data.line.width);
3935
3936	if (op->data.line.dash_on_length > 0 &&
3937	op->data.line.dash_off_length > 0)
3938	{
3939	double dash_list[2];
3940	dash_list[0] = op->data.line.dash_on_length;
3941	dash_list[1] = op->data.line.dash_off_length;
3942	cairo_set_dash (cr, dash_list, 2, 0);
3943	}
3944
3945	x1 = parse_x_position_unchecked (op->data.line.x1, env);
3946	y1 = parse_y_position_unchecked (op->data.line.y1, env);
3947
3948	if (!op->data.line.x2 &&
3949	!op->data.line.y2 &&
3950	op->data.line.width==0)
3951	{
3952	cairo_rectangle (cr, x1, y1, 1, 1);
3953	cairo_fill (cr);
3954	}
3955	else
3956	{
3957	int x2, y2;
3958
3959	if (op->data.line.x2)
3960	x2 = parse_x_position_unchecked (op->data.line.x2, env);
3961	else
3962	x2 = x1;
3963
3964	if (op->data.line.y2)
3965	y2 = parse_y_position_unchecked (op->data.line.y2, env);
3966	else
3967	y2 = y1;
3968
3969	/* This is one of the cases where we are matching the exact
3970	* pixel aligned rectangle produced by X; for zero-width lines
3971	* the generic algorithm produces the right result so we don't
3972	* need to handle them here.
3973	*/
3974	if ((y1 == y2 \|\| x1 == x2) && op->data.line.width != 0)
3975	{
3976	double offset = op->data.line.width % 2 ? .5 : 0;
3977
3978	if (y1 == y2)
3979	{
3980	cairo_move_to (cr, x1, y1 + offset);
3981	cairo_line_to (cr, x2, y2 + offset);
3982	}
3983	else
3984	{
3985	cairo_move_to (cr, x1 + offset, y1);
3986	cairo_line_to (cr, x2 + offset, y2);
3987	}
3988	}
3989	else
3990	{
3991	/* zero-width lines include both end-points in X, unlike wide lines */
3992	if (op->data.line.width == 0)
3993	cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
3994
3995	cairo_move_to (cr, x1 + .5, y1 + .5);
3996	cairo_line_to (cr, x2 + .5, y2 + .5);
3997	}
3998	cairo_stroke (cr);
3999	}
4000	}
4001	break;
4002
4003	case META_DRAW_RECTANGLE:
4004	{
4005	int rx, ry, rwidth, rheight;
4006
4007	meta_color_spec_render (op->data.rectangle.color_spec, style_ctk, &color);
4008	cdk_cairo_set_source_rgba (cr, &color);
4009
4010	rx = parse_x_position_unchecked (op->data.rectangle.x, env);
4011	ry = parse_y_position_unchecked (op->data.rectangle.y, env);
4012	rwidth = parse_size_unchecked (op->data.rectangle.width, env);
4013	rheight = parse_size_unchecked (op->data.rectangle.height, env);
4014
4015	/* Filled and stroked rectangles are the other cases
4016	* we pixel-align to X rasterization
4017	*/
4018	if (op->data.rectangle.filled)
4019	{
4020	cairo_rectangle (cr, rx, ry, rwidth, rheight);
4021	cairo_fill (cr);
4022	}
4023	else
4024	{
4025	cairo_rectangle (cr, rx + .5, ry + .5, rwidth, rheight);
4026	cairo_stroke (cr);
4027	}
4028	}
4029	break;
4030
4031	case META_DRAW_ARC:
4032	{
4033	int rx, ry, rwidth, rheight;
4034	double start_angle, end_angle;
4035	double center_x, center_y;
4036
4037	meta_color_spec_render (op->data.arc.color_spec, style_ctk, &color);
4038	cdk_cairo_set_source_rgba (cr, &color);
4039
4040	rx = parse_x_position_unchecked (op->data.arc.x, env);
4041	ry = parse_y_position_unchecked (op->data.arc.y, env);
4042	rwidth = parse_size_unchecked (op->data.arc.width, env);
4043	rheight = parse_size_unchecked (op->data.arc.height, env);
4044
4045	start_angle = op->data.arc.start_angle * (M_PI3.14159265358979323846 / 180.)
4046	- (.5 * M_PI3.14159265358979323846); /* start at 12 instead of 3 oclock */
4047	end_angle = start_angle + op->data.arc.extent_angle * (M_PI3.14159265358979323846 / 180.);
4048	center_x = rx + (double)rwidth / 2. + .5;
4049	center_y = ry + (double)rheight / 2. + .5;
4050
4051	cairo_save (cr);
4052
4053	cairo_translate (cr, center_x, center_y);
4054	cairo_scale (cr, (double)rwidth / 2., (double)rheight / 2.);
4055
4056	if (op->data.arc.extent_angle >= 0)
4057	cairo_arc (cr, 0, 0, 1, start_angle, end_angle);
4058	else
4059	cairo_arc_negative (cr, 0, 0, 1, start_angle, end_angle);
4060
4061	cairo_restore (cr);
4062
4063	if (op->data.arc.filled)
4064	{
4065	cairo_line_to (cr, center_x, center_y);
4066	cairo_fill (cr);
4067	}
4068	else
4069	cairo_stroke (cr);
4070	}
4071	break;
4072
4073	case META_DRAW_CLIP:
4074	break;
4075
4076	case META_DRAW_TINT:
4077	{
4078	int rx, ry, rwidth, rheight;
4079	gboolean needs_alpha;
4080
4081	needs_alpha = op->data.tint.alpha_spec &&
4082	(op->data.tint.alpha_spec->n_alphas > 1 \|\|
4083	op->data.tint.alpha_spec->alphas[0] != 0xff);
4084
4085	rx = parse_x_position_unchecked (op->data.tint.x, env);
4086	ry = parse_y_position_unchecked (op->data.tint.y, env);
4087	rwidth = parse_size_unchecked (op->data.tint.width, env);
4088	rheight = parse_size_unchecked (op->data.tint.height, env);
4089
4090	if (!needs_alpha)
4091	{
4092	meta_color_spec_render (op->data.tint.color_spec, style_ctk, &color);
4093	cdk_cairo_set_source_rgba (cr, &color);
4094
4095	cairo_rectangle (cr, rx, ry, rwidth, rheight);
4096	cairo_fill (cr);
4097	}
4098	else
4099	{
4100	GdkPixbuf *pixbuf;
4101
4102	pixbuf = draw_op_as_pixbuf (op, style_ctk, info,
4103	rwidth, rheight);
4104
4105	if (pixbuf)
4106	{
4107	cdk_cairo_set_source_pixbuf (cr, pixbuf, rx, ry);
4108	cairo_paint (cr);
4109
4110	g_object_unref (G_OBJECT (pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((pixbuf)), (((GType) ((20) << (2)))))))));
4111	}
4112	}
4113	}
4114	break;
4115
4116	case META_DRAW_GRADIENT:
4117	{
4118	int rx, ry, rwidth, rheight;
4119
4120	rx = parse_x_position_unchecked (op->data.gradient.x, env);
4121	ry = parse_y_position_unchecked (op->data.gradient.y, env);
4122	rwidth = parse_size_unchecked (op->data.gradient.width, env);
4123	rheight = parse_size_unchecked (op->data.gradient.height, env);
4124
4125	meta_gradient_spec_render (op->data.gradient.gradient_spec,
4126	op->data.gradient.alpha_spec,
4127	cr, style_ctk, rx, ry, rwidth, rheight);
4128	}
4129	break;
4130
4131	case META_DRAW_IMAGE:
4132	{
4133	gint scale;
4134	gdouble rx, ry, rwidth, rheight;
4135	cairo_surface_t *surface;
4136
4137	scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());
4138	cairo_scale (cr, 1.0 / scale, 1.0 / scale);
4139
4140	if (op->data.image.pixbuf)
4141	{
4142	env->object_width = gdk_pixbuf_get_width (op->data.image.pixbuf) / scale;
4143	env->object_height = gdk_pixbuf_get_height (op->data.image.pixbuf) / scale;
4144	}
4145
4146	rwidth = parse_size_unchecked (op->data.image.width, env) * scale;
4147	rheight = parse_size_unchecked (op->data.image.height, env) * scale;
4148
4149	surface = draw_op_as_surface (op, style_ctk, info, rwidth, rheight);
4150
4151	if (surface)
4152	{
4153	rx = parse_x_position_unchecked (op->data.image.x, env) * scale;
4154	ry = parse_y_position_unchecked (op->data.image.y, env) * scale;
4155
4156	cairo_set_source_surface (cr, surface, rx, ry);
4157
4158	if (op->data.image.alpha_spec)
4159	{
4160	cairo_pattern_t *pattern;
4161
4162	cairo_translate (cr, rx, ry);
4163	cairo_scale (cr, rwidth, rheight);
4164
4165	pattern = meta_alpha_gradient_spec_get_mask (op->data.image.alpha_spec);
4166	cairo_mask (cr, pattern);
4167
4168	cairo_pattern_destroy (pattern);
4169	}
4170	else
4171	{
4172	cairo_paint (cr);
4173	}
4174
4175	cairo_surface_destroy (surface);
4176	}
4177	}
4178	break;
4179
4180	case META_DRAW_CTK_ARROW:
4181	{
4182	int rx, ry, rwidth, rheight;
4183
4184	rx = parse_x_position_unchecked (op->data.ctk_arrow.x, env);
4185	ry = parse_y_position_unchecked (op->data.ctk_arrow.y, env);
4186	rwidth = parse_size_unchecked (op->data.ctk_arrow.width, env);
4187	rheight = parse_size_unchecked (op->data.ctk_arrow.height, env);
4188
4189	double size = MAX(rwidth, rheight)(((rwidth) > (rheight)) ? (rwidth) : (rheight)), angle = 0;
4190
4191	switch (op->data.ctk_arrow.arrow)
4192	{
4193	case CTK_ARROW_UP:
4194	angle = 0;
4195	break;
4196	case CTK_ARROW_RIGHT:
4197	angle = M_PI3.14159265358979323846 / 2;
4198	break;
4199	case CTK_ARROW_DOWN:
4200	angle = M_PI3.14159265358979323846;
4201	break;
4202	case CTK_ARROW_LEFT:
4203	angle = 3 * M_PI3.14159265358979323846 / 2;
4204	break;
4205	case CTK_ARROW_NONE:
4206	return;
4207	}
4208
4209	ctk_style_context_set_state (style_ctk, op->data.ctk_arrow.state);
4210	ctk_render_arrow (style_ctk, cr, angle, rx, ry, size);
4211	}
4212	break;
4213
4214	case META_DRAW_CTK_BOX:
4215	{
4216	int rx, ry, rwidth, rheight;
4217
4218	rx = parse_x_position_unchecked (op->data.ctk_box.x, env);
4219	ry = parse_y_position_unchecked (op->data.ctk_box.y, env);
4220	rwidth = parse_size_unchecked (op->data.ctk_box.width, env);
4221	rheight = parse_size_unchecked (op->data.ctk_box.height, env);
4222
4223	ctk_style_context_set_state (style_ctk, op->data.ctk_box.state);
4224	ctk_render_background (style_ctk, cr, rx, ry, rwidth, rheight);
4225	ctk_render_frame (style_ctk, cr, rx, ry, rwidth, rheight);
4226	}
4227	break;
4228
4229	case META_DRAW_CTK_VLINE:
4230	{
4231	int rx, ry1, ry2;
4232
4233	rx = parse_x_position_unchecked (op->data.ctk_vline.x, env);
4234	ry1 = parse_y_position_unchecked (op->data.ctk_vline.y1, env);
4235	ry2 = parse_y_position_unchecked (op->data.ctk_vline.y2, env);
4236
4237	ctk_style_context_set_state (style_ctk, op->data.ctk_vline.state);
4238	ctk_render_line (style_ctk, cr, rx, ry1, rx, ry2);
4239	}
4240	break;
4241
4242	case META_DRAW_ICON:
4243	{
4244	gint scale;
4245	gdouble rx, ry, rwidth, rheight;
4246	cairo_surface_t *surface;
4247
4248	scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());
4249	cairo_scale (cr, 1.0 / scale, 1.0 / scale);
4250
4251	rwidth = parse_size_unchecked (op->data.icon.width, env) * scale;
4252	rheight = parse_size_unchecked (op->data.icon.height, env) * scale;
4253
4254	surface = draw_op_as_surface (op, style_ctk, info, rwidth, rheight);
4255
4256	if (surface)
4257	{
4258	rx = parse_x_position_unchecked (op->data.icon.x, env) * scale;
4259	ry = parse_y_position_unchecked (op->data.icon.y, env) * scale;
4260
4261	cairo_set_source_surface (cr, surface, rx, ry);
4262
4263	if (op->data.icon.alpha_spec)
4264	{
4265	cairo_pattern_t *pattern;
4266
4267	cairo_translate (cr, rx, ry);
4268	cairo_scale (cr, rwidth, rheight);
4269
4270	pattern = meta_alpha_gradient_spec_get_mask (op->data.icon.alpha_spec);
4271	cairo_mask (cr, pattern);
4272
4273	cairo_pattern_destroy (pattern);
4274	}
4275	else
4276	{
4277	cairo_paint (cr);
4278	}
4279
4280	cairo_surface_destroy (surface);
4281	}
4282	}
4283	break;
4284
4285	case META_DRAW_TITLE:
4286	if (info->title_layout)
4287	{
4288	int rx, ry;
4289	PangoRectangle ink_rect, logical_rect;
4290
4291	meta_color_spec_render (op->data.title.color_spec, style_ctk, &color);
4292	cdk_cairo_set_source_rgba (cr, &color);
4293
4294	rx = parse_x_position_unchecked (op->data.title.x, env);
4295	ry = parse_y_position_unchecked (op->data.title.y, env);
4296
4297	if (op->data.title.ellipsize_width)
4298	{
4299	int ellipsize_width;
4300	int right_bearing;
4301
4302	ellipsize_width = parse_x_position_unchecked (op->data.title.ellipsize_width, env);
4303	/* HACK: parse_x_position_unchecked adds in env->rect.x, subtract out again */
4304	ellipsize_width -= env->rect.x;
4305
4306	pango_layout_set_width (info->title_layout, -1);
4307	pango_layout_get_pixel_extents (info->title_layout,
4308	&ink_rect, &logical_rect);
4309
4310	/* Pango's idea of ellipsization is with respect to the logical rect.
4311	* correct for this, by reducing the ellipsization width by the overflow
4312	* of the un-ellipsized text on the right... it's always the visual
4313	* right we want regardless of bidi, since since the X we pass in to
4314	* cairo_move_to() is always the left edge of the line.
4315	*/
4316	right_bearing = (ink_rect.x + ink_rect.width) - (logical_rect.x + logical_rect.width);
4317	right_bearing = MAX (right_bearing, 0)(((right_bearing) > (0)) ? (right_bearing) : (0));
4318
4319	ellipsize_width -= right_bearing;
4320	ellipsize_width = MAX (ellipsize_width, 0)(((ellipsize_width) > (0)) ? (ellipsize_width) : (0));
4321
4322	/* Only ellipsizing when necessary is a performance optimization -
4323	* pango_layout_set_width() will force a relayout if it isn't the
4324	* same as the current width of -1.
4325	*/
4326	if (ellipsize_width < logical_rect.width)
4327	pango_layout_set_width (info->title_layout, PANGO_SCALE1024 * ellipsize_width);
4328	}
4329	else if (rx - env->rect.x + env->title_width >= env->rect.width)
4330	{
4331	const double alpha_margin = 30.0;
4332	int text_space = env->rect.x + env->rect.width -
4333	(rx - env->rect.x) - env->right_width;
4334
4335	double startalpha = 1.0 - (alpha_margin/((double)text_space));
4336
4337	cairo_pattern_t *linpat;
4338	linpat = cairo_pattern_create_linear (rx, ry, text_space,
4339	env->title_height);
4340	cairo_pattern_add_color_stop_rgba (linpat, 0, color.red,
4341	color.green,
4342	color.blue,
4343	color.alpha);
4344	cairo_pattern_add_color_stop_rgba (linpat, startalpha,
4345	color.red,
4346	color.green,
4347	color.blue,
4348	color.alpha);
4349	cairo_pattern_add_color_stop_rgba (linpat, 1, color.red,
4350	color.green,
4351	color.blue, 0);
4352	cairo_set_source(cr, linpat);
4353	cairo_pattern_destroy(linpat);
4354	}
4355
4356	cairo_move_to (cr, rx, ry);
4357	pango_cairo_show_layout (cr, info->title_layout);
4358
4359	/* Remove any ellipsization we might have set; will short-circuit
4360	* if the width is already -1 */
4361	pango_layout_set_width (info->title_layout, -1);
4362	}
4363	break;
4364
4365	case META_DRAW_OP_LIST:
4366	{
4367	MetaRectangle d_rect;
4368
4369	d_rect.x = parse_x_position_unchecked (op->data.op_list.x, env);
4370	d_rect.y = parse_y_position_unchecked (op->data.op_list.y, env);
4371	d_rect.width = parse_size_unchecked (op->data.op_list.width, env);
4372	d_rect.height = parse_size_unchecked (op->data.op_list.height, env);
4373
4374	meta_draw_op_list_draw_with_style (op->data.op_list.op_list,
4375	style_ctk,
4376	cr,
4377	info, d_rect);
4378	}
4379	break;
4380
4381	case META_DRAW_TILE:
4382	{
4383	int rx, ry, rwidth, rheight;
4384	int tile_xoffset, tile_yoffset;
4385	MetaRectangle tile;
4386
4387	rx = parse_x_position_unchecked (op->data.tile.x, env);
4388	ry = parse_y_position_unchecked (op->data.tile.y, env);
4389	rwidth = parse_size_unchecked (op->data.tile.width, env);
4390	rheight = parse_size_unchecked (op->data.tile.height, env);
4391
4392	cairo_save (cr);
4393
4394	cairo_rectangle (cr, rx, ry, rwidth, rheight);
4395	cairo_clip (cr);
4396
4397	tile_xoffset = parse_x_position_unchecked (op->data.tile.tile_xoffset, env);
4398	tile_yoffset = parse_y_position_unchecked (op->data.tile.tile_yoffset, env);
4399	/* tile offset should not include x/y */
4400	tile_xoffset -= rect.x;
4401	tile_yoffset -= rect.y;
4402
4403	tile.width = parse_size_unchecked (op->data.tile.tile_width, env);
4404	tile.height = parse_size_unchecked (op->data.tile.tile_height, env);
4405
4406	tile.x = rx - tile_xoffset;
4407
4408	while (tile.x < (rx + rwidth))
4409	{
4410	tile.y = ry - tile_yoffset;
4411	while (tile.y < (ry + rheight))
4412	{
4413	meta_draw_op_list_draw_with_style (op->data.tile.op_list,
4414	style_ctk, cr, info,
4415	tile);
4416
4417	tile.y += tile.height;
4418	}
4419
4420	tile.x += tile.width;
4421	}
4422	cairo_restore (cr);
4423	}
4424	break;
4425	}
4426
4427	cairo_restore (cr);
4428	ctk_style_context_restore (style_ctk);
4429	}
4430
4431	void
4432	meta_draw_op_draw_with_style (const MetaDrawOp *op,
4433	CtkStyleContext *style_ctk,
4434	cairo_t *cr,
4435	const MetaDrawInfo *info,
4436	MetaRectangle logical_region)
4437	{
4438	MetaPositionExprEnv env;
4439
4440	fill_env (&env, info, logical_region);
4441
4442	meta_draw_op_draw_with_env (op,
4443	style_ctk,
4444	cr,
4445	info, logical_region,
4446	&env);
4447
4448	}
4449
4450	void
4451	meta_draw_op_draw (const MetaDrawOp *op,
4452	CtkWidget *widget,
4453	cairo_t *cr,
4454	const MetaDrawInfo *info,
4455	MetaRectangle logical_region)
4456	{
4457	meta_draw_op_draw_with_style (op,
4458	ctk_widget_get_style_context (widget),
4459	cr,
4460	info, logical_region);
4461	}
4462
4463	MetaDrawOpList*
4464	meta_draw_op_list_new (int n_preallocs)
4465	{
4466	MetaDrawOpList *op_list;
4467
4468	g_return_val_if_fail (n_preallocs >= 0, NULL)do { if ((n_preallocs >= 0)) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "n_preallocs >= 0") ; return (((void)0)); } } while (0);
4469
4470	op_list = g_new (MetaDrawOpList, 1)((MetaDrawOpList *) g_malloc_n ((1), sizeof (MetaDrawOpList)) );
4471
4472	op_list->refcount = 1;
4473	op_list->n_allocated = n_preallocs;
4474	op_list->ops = g_new (MetaDrawOp, op_list->n_allocated)((MetaDrawOp ) g_malloc_n ((op_list->n_allocated), sizeof (MetaDrawOp)));
4475	op_list->n_ops = 0;
4476
4477	return op_list;
4478	}
4479
4480	void
4481	meta_draw_op_list_ref (MetaDrawOpList *op_list)
4482	{
4483	g_return_if_fail (op_list != NULL)do { if ((op_list != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "op_list != NULL"); return ; } } while (0);
4484
4485	op_list->refcount += 1;
4486	}
4487
4488	void
4489	meta_draw_op_list_unref (MetaDrawOpList *op_list)
4490	{
4491	g_return_if_fail (op_list != NULL)do { if ((op_list != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "op_list != NULL"); return ; } } while (0);
4492	g_return_if_fail (op_list->refcount > 0)do { if ((op_list->refcount > 0)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "op_list->refcount > 0" ); return; } } while (0);
4493
4494	op_list->refcount -= 1;
4495
4496	if (op_list->refcount == 0)
4497	{
4498	int i;
4499
4500	for (i = 0; i < op_list->n_ops; i++)
4501	meta_draw_op_free (op_list->ops[i]);
4502
4503	g_free (op_list->ops);
4504
4505	DEBUG_FILL_STRUCT (op_list)memset ((op_list), 0xef, sizeof (*(op_list)));
4506	g_free (op_list);
4507	}
4508	}
4509
4510	void
4511	meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list,
4512	CtkStyleContext *style_ctk,
4513	cairo_t *cr,
4514	const MetaDrawInfo *info,
4515	MetaRectangle rect)
4516	{
4517	/* BOOKMARK */
4518
4519	int i;
4520	MetaPositionExprEnv env;
4521
4522	if (op_list->n_ops == 0)
4523	return;
4524
4525	fill_env (&env, info, rect);
4526
4527	/* FIXME this can be optimized, potentially a lot, by
4528	* compressing multiple ops when possible. For example,
4529	* anything convertible to a pixbuf can be composited
4530	* client-side, and putting a color tint over a pixbuf
4531	* can be done without creating the solid-color pixbuf.
4532	*
4533	* To implement this my plan is to have the idea of a
4534	* compiled draw op (with the string expressions already
4535	* evaluated), we make an array of those, and then fold
4536	* adjacent items when possible.
4537	*/
4538
4539	cairo_save (cr);
4540
4541	for (i = 0; i < op_list->n_ops; i++)
4542	{
4543	MetaDrawOp *op = op_list->ops[i];
4544
4545	if (op->type == META_DRAW_CLIP)
4546	{
4547	cairo_restore (cr);
4548
4549	cairo_rectangle (cr,
4550	parse_x_position_unchecked (op->data.clip.x, &env),
4551	parse_y_position_unchecked (op->data.clip.y, &env),
4552	parse_size_unchecked (op->data.clip.width, &env),
4553	parse_size_unchecked (op->data.clip.height, &env));
4554	cairo_clip (cr);
4555
4556	cairo_save (cr);
4557	}
4558	else if (cdk_cairo_get_clip_rectangle (cr, NULL((void*)0)))
4559	{
4560	meta_draw_op_draw_with_env (op, style_ctk, cr, info, rect, &env);
4561	}
4562	}
4563
4564	cairo_restore (cr);
4565	}
4566
4567	void
4568	meta_draw_op_list_draw (const MetaDrawOpList *op_list,
4569	CtkWidget *widget,
4570	cairo_t *cr,
4571	const MetaDrawInfo *info,
4572	MetaRectangle rect)
4573
4574	{
4575	meta_draw_op_list_draw_with_style (op_list,
4576	ctk_widget_get_style_context (widget),
4577	cr,
4578	info, rect);
4579	}
4580
4581	void
4582	meta_draw_op_list_append (MetaDrawOpList *op_list,
4583	MetaDrawOp *op)
4584	{
4585	if (op_list->n_ops == op_list->n_allocated)
4586	{
4587	op_list->n_allocated *= 2;
4588	op_list->ops = g_renew (MetaDrawOp, op_list->ops, op_list->n_allocated)((MetaDrawOp ) g_realloc_n (op_list->ops, (op_list->n_allocated ), sizeof (MetaDrawOp)));
4589	}
4590
4591	op_list->ops[op_list->n_ops] = op;
4592	op_list->n_ops += 1;
4593	}
4594
4595	gboolean
4596	meta_draw_op_list_validate (MetaDrawOpList *op_list,
4597	GError **error)
4598	{
4599	g_return_val_if_fail (op_list != NULL, FALSE)do { if ((op_list != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "op_list != NULL"); return ((0)); } } while (0);
4600
4601	/* empty lists are OK, nothing else to check really */
4602
4603	return TRUE(!(0));
4604	}
4605
4606	/* This is not done in validate, since we wouldn't know the name
4607	* of the list to report the error. It might be nice to
4608	* store names inside the list sometime.
4609	*/
4610	gboolean
4611	meta_draw_op_list_contains (MetaDrawOpList *op_list,
4612	MetaDrawOpList *child)
4613	{
4614	int i;
4615
4616	/* mmm, huge tree recursion */
4617
4618	for (i = 0; i < op_list->n_ops; i++)
4619	{
4620	if (op_list->ops[i]->type == META_DRAW_OP_LIST)
4621	{
4622	if (op_list->ops[i]->data.op_list.op_list == child)
4623	return TRUE(!(0));
4624
4625	if (meta_draw_op_list_contains (op_list->ops[i]->data.op_list.op_list,
4626	child))
4627	return TRUE(!(0));
4628	}
4629	else if (op_list->ops[i]->type == META_DRAW_TILE)
4630	{
4631	if (op_list->ops[i]->data.tile.op_list == child)
4632	return TRUE(!(0));
4633
4634	if (meta_draw_op_list_contains (op_list->ops[i]->data.tile.op_list,
4635	child))
4636	return TRUE(!(0));
4637	}
4638	}
4639
4640	return FALSE(0);
4641	}
4642
4643	/**
4644	* Constructor for a MetaFrameStyle.
4645	*
4646	* \param parent The parent style. Data not filled in here will be
4647	* looked for in the parent style, and in its parent
4648	* style, and so on.
4649	*
4650	* \return The newly-constructed style.
4651	*/
4652	MetaFrameStyle*
4653	meta_frame_style_new (MetaFrameStyle *parent)
4654	{
4655	MetaFrameStyle *style;
4656
4657	style = g_new0 (MetaFrameStyle, 1)((MetaFrameStyle *) g_malloc0_n ((1), sizeof (MetaFrameStyle) ));
4658
4659	style->refcount = 1;
4660
4661	/* Default alpha is fully opaque */
4662	style->window_background_alpha = 255;
4663
4664	style->parent = parent;
4665	if (parent)
4666	meta_frame_style_ref (parent);
4667
4668	return style;
4669	}
4670
4671	/**
4672	* Increases the reference count of a frame style.
4673	* If the style is NULL, this is a no-op.
4674	*
4675	* \param style The style.
4676	*/
4677	void
4678	meta_frame_style_ref (MetaFrameStyle *style)
4679	{
4680	g_return_if_fail (style != NULL)do { if ((style != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "style != NULL"); return ; } } while (0);
4681
4682	style->refcount += 1;
4683	}
4684
4685	static void
4686	free_button_ops (MetaDrawOpList *op_lists[META_BUTTON_TYPE_LAST][META_BUTTON_STATE_LAST])
4687	{
4688	int i, j;
4689
4690	for (i = 0; i < META_BUTTON_TYPE_LAST; i++)
4691	for (j = 0; j < META_BUTTON_STATE_LAST; j++)
4692	if (op_lists[i][j])
4693	meta_draw_op_list_unref (op_lists[i][j]);
4694	}
4695
4696	void
4697	meta_frame_style_unref (MetaFrameStyle *style)
4698	{
4699	g_return_if_fail (style != NULL)do { if ((style != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "style != NULL"); return ; } } while (0);
4700	g_return_if_fail (style->refcount > 0)do { if ((style->refcount > 0)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "style->refcount > 0" ); return; } } while (0);
4701
4702	style->refcount -= 1;
4703
4704	if (style->refcount == 0)
4705	{
4706	int i;
4707
4708	free_button_ops (style->buttons);
4709
4710	for (i = 0; i < META_FRAME_PIECE_LAST; i++)
4711	if (style->pieces[i])
4712	meta_draw_op_list_unref (style->pieces[i]);
4713
4714	if (style->layout)
4715	meta_frame_layout_unref (style->layout);
4716
4717	if (style->window_background_color)
4718	meta_color_spec_free (style->window_background_color);
4719
4720	/* we hold a reference to any parent style */
4721	if (style->parent)
4722	meta_frame_style_unref (style->parent);
4723
4724	DEBUG_FILL_STRUCT (style)memset ((style), 0xef, sizeof (*(style)));
4725	g_free (style);
4726	}
4727	}
4728
4729	static MetaButtonState
4730	map_button_state (MetaButtonType button_type,
4731	const MetaFrameGeometry *fgeom,
4732	int middle_bg_offset,
4733	MetaButtonState button_states[META_BUTTON_TYPE_LAST])
4734	{
4735	MetaButtonFunction function = META_BUTTON_FUNCTION_LAST;
4736
4737	switch (button_type)
4738	{
4739	/* First handle functions, which map directly */
4740	case META_BUTTON_TYPE_SHADE:
4741	case META_BUTTON_TYPE_ABOVE:
4742	case META_BUTTON_TYPE_STICK:
4743	case META_BUTTON_TYPE_UNSHADE:
4744	case META_BUTTON_TYPE_UNABOVE:
4745	case META_BUTTON_TYPE_UNSTICK:
4746	case META_BUTTON_TYPE_MENU:
4747	case META_BUTTON_TYPE_APPMENU:
4748	case META_BUTTON_TYPE_MINIMIZE:
4749	case META_BUTTON_TYPE_MAXIMIZE:
4750	case META_BUTTON_TYPE_CLOSE:
4751	return button_states[button_type];
4752
4753	/* Map position buttons to the corresponding function */
4754	case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
4755	case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
4756	if (fgeom->n_right_buttons > 0)
4757	function = fgeom->button_layout.right_buttons[0];
4758	break;
4759	case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
4760	if (fgeom->n_right_buttons > 0)
4761	function = fgeom->button_layout.right_buttons[fgeom->n_right_buttons - 1];
4762	break;
4763	case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
4764	if (middle_bg_offset + 1 < fgeom->n_right_buttons)
4765	function = fgeom->button_layout.right_buttons[middle_bg_offset + 1];
4766	break;
4767	case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
4768	case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
4769	if (fgeom->n_left_buttons > 0)
4770	function = fgeom->button_layout.left_buttons[0];
4771	break;
4772	case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
4773	if (fgeom->n_left_buttons > 0)
4774	function = fgeom->button_layout.left_buttons[fgeom->n_left_buttons - 1];
4775	break;
4776	case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
4777	if (middle_bg_offset + 1 < fgeom->n_left_buttons)
4778	function = fgeom->button_layout.left_buttons[middle_bg_offset + 1];
4779	break;
4780	case META_BUTTON_TYPE_LAST:
4781	break;
4782	}
4783
4784	if (function != META_BUTTON_FUNCTION_LAST)
4785	return button_states[map_button_function_to_type (function)];
4786
4787	return META_BUTTON_STATE_LAST;
4788	}
4789
4790	static MetaDrawOpList*
4791	get_button (MetaFrameStyle *style,
4792	MetaButtonType type,
4793	MetaButtonState state)
4794	{
4795	MetaDrawOpList *op_list;
4796	MetaFrameStyle *parent;
4797
4798	parent = style;
4799	op_list = NULL((void*)0);
4800	while (parent && op_list == NULL((void*)0))
4801	{
4802	op_list = parent->buttons[type][state];
4803	parent = parent->parent;
4804	}
4805
4806	/* We fall back to the side buttons if we don't have
4807	* single button backgrounds, and to middle button
4808	* backgrounds if we don't have the ones on the sides
4809	*/
4810
4811	if (op_list == NULL((void*)0) &&
4812	type == META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND)
4813	return get_button (style, META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND, state);
4814
4815	if (op_list == NULL((void*)0) &&
4816	type == META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND)
4817	return get_button (style, META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND, state);
4818
4819	if (op_list == NULL((void*)0) &&
4820	(type == META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND \|\|
4821	type == META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND))
4822	return get_button (style, META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND,
4823	state);
4824
4825	if (op_list == NULL((void*)0) &&
4826	(type == META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND \|\|
4827	type == META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND))
4828	return get_button (style, META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND,
4829	state);
4830
4831	/* We fall back to normal if no prelight */
4832	if (op_list == NULL((void*)0) &&
4833	state == META_BUTTON_STATE_PRELIGHT)
4834	return get_button (style, type, META_BUTTON_STATE_NORMAL);
4835
4836	return op_list;
4837	}
4838
4839	gboolean
4840	meta_frame_style_validate (MetaFrameStyle *style,
4841	guint current_theme_version,
4842	GError **error)
4843	{
4844	int i, j;
4845
4846	g_return_val_if_fail (style != NULL, FALSE)do { if ((style != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "style != NULL"); return ((0)); } } while (0);
4847	g_return_val_if_fail (style->layout != NULL, FALSE)do { if ((style->layout != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "style->layout != NULL" ); return ((0)); } } while (0);
4848
4849	for (i = 0; i < META_BUTTON_TYPE_LAST; i++)
4850	{
4851	/* for now the "positional" buttons are optional */
4852	if (i >= META_BUTTON_TYPE_CLOSE)
4853	{
4854	for (j = 0; j < META_BUTTON_STATE_LAST; j++)
4855	{
4856	if (get_button (style, i, j) == NULL((void*)0) &&
4857	meta_theme_earliest_version_with_button (i) <= current_theme_version
4858	)
4859	{
4860	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
4861	META_THEME_ERROR_FAILED,
4862	_("<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be specified for this frame style")dgettext ("croma", "<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be specified for this frame style" ),
4863	meta_button_type_to_string (i),
4864	meta_button_state_to_string (j));
4865	return FALSE(0);
4866	}
4867	}
4868	}
4869	}
4870
4871	return TRUE(!(0));
4872	}
4873
4874	static void
4875	get_button_rect (MetaButtonType type,
4876	const MetaFrameGeometry *fgeom,
4877	int middle_background_offset,
4878	CdkRectangle *rect)
4879	{
4880	switch (type)
4881	{
4882	case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
4883	*rect = fgeom->left_left_background;
4884	break;
4885
4886	case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
4887	*rect = fgeom->left_middle_backgrounds[middle_background_offset];
4888	break;
4889
4890	case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
4891	*rect = fgeom->left_right_background;
4892	break;
4893
4894	case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
4895	*rect = fgeom->left_single_background;
4896	break;
4897
4898	case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
4899	*rect = fgeom->right_left_background;
4900	break;
4901
4902	case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
4903	*rect = fgeom->right_middle_backgrounds[middle_background_offset];
4904	break;
4905
4906	case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
4907	*rect = fgeom->right_right_background;
4908	break;
4909
4910	case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
4911	*rect = fgeom->right_single_background;
4912	break;
4913
4914	case META_BUTTON_TYPE_CLOSE:
4915	*rect = fgeom->close_rect.visible;
4916	break;
4917
4918	case META_BUTTON_TYPE_SHADE:
4919	*rect = fgeom->shade_rect.visible;
4920	break;
4921
4922	case META_BUTTON_TYPE_UNSHADE:
4923	*rect = fgeom->unshade_rect.visible;
4924	break;
4925
4926	case META_BUTTON_TYPE_ABOVE:
4927	*rect = fgeom->above_rect.visible;
4928	break;
4929
4930	case META_BUTTON_TYPE_UNABOVE:
4931	*rect = fgeom->unabove_rect.visible;
4932	break;
4933
4934	case META_BUTTON_TYPE_STICK:
4935	*rect = fgeom->stick_rect.visible;
4936	break;
4937
4938	case META_BUTTON_TYPE_UNSTICK:
4939	*rect = fgeom->unstick_rect.visible;
4940	break;
4941
4942	case META_BUTTON_TYPE_MAXIMIZE:
4943	*rect = fgeom->max_rect.visible;
4944	break;
4945
4946	case META_BUTTON_TYPE_MINIMIZE:
4947	*rect = fgeom->min_rect.visible;
4948	break;
4949
4950	case META_BUTTON_TYPE_MENU:
4951	*rect = fgeom->menu_rect.visible;
4952	break;
4953
4954	case META_BUTTON_TYPE_APPMENU:
4955	*rect = fgeom->appmenu_rect.visible;
4956	break;
4957
4958	case META_BUTTON_TYPE_LAST:
4959	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 4959, ( (const char) (__func__)), ((void)0)); } while (0);
4960	break;
4961	}
4962	}
4963
4964	void
4965	meta_frame_style_draw_with_style (MetaFrameStyle *style,
4966	CtkStyleContext *style_ctk,
4967	cairo_t *cr,
4968	const MetaFrameGeometry *fgeom,
4969	int client_width,
4970	int client_height,
4971	PangoLayout *title_layout,
4972	int text_height,
4973	MetaButtonState button_states[META_BUTTON_TYPE_LAST],
4974	GdkPixbuf *mini_icon,
4975	GdkPixbuf *icon)
4976	{
4977	/* BOOKMARK */
4978	int i, j;
4979	CdkRectangle visible_rect;
4980	CdkRectangle titlebar_rect;
4981	CdkRectangle left_titlebar_edge;
4982	CdkRectangle right_titlebar_edge;
4983	CdkRectangle bottom_titlebar_edge;
4984	CdkRectangle top_titlebar_edge;
4985	CdkRectangle left_edge, right_edge, bottom_edge;
4986	PangoRectangle extents;
4987	MetaDrawInfo draw_info;
4988	const MetaFrameBorders *borders;
4989
4990	borders = &fgeom->borders;
4991
4992	visible_rect.x = borders->invisible.left;
4993	visible_rect.y = borders->invisible.top;
4994	visible_rect.width = fgeom->width - borders->invisible.left - borders->invisible.right;
4995	visible_rect.height = fgeom->height - borders->invisible.top - borders->invisible.bottom;
4996
4997	titlebar_rect.x = visible_rect.x;
4998	titlebar_rect.y = visible_rect.y;
4999	titlebar_rect.width = visible_rect.width;
5000	titlebar_rect.height = borders->visible.top;
5001
5002	left_titlebar_edge.x = titlebar_rect.x;
5003	left_titlebar_edge.y = titlebar_rect.y + fgeom->top_titlebar_edge;
5004	left_titlebar_edge.width = fgeom->left_titlebar_edge;
5005	left_titlebar_edge.height = titlebar_rect.height - fgeom->top_titlebar_edge - fgeom->bottom_titlebar_edge;
5006
5007	right_titlebar_edge.y = left_titlebar_edge.y;
5008	right_titlebar_edge.height = left_titlebar_edge.height;
5009	right_titlebar_edge.width = fgeom->right_titlebar_edge;
5010	right_titlebar_edge.x = titlebar_rect.x + titlebar_rect.width - right_titlebar_edge.width;
5011
5012	top_titlebar_edge.x = titlebar_rect.x;
5013	top_titlebar_edge.y = titlebar_rect.y;
5014	top_titlebar_edge.width = titlebar_rect.width;
5015	top_titlebar_edge.height = fgeom->top_titlebar_edge;
5016
5017	bottom_titlebar_edge.x = titlebar_rect.x;
5018	bottom_titlebar_edge.width = titlebar_rect.width;
5019	bottom_titlebar_edge.height = fgeom->bottom_titlebar_edge;
5020	bottom_titlebar_edge.y = titlebar_rect.y + titlebar_rect.height - bottom_titlebar_edge.height;
5021
5022	left_edge.x = visible_rect.x;
5023	left_edge.y = visible_rect.y + borders->visible.top;
5024	left_edge.width = borders->visible.left;
5025	left_edge.height = visible_rect.height - borders->visible.top - borders->visible.bottom;
5026
5027	right_edge.x = visible_rect.x + visible_rect.width - borders->visible.right;
5028	right_edge.y = visible_rect.y + borders->visible.top;
5029	right_edge.width = borders->visible.right;
5030	right_edge.height = visible_rect.height - borders->visible.top - borders->visible.bottom;
5031
5032	bottom_edge.x = visible_rect.x;
5033	bottom_edge.y = visible_rect.y + visible_rect.height - borders->visible.bottom;
5034	bottom_edge.width = visible_rect.width;
5035	bottom_edge.height = borders->visible.bottom;
5036
5037	if (title_layout)
5038	pango_layout_get_pixel_extents (title_layout,
5039	NULL((void*)0), &extents);
5040
5041	draw_info.mini_icon = mini_icon;
5042	draw_info.icon = icon;
5043	draw_info.title_layout = title_layout;
5044	draw_info.title_layout_width = title_layout ? extents.width : 0;
5045	draw_info.title_layout_height = title_layout ? extents.height : 0;
5046	draw_info.fgeom = fgeom;
5047
5048	/* The enum is in the order the pieces should be rendered. */
5049	i = 0;
5050	while (i < META_FRAME_PIECE_LAST)
5051	{
5052	CdkRectangle rect;
5053
5054	switch ((MetaFramePiece) i)
5055	{
5056	case META_FRAME_PIECE_ENTIRE_BACKGROUND:
5057	rect = visible_rect;
5058	break;
5059
5060	case META_FRAME_PIECE_TITLEBAR:
5061	rect = titlebar_rect;
5062	break;
5063
5064	case META_FRAME_PIECE_LEFT_TITLEBAR_EDGE:
5065	rect = left_titlebar_edge;
5066	break;
5067
5068	case META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE:
5069	rect = right_titlebar_edge;
5070	break;
5071
5072	case META_FRAME_PIECE_TOP_TITLEBAR_EDGE:
5073	rect = top_titlebar_edge;
5074	break;
5075
5076	case META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE:
5077	rect = bottom_titlebar_edge;
5078	break;
5079
5080	case META_FRAME_PIECE_TITLEBAR_MIDDLE:
5081	rect.x = left_titlebar_edge.x + left_titlebar_edge.width;
5082	rect.y = top_titlebar_edge.y + top_titlebar_edge.height;
5083	rect.width = titlebar_rect.width - left_titlebar_edge.width -
5084	right_titlebar_edge.width;
5085	rect.height = titlebar_rect.height - top_titlebar_edge.height - bottom_titlebar_edge.height;
5086	break;
5087
5088	case META_FRAME_PIECE_TITLE:
5089	rect = fgeom->title_rect;
5090	break;
5091
5092	case META_FRAME_PIECE_LEFT_EDGE:
5093	rect = left_edge;
5094	break;
5095
5096	case META_FRAME_PIECE_RIGHT_EDGE:
5097	rect = right_edge;
5098	break;
5099
5100	case META_FRAME_PIECE_BOTTOM_EDGE:
5101	rect = bottom_edge;
5102	break;
5103
5104	case META_FRAME_PIECE_OVERLAY:
5105	rect = visible_rect;
5106	break;
5107
5108	case META_FRAME_PIECE_LAST:
5109	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5109, ( (const char) (__func__)), ((void)0)); } while (0);
5110	break;
5111	}
5112
5113	cairo_save (cr);
5114
5115	cdk_cairo_rectangle (cr, &rect);
5116	cairo_clip (cr);
5117
5118	if (cdk_cairo_get_clip_rectangle (cr, NULL((void*)0)))
5119	{
5120	MetaDrawOpList *op_list;
5121	MetaFrameStyle *parent;
5122
5123	parent = style;
5124	op_list = NULL((void*)0);
5125	while (parent && op_list == NULL((void*)0))
5126	{
5127	op_list = parent->pieces[i];
5128	parent = parent->parent;
5129	}
5130
5131	if (op_list)
5132	{
5133	MetaRectangle m_rect;
5134	m_rect = meta_rect (rect.x, rect.y, rect.width, rect.height);
5135	meta_draw_op_list_draw_with_style (op_list,
5136	style_ctk,
5137	cr,
5138	&draw_info,
5139	m_rect);
5140	}
5141	}
5142
5143	cairo_restore (cr);
5144
5145	/* Draw buttons just before overlay */
5146	if ((i + 1) == META_FRAME_PIECE_OVERLAY)
5147	{
5148	int middle_bg_offset;
5149
5150	middle_bg_offset = 0;
5151	j = 0;
5152	while (j < META_BUTTON_TYPE_LAST)
5153	{
5154	MetaDrawOpList *op_list;
5155	MetaButtonState button_state;
5156
5157	get_button_rect (j, fgeom, middle_bg_offset, &rect);
5158
5159	button_state = map_button_state (j, fgeom, middle_bg_offset, button_states);
5160	op_list = get_button (style, j, button_state);
5161
5162	if (op_list)
5163	{
5164	cairo_save (cr);
5165	cdk_cairo_rectangle (cr, &rect);
5166	cairo_clip (cr);
5167
5168	if (cdk_cairo_get_clip_rectangle (cr, NULL((void*)0)))
5169	{
5170	MetaRectangle m_rect;
5171
5172	m_rect = meta_rect (rect.x, rect.y,
5173	rect.width, rect.height);
5174
5175	meta_draw_op_list_draw_with_style (op_list,
5176	style_ctk,
5177	cr,
5178	&draw_info,
5179	m_rect);
5180	}
5181
5182	cairo_restore (cr);
5183	}
5184
5185	/* MIDDLE_BACKGROUND type may get drawn more than once */
5186	if ((j == META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND \|\|
5187	j == META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND) &&
5188	middle_bg_offset < MAX_MIDDLE_BACKGROUNDS(META_BUTTON_FUNCTION_LAST - 2))
5189	{
5190	++middle_bg_offset;
5191	}
5192	else
5193	{
5194	middle_bg_offset = 0;
5195	++j;
5196	}
5197	}
5198	}
5199
5200	++i;
5201	}
5202	}
5203
5204	void
5205	meta_frame_style_draw (MetaFrameStyle *style,
5206	CtkWidget *widget,
5207	cairo_t *cr,
5208	const MetaFrameGeometry *fgeom,
5209	int client_width,
5210	int client_height,
5211	PangoLayout *title_layout,
5212	int text_height,
5213	MetaButtonState button_states[META_BUTTON_TYPE_LAST],
5214	GdkPixbuf *mini_icon,
5215	GdkPixbuf *icon)
5216	{
5217	meta_frame_style_draw_with_style (style,
5218	ctk_widget_get_style_context (widget),
5219	cr,
5220	fgeom, client_width, client_height,
5221	title_layout, text_height,
5222	button_states, mini_icon, icon);
5223	}
5224
5225	MetaFrameStyleSet*
5226	meta_frame_style_set_new (MetaFrameStyleSet *parent)
5227	{
5228	MetaFrameStyleSet *style_set;
5229
5230	style_set = g_new0 (MetaFrameStyleSet, 1)((MetaFrameStyleSet *) g_malloc0_n ((1), sizeof (MetaFrameStyleSet )));
5231
5232	style_set->parent = parent;
5233	if (parent)
5234	meta_frame_style_set_ref (parent);
5235
5236	style_set->refcount = 1;
5237
5238	return style_set;
5239	}
5240
5241	static void
5242	free_focus_styles (MetaFrameStyle *focus_styles[META_FRAME_FOCUS_LAST])
5243	{
5244	int i;
5245
5246	for (i = 0; i < META_FRAME_FOCUS_LAST; i++)
5247	if (focus_styles[i])
5248	meta_frame_style_unref (focus_styles[i]);
5249	}
5250
5251	void
5252	meta_frame_style_set_ref (MetaFrameStyleSet *style_set)
5253	{
5254	g_return_if_fail (style_set != NULL)do { if ((style_set != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "style_set != NULL"); return ; } } while (0);
5255
5256	style_set->refcount += 1;
5257	}
5258
5259	void
5260	meta_frame_style_set_unref (MetaFrameStyleSet *style_set)
5261	{
5262	g_return_if_fail (style_set != NULL)do { if ((style_set != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "style_set != NULL"); return ; } } while (0);
5263	g_return_if_fail (style_set->refcount > 0)do { if ((style_set->refcount > 0)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "style_set->refcount > 0" ); return; } } while (0);
5264
5265	style_set->refcount -= 1;
5266
5267	if (style_set->refcount == 0)
5268	{
5269	int i;
5270
5271	for (i = 0; i < META_FRAME_RESIZE_LAST; i++)
5272	{
5273	free_focus_styles (style_set->normal_styles[i]);
5274	free_focus_styles (style_set->shaded_styles[i]);
5275	}
5276
5277	free_focus_styles (style_set->maximized_styles);
5278	free_focus_styles (style_set->tiled_left_styles);
5279	free_focus_styles (style_set->tiled_right_styles);
5280	free_focus_styles (style_set->maximized_and_shaded_styles);
5281	free_focus_styles (style_set->tiled_left_and_shaded_styles);
5282	free_focus_styles (style_set->tiled_right_and_shaded_styles);
5283
5284	if (style_set->parent)
5285	meta_frame_style_set_unref (style_set->parent);
5286
5287	DEBUG_FILL_STRUCT (style_set)memset ((style_set), 0xef, sizeof (*(style_set)));
5288	g_free (style_set);
5289	}
5290	}
5291
5292
5293	static MetaFrameStyle*
5294	get_style (MetaFrameStyleSet *style_set,
5295	MetaFrameState state,
5296	MetaFrameResize resize,
5297	MetaFrameFocus focus)
5298	{
5299	MetaFrameStyle *style;
5300
5301	style = NULL((void*)0);
5302
5303	switch (state)
5304	{
5305	case META_FRAME_STATE_NORMAL:
5306	case META_FRAME_STATE_SHADED:
5307	{
5308	if (state == META_FRAME_STATE_SHADED)
5309	style = style_set->shaded_styles[resize][focus];
5310	else
5311	style = style_set->normal_styles[resize][focus];
5312
5313	/* Try parent if we failed here */
5314	if (style == NULL((void*)0) && style_set->parent)
5315	style = get_style (style_set->parent, state, resize, focus);
5316
5317	/* Allow people to omit the vert/horz/none resize modes */
5318	if (style == NULL((void*)0) &&
5319	resize != META_FRAME_RESIZE_BOTH)
5320	style = get_style (style_set, state, META_FRAME_RESIZE_BOTH, focus);
5321	}
5322	break;
5323	default:
5324	{
5325	MetaFrameStyle **styles;
5326
5327	styles = NULL((void*)0);
5328
5329	switch (state)
5330	{
5331	case META_FRAME_STATE_MAXIMIZED:
5332	styles = style_set->maximized_styles;
5333	break;
5334	case META_FRAME_STATE_TILED_LEFT:
5335	styles = style_set->tiled_left_styles;
5336	break;
5337	case META_FRAME_STATE_TILED_RIGHT:
5338	styles = style_set->tiled_right_styles;
5339	break;
5340	case META_FRAME_STATE_MAXIMIZED_AND_SHADED:
5341	styles = style_set->maximized_and_shaded_styles;
5342	break;
5343	case META_FRAME_STATE_TILED_LEFT_AND_SHADED:
5344	styles = style_set->tiled_left_and_shaded_styles;
5345	break;
5346	case META_FRAME_STATE_TILED_RIGHT_AND_SHADED:
5347	styles = style_set->tiled_right_and_shaded_styles;
5348	break;
5349	case META_FRAME_STATE_NORMAL:
5350	case META_FRAME_STATE_SHADED:
5351	case META_FRAME_STATE_LAST:
5352	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5352, ( (const char) (__func__)), ((void)0)); } while (0);
5353	break;
5354	}
5355
5356	style = styles[focus];
5357
5358	/* Tiled states are optional, try falling back to non-tiled states */
5359	if (style == NULL((void*)0))
5360	{
5361	if (state == META_FRAME_STATE_TILED_LEFT \|\|
5362	state == META_FRAME_STATE_TILED_RIGHT)
5363	style = get_style (style_set, META_FRAME_STATE_NORMAL,
5364	resize, focus);
5365	else if (state == META_FRAME_STATE_TILED_LEFT_AND_SHADED \|\|
5366	state == META_FRAME_STATE_TILED_RIGHT_AND_SHADED)
5367	style = get_style (style_set, META_FRAME_STATE_SHADED,
5368	resize, focus);
5369	}
5370
5371	/* Try parent if we failed here */
5372	if (style == NULL((void*)0) && style_set->parent)
5373	style = get_style (style_set->parent, state, resize, focus);
5374	}
5375	}
5376
5377	return style;
5378	}
5379
5380	static gboolean
5381	check_state (MetaFrameStyleSet *style_set,
5382	MetaFrameState state,
5383	GError **error)
5384	{
5385	int i;
5386
5387	for (i = 0; i < META_FRAME_FOCUS_LAST; i++)
5388	{
5389	if (get_style (style_set, state,
5390	META_FRAME_RESIZE_NONE, i) == NULL((void*)0))
5391	{
5392	/* Translators: This error occurs when a <frame> tag is missing
5393	* in theme XML. The "<frame ...>" is intended as a noun phrase,
5394	* and the "missing" qualifies it. You should translate "whatever".
5395	*/
5396	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
5397	META_THEME_ERROR_FAILED,
5398	_("Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>")dgettext ("croma", "Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>" ),
5399	meta_frame_state_to_string (state),
5400	meta_frame_resize_to_string (META_FRAME_RESIZE_NONE),
5401	meta_frame_focus_to_string (i));
5402	return FALSE(0);
5403	}
5404	}
5405
5406	return TRUE(!(0));
5407	}
5408
5409	gboolean
5410	meta_frame_style_set_validate (MetaFrameStyleSet *style_set,
5411	GError **error)
5412	{
5413	int i, j;
5414
5415	g_return_val_if_fail (style_set != NULL, FALSE)do { if ((style_set != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "style_set != NULL"); return ((0)); } } while (0);
5416
5417	for (i = 0; i < META_FRAME_RESIZE_LAST; i++)
5418	for (j = 0; j < META_FRAME_FOCUS_LAST; j++)
5419	if (get_style (style_set, META_FRAME_STATE_NORMAL, i, j) == NULL((void*)0))
5420	{
5421	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
5422	META_THEME_ERROR_FAILED,
5423	_("Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>")dgettext ("croma", "Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>" ),
5424	meta_frame_state_to_string (META_FRAME_STATE_NORMAL),
5425	meta_frame_resize_to_string (i),
5426	meta_frame_focus_to_string (j));
5427	return FALSE(0);
5428	}
5429
5430	if (!check_state (style_set, META_FRAME_STATE_SHADED, error))
5431	return FALSE(0);
5432
5433	if (!check_state (style_set, META_FRAME_STATE_MAXIMIZED, error))
5434	return FALSE(0);
5435
5436	if (!check_state (style_set, META_FRAME_STATE_MAXIMIZED_AND_SHADED, error))
5437	return FALSE(0);
5438
5439	return TRUE(!(0));
5440	}
5441
5442	MetaTheme*
5443	meta_theme_get_current (void)
5444	{
5445	return meta_current_theme;
5446	}
5447
5448	void
5449	meta_theme_set_current (const char *name,
5450	gboolean force_reload)
5451	{
5452	MetaTheme *new_theme;
5453	GError *err;
5454
5455	meta_topicmeta_topic_real (META_DEBUG_THEMES, "Setting current theme to \"%s\"\n", name);
5456
5457	if (!force_reload &&
5458	meta_current_theme &&
5459	strcmp (name, meta_current_theme->name) == 0)
5460	return;
5461
5462	err = NULL((void*)0);
5463	new_theme = meta_theme_load (name, &err);
5464
5465	if (new_theme == NULL((void*)0))
5466	{
5467	meta_warning (_("Failed to load theme \"%s\": %s\n")dgettext ("croma", "Failed to load theme \"%s\": %s\n"),
5468	name, err->message);
5469	g_error_free (err);
5470	}
5471	else
5472	{
5473	if (meta_current_theme)
5474	meta_theme_free (meta_current_theme);
5475
5476	meta_current_theme = new_theme;
5477
5478	meta_topicmeta_topic_real (META_DEBUG_THEMES, "New theme is \"%s\"\n", meta_current_theme->name);
5479	}
5480	}
5481
5482	MetaTheme*
5483	meta_theme_new (void)
5484	{
5485	MetaTheme *theme;
5486
5487	theme = g_new0 (MetaTheme, 1)((MetaTheme *) g_malloc0_n ((1), sizeof (MetaTheme)));
5488
5489	theme->images_by_filename =
5490	g_hash_table_new_full (g_str_hash,
5491	g_str_equal,
5492	g_free,
5493	g_object_unref);
5494
5495	theme->layouts_by_name =
5496	g_hash_table_new_full (g_str_hash,
5497	g_str_equal,
5498	g_free,
5499	(GDestroyNotify) meta_frame_layout_unref);
5500
5501	theme->draw_op_lists_by_name =
5502	g_hash_table_new_full (g_str_hash,
5503	g_str_equal,
5504	g_free,
5505	(GDestroyNotify) meta_draw_op_list_unref);
5506
5507	theme->styles_by_name =
5508	g_hash_table_new_full (g_str_hash,
5509	g_str_equal,
5510	g_free,
5511	(GDestroyNotify) meta_frame_style_unref);
5512
5513	theme->style_sets_by_name =
5514	g_hash_table_new_full (g_str_hash,
5515	g_str_equal,
5516	g_free,
5517	(GDestroyNotify) meta_frame_style_set_unref);
5518
5519	/* Create our variable quarks so we can look up variables without
5520	having to strcmp for the names */
5521	theme->quark_width = g_quark_from_static_string ("width");
5522	theme->quark_height = g_quark_from_static_string ("height");
5523	theme->quark_object_width = g_quark_from_static_string ("object_width");
5524	theme->quark_object_height = g_quark_from_static_string ("object_height");
5525	theme->quark_left_width = g_quark_from_static_string ("left_width");
5526	theme->quark_right_width = g_quark_from_static_string ("right_width");
5527	theme->quark_top_height = g_quark_from_static_string ("top_height");
5528	theme->quark_bottom_height = g_quark_from_static_string ("bottom_height");
5529	theme->quark_mini_icon_width = g_quark_from_static_string ("mini_icon_width");
5530	theme->quark_mini_icon_height = g_quark_from_static_string ("mini_icon_height");
5531	theme->quark_icon_width = g_quark_from_static_string ("icon_width");
5532	theme->quark_icon_height = g_quark_from_static_string ("icon_height");
5533	theme->quark_title_width = g_quark_from_static_string ("title_width");
5534	theme->quark_title_height = g_quark_from_static_string ("title_height");
5535	theme->quark_frame_x_center = g_quark_from_static_string ("frame_x_center");
5536	theme->quark_frame_y_center = g_quark_from_static_string ("frame_y_center");
5537	return theme;
5538	}
5539
5540
5541	void
5542	meta_theme_free (MetaTheme *theme)
5543	{
5544	int i;
5545
5546	g_return_if_fail (theme != NULL)do { if ((theme != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "theme != NULL"); return ; } } while (0);
5547
5548	g_free (theme->name);
5549	g_free (theme->dirname);
5550	g_free (theme->filename);
5551	g_free (theme->readable_name);
5552	g_free (theme->date);
5553	g_free (theme->description);
5554	g_free (theme->author);
5555	g_free (theme->copyright);
5556
5557	/* be more careful when destroying the theme hash tables,
5558	since they are only constructed as needed, and may be NULL. */
5559	if (theme->integer_constants)
5560	g_hash_table_destroy (theme->integer_constants);
5561	if (theme->images_by_filename)
5562	g_hash_table_destroy (theme->images_by_filename);
5563	if (theme->layouts_by_name)
5564	g_hash_table_destroy (theme->layouts_by_name);
5565	if (theme->draw_op_lists_by_name)
5566	g_hash_table_destroy (theme->draw_op_lists_by_name);
5567	if (theme->styles_by_name)
5568	g_hash_table_destroy (theme->styles_by_name);
5569	if (theme->style_sets_by_name)
5570	g_hash_table_destroy (theme->style_sets_by_name);
5571
5572	for (i = 0; i < META_FRAME_TYPE_LAST; i++)
5573	if (theme->style_sets_by_type[i])
5574	meta_frame_style_set_unref (theme->style_sets_by_type[i]);
5575
5576	DEBUG_FILL_STRUCT (theme)memset ((theme), 0xef, sizeof (*(theme)));
5577	g_free (theme);
5578	}
5579
5580	gboolean
5581	meta_theme_validate (MetaTheme *theme,
5582	GError **error)
5583	{
5584	int i;
5585
5586	g_return_val_if_fail (theme != NULL, FALSE)do { if ((theme != ((void)0))) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "theme != NULL"); return ((0)); } } while (0);
5587
5588	/* FIXME what else should be checked? */
5589
5590	g_assert (theme->name)do { if (theme->name) ; else g_assertion_message_expr ("croma" , "ui/theme.c", 5590, ((const char*) (__func__)), "theme->name" ); } while (0);
5591
5592	if (theme->readable_name == NULL((void*)0))
5593	{
5594	/* Translators: This error means that a necessary XML tag (whose name
5595	* is given in angle brackets) was not found in a given theme (whose
5596	* name is given second, in quotation marks).
5597	*/
5598	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
5599	_("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "name", theme->name);
5600	return FALSE(0);
5601	}
5602
5603	if (theme->author == NULL((void*)0))
5604	{
5605	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
5606	_("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "author", theme->name);
5607	return FALSE(0);
5608	}
5609
5610	if (theme->date == NULL((void*)0))
5611	{
5612	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
5613	_("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "date", theme->name);
5614	return FALSE(0);
5615	}
5616
5617	if (theme->description == NULL((void*)0))
5618	{
5619	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
5620	_("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "description", theme->name);
5621	return FALSE(0);
5622	}
5623
5624	if (theme->copyright == NULL((void*)0))
5625	{
5626	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
5627	_("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "copyright", theme->name);
5628	return FALSE(0);
5629	}
5630
5631	for (i = 0; i < (int)META_FRAME_TYPE_LAST; i++)
5632	if (i != (int)META_FRAME_TYPE_ATTACHED && theme->style_sets_by_type[i] == NULL((void*)0))
5633	{
5634	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
5635	_("No frame style set for window type \"%s\" in theme \"%s\", add a <window type=\"%s\" style_set=\"whatever\"/> element")dgettext ("croma", "No frame style set for window type \"%s\" in theme \"%s\", add a <window type=\"%s\" style_set=\"whatever\"/> element" ),
5636	meta_frame_type_to_string (i),
5637	theme->name,
5638	meta_frame_type_to_string (i));
5639
5640	return FALSE(0);
5641	}
5642
5643	return TRUE(!(0));
5644	}
5645
5646	GdkPixbuf*
5647	meta_theme_load_image (MetaTheme *theme,
5648	const char *filename,
5649	guint size_of_theme_icons,
5650	GError **error)
5651	{
5652	GdkPixbuf *pixbuf;
5653	int scale;
5654
5655	pixbuf = g_hash_table_lookup (theme->images_by_filename,
5656	filename);
5657
5658	scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());
5659
5660	if (pixbuf == NULL((void*)0))
5661	{
5662
5663	if (g_str_has_prefix (filename, "theme:") &&
5664	META_THEME_ALLOWS (theme, META_THEME_IMAGES_FROM_ICON_THEMES)(theme->format_version >= 2))
5665	{
5666	pixbuf = ctk_icon_theme_load_icon_for_scale (
5667	ctk_icon_theme_get_default (),
5668	filename+6,
5669	size_of_theme_icons,
5670	scale,
5671	0,
5672	error);
5673	if (pixbuf == NULL((void)0)) return NULL((void)0);
5674	}
5675	else
5676	{
5677	char *full_path;
5678	full_path = g_build_filename (theme->dirname, filename, NULL((void*)0));
5679
5680	gint width, height;
5681
5682	if (gdk_pixbuf_get_file_info (full_path, &width, &height) == NULL((void*)0))
5683	{
5684	g_free (full_path);
5685	return NULL((void*)0);
5686	}
5687
5688	width *= scale;
5689	height *= scale;
5690
5691	pixbuf = gdk_pixbuf_new_from_file_at_size (full_path, width, height, error);
5692
5693	if (pixbuf == NULL((void*)0))
5694	{
5695	g_free (full_path);
5696	return NULL((void*)0);
5697	}
5698
5699	g_free (full_path);
5700	}
5701	g_hash_table_replace (theme->images_by_filename,
5702	g_strdup (filename),
5703	pixbuf);
5704	}
5705
5706	g_assert (pixbuf)do { if (pixbuf) ; else g_assertion_message_expr ("croma", "ui/theme.c" , 5706, ((const char*) (__func__)), "pixbuf"); } while (0);
5707
5708	g_object_ref (G_OBJECT (pixbuf))((__typeof__ (((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance) ((pixbuf)), (((GType) ((20) << (2))) ))))))) (g_object_ref) (((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance) ((pixbuf)), (((GType) ((20) << (2))) )))))));
5709
5710	return pixbuf;
5711	}
5712
5713	static MetaFrameStyle*
5714	theme_get_style (MetaTheme *theme,
5715	MetaFrameType type,
5716	MetaFrameFlags flags)
5717	{
5718	MetaFrameState state;
5719	MetaFrameResize resize;
5720	MetaFrameFocus focus;
5721	MetaFrameStyle *style;
5722	MetaFrameStyleSet *style_set;
5723
5724	style_set = theme->style_sets_by_type[type];
5725
5726	if (style_set == NULL((void*)0) && type == META_FRAME_TYPE_ATTACHED)
5727	style_set = theme->style_sets_by_type[META_FRAME_TYPE_BORDER];
5728
5729	/* Right now the parser forces a style set for all other types,
5730	* but this fallback code is here in case I take that out.
5731	*/
5732	if (style_set == NULL((void*)0))
5733	style_set = theme->style_sets_by_type[META_FRAME_TYPE_NORMAL];
5734	if (style_set == NULL((void*)0))
5735	return NULL((void*)0);
5736
5737	switch (flags & (META_FRAME_MAXIMIZED \| META_FRAME_SHADED \| META_FRAME_TILED_LEFT \| META_FRAME_TILED_RIGHT))
5738	{
5739	case 0:
5740	state = META_FRAME_STATE_NORMAL;
5741	break;
5742	case META_FRAME_MAXIMIZED:
5743	state = META_FRAME_STATE_MAXIMIZED;
5744	break;
5745	case META_FRAME_TILED_LEFT:
5746	case (META_FRAME_MAXIMIZED \| META_FRAME_TILED_LEFT):
5747	state = META_FRAME_STATE_TILED_LEFT;
5748	break;
5749	case META_FRAME_TILED_RIGHT:
5750	case (META_FRAME_MAXIMIZED \| META_FRAME_TILED_RIGHT):
5751	state = META_FRAME_STATE_TILED_RIGHT;
5752	break;
5753	case META_FRAME_SHADED:
5754	state = META_FRAME_STATE_SHADED;
5755	break;
5756	case (META_FRAME_MAXIMIZED \| META_FRAME_SHADED):
5757	state = META_FRAME_STATE_MAXIMIZED_AND_SHADED;
5758	break;
5759	case (META_FRAME_TILED_LEFT \| META_FRAME_SHADED):
5760	state = META_FRAME_STATE_TILED_LEFT_AND_SHADED;
5761	break;
5762	case (META_FRAME_TILED_RIGHT \| META_FRAME_SHADED):
5763	state = META_FRAME_STATE_TILED_RIGHT_AND_SHADED;
5764	break;
5765	default:
5766	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5766, ( (const char) (__func__)), ((void)0)); } while (0);
5767	state = META_FRAME_STATE_LAST; /* compiler */
5768	break;
5769	}
5770
5771	switch (flags & (META_FRAME_ALLOWS_VERTICAL_RESIZE \| META_FRAME_ALLOWS_HORIZONTAL_RESIZE))
5772	{
5773	case 0:
5774	resize = META_FRAME_RESIZE_NONE;
5775	break;
5776	case META_FRAME_ALLOWS_VERTICAL_RESIZE:
5777	resize = META_FRAME_RESIZE_VERTICAL;
5778	break;
5779	case META_FRAME_ALLOWS_HORIZONTAL_RESIZE:
5780	resize = META_FRAME_RESIZE_HORIZONTAL;
5781	break;
5782	case (META_FRAME_ALLOWS_VERTICAL_RESIZE \| META_FRAME_ALLOWS_HORIZONTAL_RESIZE):
5783	resize = META_FRAME_RESIZE_BOTH;
5784	break;
5785	default:
5786	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5786, ( (const char) (__func__)), ((void)0)); } while (0);
5787	resize = META_FRAME_RESIZE_LAST; /* compiler */
5788	break;
5789	}
5790
5791	/* re invert the styles used for focus/unfocussed while flashing a frame */
5792	if (((flags & META_FRAME_HAS_FOCUS) && !(flags & META_FRAME_IS_FLASHING))
5793	\|\| (!(flags & META_FRAME_HAS_FOCUS) && (flags & META_FRAME_IS_FLASHING)))
5794	focus = META_FRAME_FOCUS_YES;
5795	else
5796	focus = META_FRAME_FOCUS_NO;
5797
5798	style = get_style (style_set, state, resize, focus);
5799
5800	return style;
5801	}
5802
5803	MetaFrameStyle*
5804	meta_theme_get_frame_style (MetaTheme *theme,
5805	MetaFrameType type,
5806	MetaFrameFlags flags)
5807	{
5808	MetaFrameStyle *style;
5809
5810	g_return_val_if_fail (type < META_FRAME_TYPE_LAST, NULL)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning ("croma", ((const char) (__func__)), "type < META_FRAME_TYPE_LAST" ); return (((void)0)); } } while (0);
5811
5812	style = theme_get_style (theme, type, flags);
5813
5814	return style;
5815	}
5816
5817	double
5818	meta_theme_get_title_scale (MetaTheme *theme,
5819	MetaFrameType type,
5820	MetaFrameFlags flags)
5821	{
5822	MetaFrameStyle *style;
5823
5824	g_return_val_if_fail (type < META_FRAME_TYPE_LAST, 1.0)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST" ); return (1.0); } } while (0);
5825
5826	style = theme_get_style (theme, type, flags);
5827
5828	/* Parser is not supposed to allow this currently */
5829	if (style == NULL((void*)0))
5830	return 1.0;
5831
5832	return style->layout->title_scale;
5833	}
5834
5835	void
5836	meta_theme_draw_frame (MetaTheme *theme,
5837	CtkStyleContext *style_ctk,
5838	cairo_t *cr,
5839	MetaFrameType type,
5840	MetaFrameFlags flags,
5841	int client_width,
5842	int client_height,
5843	PangoLayout *title_layout,
5844	int text_height,
5845	const MetaButtonLayout *button_layout,
5846	MetaButtonState button_states[META_BUTTON_TYPE_LAST],
5847	GdkPixbuf *mini_icon,
5848	GdkPixbuf *icon)
5849	{
5850	MetaFrameGeometry fgeom;
5851	MetaFrameStyle *style;
5852
5853	g_return_if_fail (type < META_FRAME_TYPE_LAST)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST" ); return; } } while (0);
5854
5855	style = theme_get_style (theme, type, flags);
5856
5857	/* Parser is not supposed to allow this currently */
5858	if (style == NULL((void*)0))
5859	return;
5860
5861	meta_frame_layout_calc_geometry (style->layout,
5862	text_height,
5863	flags,
5864	client_width, client_height,
5865	button_layout,
5866	&fgeom,
5867	theme);
5868
5869	meta_frame_style_draw_with_style (style,
5870	style_ctk,
5871	cr,
5872	&fgeom,
5873	client_width, client_height,
5874	title_layout,
5875	text_height,
5876	button_states,
5877	mini_icon, icon);
5878	}
5879
5880	void
5881	meta_theme_draw_frame_by_name (MetaTheme *theme,
5882	CtkWidget *widget,
5883	cairo_t *cr,
5884	const gchar *style_name,
5885	MetaFrameFlags flags,
5886	int client_width,
5887	int client_height,
5888	PangoLayout *title_layout,
5889	int text_height,
5890	const MetaButtonLayout *button_layout,
5891	MetaButtonState button_states[META_BUTTON_TYPE_LAST],
5892	GdkPixbuf *mini_icon,
5893	GdkPixbuf *icon)
5894	{
5895	MetaFrameGeometry fgeom;
5896	MetaFrameStyle *style;
5897
5898	style = meta_theme_lookup_style (theme, style_name);
5899
5900	/* Parser is not supposed to allow this currently */
5901	if (style == NULL((void*)0))
5902	return;
5903
5904	meta_frame_layout_calc_geometry (style->layout,
5905	text_height,
5906	flags,
5907	client_width, client_height,
5908	button_layout,
5909	&fgeom,
5910	theme);
5911
5912	meta_frame_style_draw (style,
5913	widget,
5914	cr,
5915	&fgeom,
5916	client_width, client_height,
5917	title_layout,
5918	text_height,
5919	button_states,
5920	mini_icon, icon);
5921	}
5922
5923	void
5924	meta_theme_get_frame_borders (MetaTheme *theme,
5925	MetaFrameType type,
5926	int text_height,
5927	MetaFrameFlags flags,
5928	MetaFrameBorders *borders)
5929	{
5930	MetaFrameStyle *style;
5931
5932	g_return_if_fail (type < META_FRAME_TYPE_LAST)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST" ); return; } } while (0);
5933
5934	style = theme_get_style (theme, type, flags);
5935
5936	meta_frame_borders_clear (borders);
5937
5938	/* Parser is not supposed to allow this currently */
5939	if (style == NULL((void*)0))
5940	return;
5941
5942	meta_frame_layout_get_borders (style->layout,
5943	text_height,
5944	flags,
5945	borders);
5946	}
5947
5948	void
5949	meta_theme_calc_geometry (MetaTheme *theme,
5950	MetaFrameType type,
5951	int text_height,
5952	MetaFrameFlags flags,
5953	int client_width,
5954	int client_height,
5955	const MetaButtonLayout *button_layout,
5956	MetaFrameGeometry *fgeom)
5957	{
5958	MetaFrameStyle *style;
5959
5960	g_return_if_fail (type < META_FRAME_TYPE_LAST)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST" ); return; } } while (0);
5961
5962	style = theme_get_style (theme, type, flags);
5963
5964	/* Parser is not supposed to allow this currently */
5965	if (style == NULL((void*)0))
5966	return;
5967
5968	meta_frame_layout_calc_geometry (style->layout,
5969	text_height,
5970	flags,
5971	client_width, client_height,
5972	button_layout,
5973	fgeom,
5974	theme);
5975	}
5976
5977	MetaFrameLayout*
5978	meta_theme_lookup_layout (MetaTheme *theme,
5979	const char *name)
5980	{
5981	return g_hash_table_lookup (theme->layouts_by_name, name);
5982	}
5983
5984	void
5985	meta_theme_insert_layout (MetaTheme *theme,
5986	const char *name,
5987	MetaFrameLayout *layout)
5988	{
5989	meta_frame_layout_ref (layout);
5990	g_hash_table_replace (theme->layouts_by_name, g_strdup (name), layout);
5991	}
5992
5993	MetaDrawOpList*
5994	meta_theme_lookup_draw_op_list (MetaTheme *theme,
5995	const char *name)
5996	{
5997	return g_hash_table_lookup (theme->draw_op_lists_by_name, name);
5998	}
5999
6000	void
6001	meta_theme_insert_draw_op_list (MetaTheme *theme,
6002	const char *name,
6003	MetaDrawOpList *op_list)
6004	{
6005	meta_draw_op_list_ref (op_list);
6006	g_hash_table_replace (theme->draw_op_lists_by_name, g_strdup (name), op_list);
6007	}
6008
6009	MetaFrameStyle*
6010	meta_theme_lookup_style (MetaTheme *theme,
6011	const char *name)
6012	{
6013	return g_hash_table_lookup (theme->styles_by_name, name);
6014	}
6015
6016	void
6017	meta_theme_insert_style (MetaTheme *theme,
6018	const char *name,
6019	MetaFrameStyle *style)
6020	{
6021	meta_frame_style_ref (style);
6022	g_hash_table_replace (theme->styles_by_name, g_strdup (name), style);
6023	}
6024
6025	MetaFrameStyleSet*
6026	meta_theme_lookup_style_set (MetaTheme *theme,
6027	const char *name)
6028	{
6029	return g_hash_table_lookup (theme->style_sets_by_name, name);
6030	}
6031
6032	void
6033	meta_theme_insert_style_set (MetaTheme *theme,
6034	const char *name,
6035	MetaFrameStyleSet *style_set)
6036	{
6037	meta_frame_style_set_ref (style_set);
6038	g_hash_table_replace (theme->style_sets_by_name, g_strdup (name), style_set);
6039	}
6040
6041	static gboolean
6042	first_uppercase (const char *str)
6043	{
6044	return g_ascii_isupper (str)((g_ascii_table[(guchar) (str)] & G_ASCII_UPPER) != 0);
6045	}
6046
6047	gboolean
6048	meta_theme_define_int_constant (MetaTheme *theme,
6049	const char *name,
6050	int value,
6051	GError **error)
6052	{
6053	if (theme->integer_constants == NULL((void*)0))
6054	theme->integer_constants = g_hash_table_new_full (g_str_hash,
6055	g_str_equal,
6056	g_free,
6057	NULL((void*)0));
6058
6059	if (!first_uppercase (name))
6060	{
6061	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
6062	_("User-defined constants must begin with a capital letter; \"%s\" does not")dgettext ("croma", "User-defined constants must begin with a capital letter; \"%s\" does not" ),
6063	name);
6064	return FALSE(0);
6065	}
6066
6067	if (g_hash_table_lookup_extended (theme->integer_constants, name, NULL((void)0), NULL((void)0)))
6068	{
6069	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
6070	_("Constant \"%s\" has already been defined")dgettext ("croma", "Constant \"%s\" has already been defined" ),
6071	name);
6072
6073	return FALSE(0);
6074	}
6075
6076	g_hash_table_insert (theme->integer_constants,
6077	g_strdup (name),
6078	GINT_TO_POINTER (value)((gpointer) (glong) (value)));
6079
6080	return TRUE(!(0));
6081	}
6082
6083	gboolean
6084	meta_theme_lookup_int_constant (MetaTheme *theme,
6085	const char *name,
6086	int *value)
6087	{
6088	gpointer old_value;
6089
6090	*value = 0;
6091
6092	if (theme->integer_constants == NULL((void*)0))
6093	return FALSE(0);
6094
6095	if (g_hash_table_lookup_extended (theme->integer_constants,
6096	name, NULL((void*)0), &old_value))
6097	{
6098	*value = GPOINTER_TO_INT (old_value)((gint) (glong) (old_value));
6099	return TRUE(!(0));
6100	}
6101	else
6102	{
6103	return FALSE(0);
6104	}
6105	}
6106
6107	gboolean
6108	meta_theme_define_float_constant (MetaTheme *theme,
6109	const char *name,
6110	double value,
6111	GError **error)
6112	{
6113	double *d;
6114
6115	if (theme->float_constants == NULL((void*)0))
6116	theme->float_constants = g_hash_table_new_full (g_str_hash,
6117	g_str_equal,
6118	g_free,
6119	g_free);
6120
6121	if (!first_uppercase (name))
6122	{
6123	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
6124	_("User-defined constants must begin with a capital letter; \"%s\" does not")dgettext ("croma", "User-defined constants must begin with a capital letter; \"%s\" does not" ),
6125	name);
6126	return FALSE(0);
6127	}
6128
6129	if (g_hash_table_lookup_extended (theme->float_constants, name, NULL((void)0), NULL((void)0)))
6130	{
6131	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
6132	_("Constant \"%s\" has already been defined")dgettext ("croma", "Constant \"%s\" has already been defined" ),
6133	name);
6134
6135	return FALSE(0);
6136	}
6137
6138	d = g_new (double, 1)((double *) g_malloc_n ((1), sizeof (double)));
6139	*d = value;
6140
6141	g_hash_table_insert (theme->float_constants,
6142	g_strdup (name), d);
6143
6144	return TRUE(!(0));
6145	}
6146
6147	gboolean
6148	meta_theme_lookup_float_constant (MetaTheme *theme,
6149	const char *name,
6150	double *value)
6151	{
6152	double *d;
6153
6154	*value = 0.0;
6155
6156	if (theme->float_constants == NULL((void*)0))
6157	return FALSE(0);
6158
6159	d = g_hash_table_lookup (theme->float_constants, name);
6160
6161	if (d)
6162	{
6163	value = d;
6164	return TRUE(!(0));
6165	}
6166	else
6167	{
6168	return FALSE(0);
6169	}
6170	}
6171
6172	gboolean
6173	meta_theme_define_color_constant (MetaTheme *theme,
6174	const char *name,
6175	const char *value,
6176	GError **error)
6177	{
6178	if (theme->color_constants == NULL((void*)0))
6179	theme->color_constants = g_hash_table_new_full (g_str_hash,
6180	g_str_equal,
6181	g_free,
6182	NULL((void*)0));
6183
6184	if (!first_uppercase (name))
6185	{
6186	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
6187	_("User-defined constants must begin with a capital letter; \"%s\" does not")dgettext ("croma", "User-defined constants must begin with a capital letter; \"%s\" does not" ),
6188	name);
6189	return FALSE(0);
6190	}
6191
6192	if (g_hash_table_lookup_extended (theme->color_constants, name, NULL((void)0), NULL((void)0)))
6193	{
6194	g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
6195	_("Constant \"%s\" has already been defined")dgettext ("croma", "Constant \"%s\" has already been defined" ),
6196	name);
6197
6198	return FALSE(0);
6199	}
6200
6201	g_hash_table_insert (theme->color_constants,
6202	g_strdup (name),
6203	g_strdup (value));
6204
6205	return TRUE(!(0));
6206	}
6207
6208	/**
6209	* Looks up a colour constant.
6210	*
6211	* \param theme the theme containing the constant
6212	* \param name the name of the constant
6213	* \param value [out] the string representation of the colour, or NULL if it
6214	* doesn't exist
6215	* \return TRUE if it exists, FALSE otherwise
6216	*/
6217	gboolean
6218	meta_theme_lookup_color_constant (MetaTheme *theme,
6219	const char *name,
6220	char **value)
6221	{
6222	char *result;
6223
6224	value = NULL((void)0);
6225
6226	if (theme->color_constants == NULL((void*)0))
6227	return FALSE(0);
6228
6229	result = g_hash_table_lookup (theme->color_constants, name);
6230
6231	if (result)
6232	{
6233	*value = result;
6234	return TRUE(!(0));
6235	}
6236	else
6237	{
6238	return FALSE(0);
6239	}
6240	}
6241
6242
6243	PangoFontDescription*
6244	meta_ctk_widget_get_font_desc (CtkWidget *widget,
6245	double scale,
6246	const PangoFontDescription *override)
6247	{
6248	PangoFontDescription *font_desc;
6249
6250	CtkStyleContext *style = ctk_widget_get_style_context (widget);
6251	CtkStateFlags state = ctk_widget_get_state_flags (widget);
6252	ctk_style_context_get(style, state, CTK_STYLE_PROPERTY_FONT"font", &font_desc, NULL((void*)0));
6253	font_desc = pango_font_description_copy (font_desc);
6254
6255	if (override)
6256	pango_font_description_merge (font_desc, override, TRUE(!(0)));
6257
6258	pango_font_description_set_size (font_desc,
6259	MAX (pango_font_description_get_size (font_desc) * scale, 1)(((pango_font_description_get_size (font_desc) * scale) > ( 1)) ? (pango_font_description_get_size (font_desc) * scale) : (1)));
6260
6261	return font_desc;
6262	}
6263
6264	/**
6265	* Returns the height of the letters in a particular font.
6266	*
6267	* \param font_desc the font
6268	* \param context the context of the font
6269	* \return the height of the letters
6270	*/
6271	int
6272	meta_pango_font_desc_get_text_height (const PangoFontDescription *font_desc,
6273	PangoContext *context)
6274	{
6275	PangoFontMetrics *metrics;
6276	PangoLanguage *lang;
6277	int retval;
6278
6279	lang = pango_context_get_language (context);
6280	metrics = pango_context_get_metrics (context, font_desc, lang);
6281
6282	retval = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +(((int)(pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics)) + 512) >> 10)
6283	pango_font_metrics_get_descent (metrics))(((int)(pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics)) + 512) >> 10);
6284
6285	pango_font_metrics_unref (metrics);
6286
6287	return retval;
6288	}
6289
6290	MetaCtkColorComponent
6291	meta_color_component_from_string (const char *str)
6292	{
6293	if (strcmp ("fg", str) == 0)
6294	return META_CTK_COLOR_FG;
6295	else if (strcmp ("bg", str) == 0)
6296	return META_CTK_COLOR_BG;
6297	else if (strcmp ("light", str) == 0)
6298	return META_CTK_COLOR_LIGHT;
6299	else if (strcmp ("dark", str) == 0)
6300	return META_CTK_COLOR_DARK;
6301	else if (strcmp ("mid", str) == 0)
6302	return META_CTK_COLOR_MID;
6303	else if (strcmp ("text", str) == 0)
6304	return META_CTK_COLOR_TEXT;
6305	else if (strcmp ("base", str) == 0)
6306	return META_CTK_COLOR_BASE;
6307	else if (strcmp ("text_aa", str) == 0)
6308	return META_CTK_COLOR_TEXT_AA;
6309	else
6310	return META_CTK_COLOR_LAST;
6311	}
6312
6313	const char*
6314	meta_color_component_to_string (MetaCtkColorComponent component)
6315	{
6316	switch (component)
6317	{
6318	case META_CTK_COLOR_FG:
6319	return "fg";
6320	case META_CTK_COLOR_BG:
6321	return "bg";
6322	case META_CTK_COLOR_LIGHT:
6323	return "light";
6324	case META_CTK_COLOR_DARK:
6325	return "dark";
6326	case META_CTK_COLOR_MID:
6327	return "mid";
6328	case META_CTK_COLOR_TEXT:
6329	return "text";
6330	case META_CTK_COLOR_BASE:
6331	return "base";
6332	case META_CTK_COLOR_TEXT_AA:
6333	return "text_aa";
6334	case META_CTK_COLOR_LAST:
6335	break;
6336	}
6337
6338	return "<unknown>";
6339	}
6340
6341	MetaButtonState
6342	meta_button_state_from_string (const char *str)
6343	{
6344	if (strcmp ("normal", str) == 0)
6345	return META_BUTTON_STATE_NORMAL;
6346	else if (strcmp ("pressed", str) == 0)
6347	return META_BUTTON_STATE_PRESSED;
6348	else if (strcmp ("prelight", str) == 0)
6349	return META_BUTTON_STATE_PRELIGHT;
6350	else
6351	return META_BUTTON_STATE_LAST;
6352	}
6353
6354	const char*
6355	meta_button_state_to_string (MetaButtonState state)
6356	{
6357	switch (state)
6358	{
6359	case META_BUTTON_STATE_NORMAL:
6360	return "normal";
6361	case META_BUTTON_STATE_PRESSED:
6362	return "pressed";
6363	case META_BUTTON_STATE_PRELIGHT:
6364	return "prelight";
6365	case META_BUTTON_STATE_LAST:
6366	break;
6367	}
6368
6369	return "<unknown>";
6370	}
6371
6372	MetaButtonType
6373	meta_button_type_from_string (const char str, MetaTheme theme)
6374	{
6375	if (META_THEME_ALLOWS(theme, META_THEME_SHADE_STICK_ABOVE_BUTTONS)(theme->format_version >= 2))
6376	{
6377	if (strcmp ("shade", str) == 0)
6378	return META_BUTTON_TYPE_SHADE;
6379	else if (strcmp ("above", str) == 0)
6380	return META_BUTTON_TYPE_ABOVE;
6381	else if (strcmp ("stick", str) == 0)
6382	return META_BUTTON_TYPE_STICK;
6383	else if (strcmp ("unshade", str) == 0)
6384	return META_BUTTON_TYPE_UNSHADE;
6385	else if (strcmp ("unabove", str) == 0)
6386	return META_BUTTON_TYPE_UNABOVE;
6387	else if (strcmp ("unstick", str) == 0)
6388	return META_BUTTON_TYPE_UNSTICK;
6389	}
6390
6391	if (strcmp ("close", str) == 0)
6392	return META_BUTTON_TYPE_CLOSE;
6393	else if (strcmp ("maximize", str) == 0)
6394	return META_BUTTON_TYPE_MAXIMIZE;
6395	else if (strcmp ("minimize", str) == 0)
6396	return META_BUTTON_TYPE_MINIMIZE;
6397	else if (strcmp ("menu", str) == 0)
6398	return META_BUTTON_TYPE_MENU;
6399	else if (strcmp ("appmenu", str) == 0)
6400	return META_BUTTON_TYPE_APPMENU;
6401	else if (strcmp ("left_left_background", str) == 0)
6402	return META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND;
6403	else if (strcmp ("left_middle_background", str) == 0)
6404	return META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND;
6405	else if (strcmp ("left_right_background", str) == 0)
6406	return META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND;
6407	else if (strcmp ("left_single_background", str) == 0)
6408	return META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND;
6409	else if (strcmp ("right_left_background", str) == 0)
6410	return META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND;
6411	else if (strcmp ("right_middle_background", str) == 0)
6412	return META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND;
6413	else if (strcmp ("right_right_background", str) == 0)
6414	return META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND;
6415	else if (strcmp ("right_single_background", str) == 0)
6416	return META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND;
6417	else
6418	return META_BUTTON_TYPE_LAST;
6419	}
6420
6421	const char*
6422	meta_button_type_to_string (MetaButtonType type)
6423	{
6424	switch (type)
6425	{
6426	case META_BUTTON_TYPE_CLOSE:
6427	return "close";
6428	case META_BUTTON_TYPE_MAXIMIZE:
6429	return "maximize";
6430	case META_BUTTON_TYPE_MINIMIZE:
6431	return "minimize";
6432	case META_BUTTON_TYPE_SHADE:
6433	return "shade";
6434	case META_BUTTON_TYPE_ABOVE:
6435	return "above";
6436	case META_BUTTON_TYPE_STICK:
6437	return "stick";
6438	case META_BUTTON_TYPE_UNSHADE:
6439	return "unshade";
6440	case META_BUTTON_TYPE_UNABOVE:
6441	return "unabove";
6442	case META_BUTTON_TYPE_UNSTICK:
6443	return "unstick";
6444	case META_BUTTON_TYPE_MENU:
6445	return "menu";
6446	case META_BUTTON_TYPE_APPMENU:
6447	return "appmenu";
6448	case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
6449	return "left_left_background";
6450	case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
6451	return "left_middle_background";
6452	case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
6453	return "left_right_background";
6454	case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
6455	return "left_single_background";
6456	case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
6457	return "right_left_background";
6458	case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
6459	return "right_middle_background";
6460	case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
6461	return "right_right_background";
6462	case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
6463	return "right_single_background";
6464	case META_BUTTON_TYPE_LAST:
6465	break;
6466	}
6467
6468	return "<unknown>";
6469	}
6470
6471	MetaFramePiece
6472	meta_frame_piece_from_string (const char *str)
6473	{
6474	if (strcmp ("entire_background", str) == 0)
6475	return META_FRAME_PIECE_ENTIRE_BACKGROUND;
6476	else if (strcmp ("titlebar", str) == 0)
6477	return META_FRAME_PIECE_TITLEBAR;
6478	else if (strcmp ("titlebar_middle", str) == 0)
6479	return META_FRAME_PIECE_TITLEBAR_MIDDLE;
6480	else if (strcmp ("left_titlebar_edge", str) == 0)
6481	return META_FRAME_PIECE_LEFT_TITLEBAR_EDGE;
6482	else if (strcmp ("right_titlebar_edge", str) == 0)
6483	return META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE;
6484	else if (strcmp ("top_titlebar_edge", str) == 0)
6485	return META_FRAME_PIECE_TOP_TITLEBAR_EDGE;
6486	else if (strcmp ("bottom_titlebar_edge", str) == 0)
6487	return META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE;
6488	else if (strcmp ("title", str) == 0)
6489	return META_FRAME_PIECE_TITLE;
6490	else if (strcmp ("left_edge", str) == 0)
6491	return META_FRAME_PIECE_LEFT_EDGE;
6492	else if (strcmp ("right_edge", str) == 0)
6493	return META_FRAME_PIECE_RIGHT_EDGE;
6494	else if (strcmp ("bottom_edge", str) == 0)
6495	return META_FRAME_PIECE_BOTTOM_EDGE;
6496	else if (strcmp ("overlay", str) == 0)
6497	return META_FRAME_PIECE_OVERLAY;
6498	else
6499	return META_FRAME_PIECE_LAST;
6500	}
6501
6502	const char*
6503	meta_frame_piece_to_string (MetaFramePiece piece)
6504	{
6505	switch (piece)
6506	{
6507	case META_FRAME_PIECE_ENTIRE_BACKGROUND:
6508	return "entire_background";
6509	case META_FRAME_PIECE_TITLEBAR:
6510	return "titlebar";
6511	case META_FRAME_PIECE_TITLEBAR_MIDDLE:
6512	return "titlebar_middle";
6513	case META_FRAME_PIECE_LEFT_TITLEBAR_EDGE:
6514	return "left_titlebar_edge";
6515	case META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE:
6516	return "right_titlebar_edge";
6517	case META_FRAME_PIECE_TOP_TITLEBAR_EDGE:
6518	return "top_titlebar_edge";
6519	case META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE:
6520	return "bottom_titlebar_edge";
6521	case META_FRAME_PIECE_TITLE:
6522	return "title";
6523	case META_FRAME_PIECE_LEFT_EDGE:
6524	return "left_edge";
6525	case META_FRAME_PIECE_RIGHT_EDGE:
6526	return "right_edge";
6527	case META_FRAME_PIECE_BOTTOM_EDGE:
6528	return "bottom_edge";
6529	case META_FRAME_PIECE_OVERLAY:
6530	return "overlay";
6531	case META_FRAME_PIECE_LAST:
6532	break;
6533	}
6534
6535	return "<unknown>";
6536	}
6537
6538	MetaFrameState
6539	meta_frame_state_from_string (const char *str)
6540	{
6541	if (strcmp ("normal", str) == 0)
6542	return META_FRAME_STATE_NORMAL;
6543	else if (strcmp ("maximized", str) == 0)
6544	return META_FRAME_STATE_MAXIMIZED;
6545	else if (strcmp ("tiled_left", str) == 0)
6546	return META_FRAME_STATE_TILED_LEFT;
6547	else if (strcmp ("tiled_right", str) == 0)
6548	return META_FRAME_STATE_TILED_RIGHT;
6549	else if (strcmp ("shaded", str) == 0)
6550	return META_FRAME_STATE_SHADED;
6551	else if (strcmp ("maximized_and_shaded", str) == 0)
6552	return META_FRAME_STATE_MAXIMIZED_AND_SHADED;
6553	else if (strcmp ("tiled_left_and_shaded", str) == 0)
6554	return META_FRAME_STATE_TILED_LEFT_AND_SHADED;
6555	else if (strcmp ("tiled_right_and_shaded", str) == 0)
6556	return META_FRAME_STATE_TILED_RIGHT_AND_SHADED;
6557	else
6558	return META_FRAME_STATE_LAST;
6559	}
6560
6561	const char*
6562	meta_frame_state_to_string (MetaFrameState state)
6563	{
6564	switch (state)
6565	{
6566	case META_FRAME_STATE_NORMAL:
6567	return "normal";
6568	case META_FRAME_STATE_MAXIMIZED:
6569	return "maximized";
6570	case META_FRAME_STATE_TILED_LEFT:
6571	return "tiled_left";
6572	case META_FRAME_STATE_TILED_RIGHT:
6573	return "tiled_right";
6574	case META_FRAME_STATE_SHADED:
6575	return "shaded";
6576	case META_FRAME_STATE_MAXIMIZED_AND_SHADED:
6577	return "maximized_and_shaded";
6578	case META_FRAME_STATE_TILED_LEFT_AND_SHADED:
6579	return "tiled_left_and_shaded";
6580	case META_FRAME_STATE_TILED_RIGHT_AND_SHADED:
6581	return "tiled_right_and_shaded";
6582	case META_FRAME_STATE_LAST:
6583	break;
6584	}
6585
6586	return "<unknown>";
6587	}
6588
6589	MetaFrameResize
6590	meta_frame_resize_from_string (const char *str)
6591	{
6592	if (strcmp ("none", str) == 0)
6593	return META_FRAME_RESIZE_NONE;
6594	else if (strcmp ("vertical", str) == 0)
6595	return META_FRAME_RESIZE_VERTICAL;
6596	else if (strcmp ("horizontal", str) == 0)
6597	return META_FRAME_RESIZE_HORIZONTAL;
6598	else if (strcmp ("both", str) == 0)
6599	return META_FRAME_RESIZE_BOTH;
6600	else
6601	return META_FRAME_RESIZE_LAST;
6602	}
6603
6604	const char*
6605	meta_frame_resize_to_string (MetaFrameResize resize)
6606	{
6607	switch (resize)
6608	{
6609	case META_FRAME_RESIZE_NONE:
6610	return "none";
6611	case META_FRAME_RESIZE_VERTICAL:
6612	return "vertical";
6613	case META_FRAME_RESIZE_HORIZONTAL:
6614	return "horizontal";
6615	case META_FRAME_RESIZE_BOTH:
6616	return "both";
6617	case META_FRAME_RESIZE_LAST:
6618	break;
6619	}
6620
6621	return "<unknown>";
6622	}
6623
6624	MetaFrameFocus
6625	meta_frame_focus_from_string (const char *str)
6626	{
6627	if (strcmp ("no", str) == 0)
6628	return META_FRAME_FOCUS_NO;
6629	else if (strcmp ("yes", str) == 0)
6630	return META_FRAME_FOCUS_YES;
6631	else
6632	return META_FRAME_FOCUS_LAST;
6633	}
6634
6635	const char*
6636	meta_frame_focus_to_string (MetaFrameFocus focus)
6637	{
6638	switch (focus)
6639	{
6640	case META_FRAME_FOCUS_NO:
6641	return "no";
6642	case META_FRAME_FOCUS_YES:
6643	return "yes";
6644	case META_FRAME_FOCUS_LAST:
6645	break;
6646	}
6647
6648	return "<unknown>";
6649	}
6650
6651	MetaFrameType
6652	meta_frame_type_from_string (const char *str)
6653	{
6654	if (strcmp ("normal", str) == 0)
6655	return META_FRAME_TYPE_NORMAL;
6656	else if (strcmp ("dialog", str) == 0)
6657	return META_FRAME_TYPE_DIALOG;
6658	else if (strcmp ("modal_dialog", str) == 0)
6659	return META_FRAME_TYPE_MODAL_DIALOG;
6660	else if (strcmp ("utility", str) == 0)
6661	return META_FRAME_TYPE_UTILITY;
6662	else if (strcmp ("menu", str) == 0)
6663	return META_FRAME_TYPE_MENU;
6664	else if (strcmp ("border", str) == 0)
6665	return META_FRAME_TYPE_BORDER;
6666	else if (strcmp ("attached", str) == 0)
6667	return META_FRAME_TYPE_ATTACHED;
6668	#if 0
6669	else if (strcmp ("toolbar", str) == 0)
6670	return META_FRAME_TYPE_TOOLBAR;
6671	#endif
6672	else
6673	return META_FRAME_TYPE_LAST;
6674	}
6675
6676	const char*
6677	meta_frame_type_to_string (MetaFrameType type)
6678	{
6679	switch (type)
6680	{
6681	case META_FRAME_TYPE_NORMAL:
6682	return "normal";
6683	case META_FRAME_TYPE_DIALOG:
6684	return "dialog";
6685	case META_FRAME_TYPE_MODAL_DIALOG:
6686	return "modal_dialog";
6687	case META_FRAME_TYPE_UTILITY:
6688	return "utility";
6689	case META_FRAME_TYPE_MENU:
6690	return "menu";
6691	case META_FRAME_TYPE_BORDER:
6692	return "border";
6693	case META_FRAME_TYPE_ATTACHED:
6694	return "attached";
6695	#if 0
6696	case META_FRAME_TYPE_TOOLBAR:
6697	return "toolbar";
6698	#endif
6699	case META_FRAME_TYPE_LAST:
6700	break;
6701	}
6702
6703	return "<unknown>";
6704	}
6705
6706	MetaGradientType
6707	meta_gradient_type_from_string (const char *str)
6708	{
6709	if (strcmp ("vertical", str) == 0)
6710	return META_GRADIENT_VERTICAL;
6711	else if (strcmp ("horizontal", str) == 0)
6712	return META_GRADIENT_HORIZONTAL;
6713	else if (strcmp ("diagonal", str) == 0)
6714	return META_GRADIENT_DIAGONAL;
6715	else
6716	return META_GRADIENT_LAST;
6717	}
6718
6719	const char*
6720	meta_gradient_type_to_string (MetaGradientType type)
6721	{
6722	switch (type)
6723	{
6724	case META_GRADIENT_VERTICAL:
6725	return "vertical";
6726	case META_GRADIENT_HORIZONTAL:
6727	return "horizontal";
6728	case META_GRADIENT_DIAGONAL:
6729	return "diagonal";
6730	case META_GRADIENT_LAST:
6731	break;
6732	}
6733
6734	return "<unknown>";
6735	}
6736
6737	CtkStateFlags
6738	meta_ctk_state_from_string (const char *str)
6739	{
6740	if (g_ascii_strcasecmp ("normal", str) == 0)
6741	return CTK_STATE_FLAG_NORMAL;
6742	else if (g_ascii_strcasecmp ("prelight", str) == 0)
6743	return CTK_STATE_FLAG_PRELIGHT;
6744	else if (g_ascii_strcasecmp ("active", str) == 0)
6745	return CTK_STATE_FLAG_ACTIVE;
6746	else if (g_ascii_strcasecmp ("selected", str) == 0)
6747	return CTK_STATE_FLAG_SELECTED;
6748	else if (g_ascii_strcasecmp ("insensitive", str) == 0)
6749	return CTK_STATE_FLAG_INSENSITIVE;
6750	else if (g_ascii_strcasecmp ("inconsistent", str) == 0)
6751	return CTK_STATE_FLAG_INCONSISTENT;
6752	else if (g_ascii_strcasecmp ("focused", str) == 0)
6753	return CTK_STATE_FLAG_FOCUSED;
6754	else if (g_ascii_strcasecmp ("backdrop", str) == 0)
6755	return CTK_STATE_FLAG_BACKDROP;
6756	else
6757	return -1; /* hack */
6758	}
6759
6760	CtkShadowType
6761	meta_ctk_shadow_from_string (const char *str)
6762	{
6763	if (strcmp ("none", str) == 0)
6764	return CTK_SHADOW_NONE;
6765	else if (strcmp ("in", str) == 0)
6766	return CTK_SHADOW_IN;
6767	else if (strcmp ("out", str) == 0)
6768	return CTK_SHADOW_OUT;
6769	else if (strcmp ("etched_in", str) == 0)
6770	return CTK_SHADOW_ETCHED_IN;
6771	else if (strcmp ("etched_out", str) == 0)
6772	return CTK_SHADOW_ETCHED_OUT;
6773	else
6774	return -1;
6775	}
6776
6777	const char*
6778	meta_ctk_shadow_to_string (CtkShadowType shadow)
6779	{
6780	switch (shadow)
6781	{
6782	case CTK_SHADOW_NONE:
6783	return "none";
6784	case CTK_SHADOW_IN:
6785	return "in";
6786	case CTK_SHADOW_OUT:
6787	return "out";
6788	case CTK_SHADOW_ETCHED_IN:
6789	return "etched_in";
6790	case CTK_SHADOW_ETCHED_OUT:
6791	return "etched_out";
6792	}
6793
6794	return "<unknown>";
	This statement is never executed
6795	}
6796
6797	CtkArrowType
6798	meta_ctk_arrow_from_string (const char *str)
6799	{
6800	if (strcmp ("up", str) == 0)
6801	return CTK_ARROW_UP;
6802	else if (strcmp ("down", str) == 0)
6803	return CTK_ARROW_DOWN;
6804	else if (strcmp ("left", str) == 0)
6805	return CTK_ARROW_LEFT;
6806	else if (strcmp ("right", str) == 0)
6807	return CTK_ARROW_RIGHT;
6808	else if (strcmp ("none", str) == 0)
6809	return CTK_ARROW_NONE;
6810	else
6811	return -1;
6812	}
6813
6814	const char*
6815	meta_ctk_arrow_to_string (CtkArrowType arrow)
6816	{
6817	switch (arrow)
6818	{
6819	case CTK_ARROW_UP:
6820	return "up";
6821	case CTK_ARROW_DOWN:
6822	return "down";
6823	case CTK_ARROW_LEFT:
6824	return "left";
6825	case CTK_ARROW_RIGHT:
6826	return "right";
6827	case CTK_ARROW_NONE:
6828	return "none";
6829	}
6830
6831	return "<unknown>";
6832	}
6833
6834	/**
6835	* Returns a fill_type from a string. The inverse of
6836	* meta_image_fill_type_to_string().
6837	*
6838	* \param str a string representing a fill_type
6839	* \result the fill_type, or -1 if it represents no fill_type.
6840	*/
6841	MetaImageFillType
6842	meta_image_fill_type_from_string (const char *str)
6843	{
6844	if (strcmp ("tile", str) == 0)
6845	return META_IMAGE_FILL_TILE;
6846	else if (strcmp ("scale", str) == 0)
6847	return META_IMAGE_FILL_SCALE;
6848	else
6849	return -1;
6850	}
6851
6852	/**
6853	* Returns a string representation of a fill_type. The inverse of
6854	* meta_image_fill_type_from_string().
6855	*
6856	* \param fill_type the fill type
6857	* \result a string representing that type
6858	*/
6859	const char*
6860	meta_image_fill_type_to_string (MetaImageFillType fill_type)
6861	{
6862	switch (fill_type)
6863	{
6864	case META_IMAGE_FILL_TILE:
6865	return "tile";
6866	case META_IMAGE_FILL_SCALE:
6867	return "scale";
6868	}
6869
6870	return "<unknown>";
6871	}
6872
6873	/**
6874	* Takes a colour "a", scales the lightness and saturation by a certain amount,
6875	* and sets "b" to the resulting colour.
6876	* ctkstyle.c cut-and-pastage.
6877	*
6878	* \param a the starting colour
6879	* \param b [out] the resulting colour
6880	* \param k amount to scale lightness and saturation by
6881	*/
6882	static void
6883	ctk_style_shade (CdkRGBA *a,
6884	CdkRGBA *b,
6885	gdouble k)
6886	{
6887	gdouble red;
6888	gdouble green;
6889	gdouble blue;
6890
6891	red = a->red;
6892	green = a->green;
6893	blue = a->blue;
6894
6895	rgb_to_hls (&red, &green, &blue);
6896
6897	green *= k;
6898	if (green > 1.0)
6899	green = 1.0;
6900	else if (green < 0.0)
6901	green = 0.0;
6902
6903	blue *= k;
6904	if (blue > 1.0)
6905	blue = 1.0;
6906	else if (blue < 0.0)
6907	blue = 0.0;
6908
6909	hls_to_rgb (&red, &green, &blue);
6910
6911	b->red = red;
6912	b->green = green;
6913	b->blue = blue;
6914	}
6915
6916	/**
6917	* Converts a red/green/blue triplet to a hue/lightness/saturation triplet.
6918	*
6919	* \param r on input, red; on output, hue
6920	* \param g on input, green; on output, lightness
6921	* \param b on input, blue; on output, saturation
6922	*/
6923	static void
6924	rgb_to_hls (gdouble *r,
6925	gdouble *g,
6926	gdouble *b)
6927	{
6928	gdouble min;
6929	gdouble max;
6930	gdouble red;
6931	gdouble green;
6932	gdouble blue;
6933	gdouble h, l, s;
6934	gdouble delta;
6935
6936	red = *r;
6937	green = *g;
6938	blue = *b;
6939
6940	if (red > green)
6941	{
6942	if (red > blue)
6943	max = red;
6944	else
6945	max = blue;
6946
6947	if (green < blue)
6948	min = green;
6949	else
6950	min = blue;
6951	}
6952	else
6953	{
6954	if (green > blue)
6955	max = green;
6956	else
6957	max = blue;
6958
6959	if (red < blue)
6960	min = red;
6961	else
6962	min = blue;
6963	}
6964
6965	l = (max + min) / 2;
6966	s = 0;
6967	h = 0;
6968
6969	if (max != min)
6970	{
6971	if (l <= 0.5)
6972	s = (max - min) / (max + min);
6973	else
6974	s = (max - min) / (2 - max - min);
6975
6976	delta = max -min;
6977	if (red == max)
6978	h = (green - blue) / delta;
6979	else if (green == max)
6980	h = 2 + (blue - red) / delta;
6981	else if (blue == max)
6982	h = 4 + (red - green) / delta;
6983
6984	h *= 60;
6985	if (h < 0.0)
6986	h += 360;
6987	}
6988
6989	*r = h;
6990	*g = l;
6991	*b = s;
6992	}
6993
6994	/**
6995	* Converts a hue/lightness/saturation triplet to a red/green/blue triplet.
6996	*
6997	* \param h on input, hue; on output, red
6998	* \param l on input, lightness; on output, green
6999	* \param s on input, saturation; on output, blue
7000	*/
7001	static void
7002	hls_to_rgb (gdouble *h,
7003	gdouble *l,
7004	gdouble *s)
7005	{
7006	gdouble hue;
7007	gdouble lightness;
7008	gdouble saturation;
7009	gdouble m1, m2;
7010	gdouble r, g, b;
7011
7012	lightness = *l;
7013	saturation = *s;
7014
7015	if (lightness <= 0.5)
7016	m2 = lightness * (1 + saturation);
7017	else
7018	m2 = lightness + saturation - lightness * saturation;
7019	m1 = 2 * lightness - m2;
7020
7021	if (saturation == 0)
7022	{
7023	*h = lightness;
7024	*l = lightness;
7025	*s = lightness;
7026	}
7027	else
7028	{
7029	hue = *h + 120;
7030	while (hue > 360)
7031	hue -= 360;
7032	while (hue < 0)
7033	hue += 360;
7034
7035	if (hue < 60)
7036	r = m1 + (m2 - m1) * hue / 60;
7037	else if (hue < 180)
7038	r = m2;
7039	else if (hue < 240)
7040	r = m1 + (m2 - m1) * (240 - hue) / 60;
7041	else
7042	r = m1;
7043
7044	hue = *h;
7045	while (hue > 360)
7046	hue -= 360;
7047	while (hue < 0)
7048	hue += 360;
7049
7050	if (hue < 60)
7051	g = m1 + (m2 - m1) * hue / 60;
7052	else if (hue < 180)
7053	g = m2;
7054	else if (hue < 240)
7055	g = m1 + (m2 - m1) * (240 - hue) / 60;
7056	else
7057	g = m1;
7058
7059	hue = *h - 120;
7060	while (hue > 360)
7061	hue -= 360;
7062	while (hue < 0)
7063	hue += 360;
7064
7065	if (hue < 60)
7066	b = m1 + (m2 - m1) * hue / 60;
7067	else if (hue < 180)
7068	b = m2;
7069	else if (hue < 240)
7070	b = m1 + (m2 - m1) * (240 - hue) / 60;
7071	else
7072	b = m1;
7073
7074	*h = r;
7075	*l = g;
7076	*s = b;
7077	}
7078	}
7079
7080	#if 0
7081	/* These are some functions I'm saving to use in optimizing
7082	* MetaDrawOpList, namely to pre-composite pixbufs on client side
7083	* prior to rendering to the server
7084	*/
7085	static void
7086	draw_bg_solid_composite (const MetaTextureSpec *bg,
7087	const MetaTextureSpec *fg,
7088	double alpha,
7089	CtkWidget *widget,
7090	CdkDrawable *drawable,
7091	const CdkRectangle *clip,
7092	MetaTextureDrawMode mode,
7093	double xalign,
7094	double yalign,
7095	int x,
7096	int y,
7097	int width,
7098	int height)
7099	{
7100	CdkColor bg_color;
7101
7102	g_assert (bg->type == META_TEXTURE_SOLID)do { if (bg->type == META_TEXTURE_SOLID) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7102, ((const char*) (__func__)), "bg->type == META_TEXTURE_SOLID" ); } while (0);
7103	g_assert (fg->type != META_TEXTURE_COMPOSITE)do { if (fg->type != META_TEXTURE_COMPOSITE) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7103, ((const char*) (__func__)), "fg->type != META_TEXTURE_COMPOSITE" ); } while (0);
7104	g_assert (fg->type != META_TEXTURE_SHAPE_LIST)do { if (fg->type != META_TEXTURE_SHAPE_LIST) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7104, ((const char*) (__func__)), "fg->type != META_TEXTURE_SHAPE_LIST" ); } while (0);
7105
7106	meta_color_spec_render (bg->data.solid.color_spec,
7107	widget,
7108	&bg_color);
7109
7110	switch (fg->type)
7111	{
7112	case META_TEXTURE_SOLID:
7113	{
7114	CdkColor fg_color;
7115
7116	meta_color_spec_render (fg->data.solid.color_spec,
7117	widget,
7118	&fg_color);
7119
7120	color_composite (&bg_color, &fg_color,
7121	alpha, &fg_color);
7122
7123	draw_color_rectangle (widget, drawable, &fg_color, clip,
7124	x, y, width, height);
7125	}
7126	break;
7127
7128	case META_TEXTURE_GRADIENT:
7129	/* FIXME I think we could just composite all the colors in
7130	* the gradient prior to generating the gradient?
7131	*/
7132	/* FALL THRU */
7133	case META_TEXTURE_IMAGE:
7134	{
7135	GdkPixbuf *pixbuf;
7136	GdkPixbuf *composited;
7137
7138	pixbuf = meta_texture_spec_render (fg, widget, mode, 255,
7139	width, height);
7140
7141	if (pixbuf == NULL((void*)0))
7142	return;
7143
7144	composited = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
7145	gdk_pixbuf_get_has_alpha (pixbuf), 8,
7146	gdk_pixbuf_get_width (pixbuf),
7147	gdk_pixbuf_get_height (pixbuf));
7148
7149	if (composited == NULL((void*)0))
7150	{
7151	g_object_unref (G_OBJECT (pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((pixbuf)), (((GType) ((20) << (2)))))))));
7152	return;
7153	}
7154
7155	gdk_pixbuf_composite_color (pixbuf,
7156	composited,
7157	0, 0,
7158	gdk_pixbuf_get_width (pixbuf),
7159	gdk_pixbuf_get_height (pixbuf),
7160	0.0, 0.0, /* offsets */
7161	1.0, 1.0, /* scale */
7162	GDK_INTERP_BILINEAR,
7163	255 * alpha,
7164	0, 0, /* check offsets */
7165	0, /* check size */
7166	CDK_COLOR_RGB (bg_color)((guint32) (((int)((bg_color).red * 255) << 16) \| ((int )((bg_color).green * 255) << 8) \| ((int)((bg_color).blue * 255)))),
7167	CDK_COLOR_RGB (bg_color)((guint32) (((int)((bg_color).red * 255) << 16) \| ((int )((bg_color).green * 255) << 8) \| ((int)((bg_color).blue * 255)))));
7168
7169	/* Need to draw background since pixbuf is not
7170	* necessarily covering the whole thing
7171	*/
7172	draw_color_rectangle (widget, drawable, &bg_color, clip,
7173	x, y, width, height);
7174
7175	render_pixbuf_aligned (drawable, clip, composited,
7176	xalign, yalign,
7177	x, y, width, height);
7178
7179	g_object_unref (G_OBJECT (pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((pixbuf)), (((GType) ((20) << (2)))))))));
7180	g_object_unref (G_OBJECT (composited)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((composited)), (((GType) ((20) << (2)))))))));
7181	}
7182	break;
7183
7184	case META_TEXTURE_BLANK:
7185	case META_TEXTURE_COMPOSITE:
7186	case META_TEXTURE_SHAPE_LIST:
7187	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 7187, ( (const char) (__func__)), ((void)0)); } while (0);
7188	break;
7189	}
7190	}
7191
7192	static void
7193	draw_bg_gradient_composite (const MetaTextureSpec *bg,
7194	const MetaTextureSpec *fg,
7195	double alpha,
7196	CtkWidget *widget,
7197	CdkDrawable *drawable,
7198	const CdkRectangle *clip,
7199	MetaTextureDrawMode mode,
7200	double xalign,
7201	double yalign,
7202	int x,
7203	int y,
7204	int width,
7205	int height)
7206	{
7207	g_assert (bg->type == META_TEXTURE_GRADIENT)do { if (bg->type == META_TEXTURE_GRADIENT) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7207, ((const char*) (__func__)), "bg->type == META_TEXTURE_GRADIENT" ); } while (0);
7208	g_assert (fg->type != META_TEXTURE_COMPOSITE)do { if (fg->type != META_TEXTURE_COMPOSITE) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7208, ((const char*) (__func__)), "fg->type != META_TEXTURE_COMPOSITE" ); } while (0);
7209	g_assert (fg->type != META_TEXTURE_SHAPE_LIST)do { if (fg->type != META_TEXTURE_SHAPE_LIST) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7209, ((const char*) (__func__)), "fg->type != META_TEXTURE_SHAPE_LIST" ); } while (0);
7210
7211	switch (fg->type)
7212	{
7213	case META_TEXTURE_SOLID:
7214	case META_TEXTURE_GRADIENT:
7215	case META_TEXTURE_IMAGE:
7216	{
7217	GdkPixbuf *bg_pixbuf;
7218	GdkPixbuf *fg_pixbuf;
7219	GdkPixbuf *composited;
7220	int fg_width, fg_height;
7221
7222	bg_pixbuf = meta_texture_spec_render (bg, widget, mode, 255,
7223	width, height);
7224
7225	if (bg_pixbuf == NULL((void*)0))
7226	return;
7227
7228	fg_pixbuf = meta_texture_spec_render (fg, widget, mode, 255,
7229	width, height);
7230
7231	if (fg_pixbuf == NULL((void*)0))
7232	{
7233	g_object_unref (G_OBJECT (bg_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((bg_pixbuf)), (((GType) ((20) << (2)))))))));
7234	return;
7235	}
7236
7237	/* gradients always fill the entire target area */
7238	g_assert (gdk_pixbuf_get_width (bg_pixbuf) == width)do { if (gdk_pixbuf_get_width (bg_pixbuf) == width) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7238, ((const char*) (__func__)), "gdk_pixbuf_get_width (bg_pixbuf) == width" ); } while (0);
7239	g_assert (gdk_pixbuf_get_height (bg_pixbuf) == height)do { if (gdk_pixbuf_get_height (bg_pixbuf) == height) ; else g_assertion_message_expr ("croma", "ui/theme.c", 7239, ((const char*) (__func__)), "gdk_pixbuf_get_height (bg_pixbuf) == height" ); } while (0);
7240
7241	composited = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
7242	gdk_pixbuf_get_has_alpha (bg_pixbuf), 8,
7243	gdk_pixbuf_get_width (bg_pixbuf),
7244	gdk_pixbuf_get_height (bg_pixbuf));
7245
7246	if (composited == NULL((void*)0))
7247	{
7248	g_object_unref (G_OBJECT (bg_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((bg_pixbuf)), (((GType) ((20) << (2)))))))));
7249	g_object_unref (G_OBJECT (fg_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((fg_pixbuf)), (((GType) ((20) << (2)))))))));
7250	return;
7251	}
7252
7253	fg_width = gdk_pixbuf_get_width (fg_pixbuf);
7254	fg_height = gdk_pixbuf_get_height (fg_pixbuf);
7255
7256	/* If we wanted to be all cool we could deal with the
7257	* offsets and try to composite only in the clip rectangle,
7258	* but I just don't care enough to figure it out.
7259	*/
7260
7261	gdk_pixbuf_composite (fg_pixbuf,
7262	composited,
7263	x + (width - fg_width) * xalign,
7264	y + (height - fg_height) * yalign,
7265	gdk_pixbuf_get_width (fg_pixbuf),
7266	gdk_pixbuf_get_height (fg_pixbuf),
7267	0.0, 0.0, /* offsets */
7268	1.0, 1.0, /* scale */
7269	GDK_INTERP_BILINEAR,
7270	255 * alpha);
7271
7272	cdk_cairo_set_source_pixbuf (cr, composited, x, y);
7273	cairo_paint (cr);
7274
7275	g_object_unref (G_OBJECT (bg_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((bg_pixbuf)), (((GType) ((20) << (2)))))))));
7276	g_object_unref (G_OBJECT (fg_pixbuf)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((fg_pixbuf)), (((GType) ((20) << (2)))))))));
7277	g_object_unref (G_OBJECT (composited)((((GObject) (void ) g_type_check_instance_cast ((GTypeInstance *) ((composited)), (((GType) ((20) << (2)))))))));
7278	}
7279	break;
7280
7281	case META_TEXTURE_BLANK:
7282	case META_TEXTURE_SHAPE_LIST:
7283	case META_TEXTURE_COMPOSITE:
7284	g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 7284, ( (const char) (__func__)), ((void)0)); } while (0);
7285	break;
7286	}
7287	}
7288	#endif
7289
7290	/**
7291	* Returns the earliest version of the theme format which required support
7292	* for a particular button. (For example, "shade" first appeared in v2, and
7293	* "close" in v1.)
7294	*
7295	* \param type the button type
7296	* \return the number of the theme format
7297	*/
7298	guint
7299	meta_theme_earliest_version_with_button (MetaButtonType type)
7300	{
7301	switch (type)
7302	{
7303	case META_BUTTON_TYPE_CLOSE:
7304	case META_BUTTON_TYPE_MAXIMIZE:
7305	case META_BUTTON_TYPE_MINIMIZE:
7306	case META_BUTTON_TYPE_MENU:
7307	case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
7308	case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
7309	case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
7310	case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
7311	case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
7312	case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
7313	return 1000;
7314
7315	case META_BUTTON_TYPE_SHADE:
7316	case META_BUTTON_TYPE_ABOVE:
7317	case META_BUTTON_TYPE_STICK:
7318	case META_BUTTON_TYPE_UNSHADE:
7319	case META_BUTTON_TYPE_UNABOVE:
7320	case META_BUTTON_TYPE_UNSTICK:
7321	return 2000;
7322
7323	case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
7324	case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
7325	return 3003;
7326
7327	case META_BUTTON_TYPE_APPMENU:
7328	return 3005;
7329
7330	default:
7331	meta_warning("Unknown button %d\n", type);
7332	return 1000;
7333	}
7334	}