+SUBDIRS = libmate libmateui

+

+INCLUDES = \

+ -DMATELOCALEDIR=\""$(prefix)/$(DATADIRNAME)/locale\"" \

+ -DPNP_IDS=\""$(PNP_IDS)"\" \

+ $(WARN_CFLAGS) \

+ $(DISABLE_DEPRECATED) \

+ $(XLIB_CFLAGS) \

+ $(MATE_DESKTOP_CFLAGS)

+

+lib_LTLIBRARIES = libmate-desktop-2.la

+

+noinst_PROGRAMS = test-ditem

+

+libmate_desktop_2_la_SOURCES = \

+ mate-desktop-item.c \

+ mate-desktop-utils.c \

+ mate-desktop-thumbnail.c \

+ mate-thumbnail-pixbuf-utils.c \

+ mate-bg.c \

+ mate-bg-crossfade.c \

+ display-name.c \

+ mate-rr.c \

+ mate-rr-config.c \

+ mate-rr-labeler.c \

+ mate-rr-private.h \

+ edid-parse.c \

+ edid.h \

+ private.h

+

+libmate_desktop_2_la_LIBADD = \

+ $(XLIB_LIBS) \

+ $(MATE_DESKTOP_LIBS)

+

+libmate_desktop_2_la_LDFLAGS = \

+ -version-info $(LT_VERSION) \

+ -no-undefined

+

+test_ditem_SOURCES = \

+ test-ditem.c

+

+test_ditem_LDADD = \

+ libmate-desktop-2.la \

+ $(XLIB_LIBS) \

+ $(MATE_DESKTOP_LIBS)

+

+pkgconfigdir = $(libdir)/pkgconfig

+pkgconfig_DATA = mate-desktop-2.0.pc

+

+pnpdata_DATA_dist = pnp.ids

+if USE_INTERNAL_PNP_IDS

+pnpdatadir = $(datadir)/libmate-desktop

+pnpdata_DATA = pnp.ids

+endif

+

+check:

+ test -s $(top_srcdir)/libmate-desktop/pnp.ids

+

+EXTRA_DIST = \

+ mate-desktop-2.0.pc.in \

+ mate-desktop-2.0-uninstalled.pc.in \

+ $(pnpdata_DATA_dist)

+

+MAINTAINERCLEANFILES = \

+ pnp.ids

+

+-include $(top_srcdir)/git.mk

+/*

+ * Copyright 2007 Red Hat, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * on the rights to use, copy, modify, merge, publish, distribute, sub

+ * license, and/or sell copies of the Software, and to permit persons to whom

+ * the Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL

+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ */

+

+/* Author: Soren Sandmann <[email protected]> */

+

+#include <config.h>

+#include <glib/gi18n-lib.h>

+#include <stdlib.h>

+#include <math.h>

+#include <stdio.h>

+#include <string.h>

+#include <glib.h>

+#include "edid.h"

+

+typedef struct Vendor Vendor;

+

+struct Vendor {

+ const char vendor_id[4];

+ const char vendor_name[28];

+};

+

+/* This list of vendor codes derived from lshw

+ *

+ * http://ezix.org/project/wiki/HardwareLiSter

+ *

+ * Note: we now prefer to use data coming from hwdata (and shipped with

+ * mate-desktop). See

+ * http://git.fedorahosted.org/git/?p=hwdata.git;a=blob_plain;f=pnp.ids;hb=HEAD

+ * All contributions to the list of vendors should go there.

+ */

+static const struct Vendor vendors[] = {

+ {"AIC", "AG Neovo"},

+ {"ACR", "Acer"},

+ {"DEL", "DELL"},

+ {"SAM", "SAMSUNG"},

+ {"SNY", "SONY"},

+ {"SEC", "Epson"},

+ {"WAC", "Wacom"},

+ {"NEC", "NEC"},

+ {"CMO", "CMO"}, /* Chi Mei */

+ {"BNQ", "BenQ"},

+

+ {"ABP", "Advansys"},

+ {"ACC", "Accton"},

+ {"ACE", "Accton"},

+ {"ADP", "Adaptec"},

+ {"ADV", "AMD"},

+ {"AIR", "AIR"},

+ {"AMI", "AMI"},

+ {"ASU", "ASUS"},

+ {"ATI", "ATI"},

+ {"ATK", "Allied Telesyn"},

+ {"AZT", "Aztech"},

+ {"BAN", "Banya"},

+ {"BRI", "Boca Research"},

+ {"BUS", "Buslogic"},

+ {"CCI", "Cache Computers Inc."},

+ {"CHA", "Chase"},

+ {"CMD", "CMD Technology, Inc."},

+ {"COG", "Cogent"},

+ {"CPQ", "Compaq"},

+ {"CRS", "Crescendo"},

+ {"CSC", "Crystal"},

+ {"CSI", "CSI"},

+ {"CTL", "Creative Labs"},

+ {"DBI", "Digi"},

+ {"DEC", "Digital Equipment"},

+ {"DBK", "Databook"},

+ {"EGL", "Eagle Technology"},

+ {"ELS", "ELSA"},

+ {"ESS", "ESS"},

+ {"FAR", "Farallon"},

+ {"FDC", "Future Domain"},

+ {"HWP", "Hewlett-Packard"},

+ {"IBM", "IBM"},

+ {"INT", "Intel"},

+ {"ISA", "Iomega"},

+ {"LEN", "Lenovo"},

+ {"MDG", "Madge"},

+ {"MDY", "Microdyne"},

+ {"MET", "Metheus"},

+ {"MIC", "Micronics"},

+ {"MLX", "Mylex"},

+ {"NVL", "Novell"},

+ {"OLC", "Olicom"},

+ {"PRO", "Proteon"},

+ {"RII", "Racal"},

+ {"RTL", "Realtek"},

+ {"SCM", "SCM"},

+ {"SKD", "SysKonnect"},

+ {"SGI", "SGI"},

+ {"SMC", "SMC"},

+ {"SNI", "Siemens Nixdorf"},

+ {"STL", "Stallion Technologies"},

+ {"SUN", "Sun"},

+ {"SUP", "SupraExpress"},

+ {"SVE", "SVEC"},

+ {"TCC", "Thomas-Conrad"},

+ {"TCI", "Tulip"},

+ {"TCM", "3Com"},

+ {"TCO", "Thomas-Conrad"},

+ {"TEC", "Tecmar"},

+ {"TRU", "Truevision"},

+ {"TOS", "Toshiba"},

+ {"TYN", "Tyan"},

+ {"UBI", "Ungermann-Bass"},

+ {"USC", "UltraStor"},

+ {"VDM", "Vadem"},

+ {"VMI", "Vermont"},

+ {"WDC", "Western Digital"},

+ {"ZDS", "Zeos"},

+

+ /* From http://faydoc.tripod.com/structures/01/0136.htm */

+ {"ACT", "Targa"},

+ {"ADI", "ADI"},

+ {"AOC", "AOC Intl"},

+ {"API", "Acer America"},

+ {"APP", "Apple Computer"},

+ {"ART", "ArtMedia"},

+ {"AST", "AST Research"},

+ {"CPL", "Compal"},

+ {"CTX", "Chuntex Electronic Co."},

+ {"DPC", "Delta Electronics"},

+ {"DWE", "Daewoo"},

+ {"ECS", "ELITEGROUP"},

+ {"EIZ", "EIZO"},

+ {"FCM", "Funai"},

+ {"GSM", "LG Electronics"},

+ {"GWY", "Gateway 2000"},

+ {"HEI", "Hyundai"},

+ {"HIT", "Hitachi"},

+ {"HSL", "Hansol"},

+ {"HTC", "Hitachi"},

+ {"ICL", "Fujitsu ICL"},

+ {"IVM", "Idek Iiyama"},

+ {"KFC", "KFC Computek"},

+ {"LKM", "ADLAS"},

+ {"LNK", "LINK Tech"},

+ {"LTN", "Lite-On"},

+ {"MAG", "MAG InnoVision"},

+ {"MAX", "Maxdata"},

+ {"MEI", "Panasonic"},

+ {"MEL", "Mitsubishi"},

+ {"MIR", "miro"},

+ {"MTC", "MITAC"},

+ {"NAN", "NANAO"},

+ {"NEC", "NEC Tech"},

+ {"NOK", "Nokia"},

+ {"OQI", "OPTIQUEST"},

+ {"PBN", "Packard Bell"},

+ {"PGS", "Princeton"},

+ {"PHL", "Philips"},

+ {"REL", "Relisys"},

+ {"SDI", "Samtron"},

+ {"SMI", "Smile"},

+ {"SPT", "Sceptre"},

+ {"SRC", "Shamrock Technology"},

+ {"STP", "Sceptre"},

+ {"TAT", "Tatung"},

+ {"TRL", "Royal Information Company"},

+ {"TSB", "Toshiba, Inc."},

+ {"UNM", "Unisys"},

+ {"VSC", "ViewSonic"},

+ {"WTC", "Wen Tech"},

+ {"ZCM", "Zenith Data Systems"},

+

+ {"???", "Unknown"},

+};

+

+static GHashTable* pnp_ids = NULL;

+

+static void read_pnp_ids(void)

+{

+ gchar* contents;

+ gchar** lines;

+ gchar* line;

+ gchar* code, *name;

+ gint i;

+

+ if (pnp_ids)

+ return;

+

+ pnp_ids = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);

+

+ if (g_file_get_contents(PNP_IDS, &contents, NULL, NULL))

+ {

+ lines = g_strsplit(contents, "\n", -1);

+

+ for (i = 0; lines[i]; i++)

+ {

+ line = lines[i];

+

+ if (line[3] == '\t')

+ {

+ code = line;

+ line[3] = '\0';

+ name = line + 4;

+ g_hash_table_insert(pnp_ids, code, name);

+ }

+ }

+

+ g_free(lines);

+ g_free(contents);

+ }

+}

+

+

+static const char* find_vendor(const char* code)

+{

+ const char* vendor_name;

+ int i;

+

+ read_pnp_ids();

+

+ vendor_name = g_hash_table_lookup(pnp_ids, code);

+

+ if (vendor_name)

+ return vendor_name;

+

+ for (i = 0; i < sizeof(vendors) / sizeof(vendors[0]); ++i)

+ {

+ const Vendor* v = &(vendors[i]);

+

+ if (strcmp(v->vendor_id, code) == 0)

+ return v->vendor_name;

+ }

+

+ return code;

+}

+

+char* make_display_name(const MonitorInfo* info)

+{

+ const char* vendor;

+ int width_mm, height_mm, inches;

+

+ if (info)

+ {

+ vendor = find_vendor(info->manufacturer_code);

+ }

+ else

+ {

+ /* Translators: "Unknown" here is used to identify a monitor for which

+ * we don't know the vendor. When a vendor is known, the name of the

+ * vendor is used. */

+ vendor = C_("Monitor vendor", "Unknown");

+ }

+

+ if (info && info->width_mm != -1 && info->height_mm)

+ {

+ width_mm = info->width_mm;

+ height_mm = info->height_mm;

+ }

+ else if (info && info->n_detailed_timings)

+ {

+ width_mm = info->detailed_timings[0].width_mm;

+ height_mm = info->detailed_timings[0].height_mm;

+ }

+ else

+ {

+ width_mm = -1;

+ height_mm = -1;

+ }

+

+ if (width_mm != -1 && height_mm != -1)

+ {

+ double d = sqrt (width_mm * width_mm + height_mm * height_mm);

+

+ inches = (int) (d / 25.4 + 0.5);

+ }

+ else

+ {

+ inches = -1;

+ }

+

+ if (inches > 0)

+ {

+ return g_strdup_printf("%s %d\"", vendor, inches);

+ }

+ else

+ {

+ return g_strdup(vendor);

+ }

+}

+/*

+ * Copyright 2007 Red Hat, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * on the rights to use, copy, modify, merge, publish, distribute, sub

+ * license, and/or sell copies of the Software, and to permit persons to whom

+ * the Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL

+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ */

+

+/* Author: Soren Sandmann <[email protected]> */

+

+#include "edid.h"

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+#include <glib.h>

+

+static int get_bit(int in, int bit)

+{

+ return (in & (1 << bit)) >> bit;

+}

+

+static int get_bits(int in, int begin, int end)

+{

+ int mask = (1 << (end - begin + 1)) - 1;

+

+ return (in >> begin) & mask;

+}

+

+static int decode_header(const uchar* edid)

+{

+ if (memcmp(edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)

+ {

+ return TRUE;

+ }

+

+ return FALSE;

+}

+

+static int decode_vendor_and_product_identification(const uchar* edid, MonitorInfo* info)

+{

+ int is_model_year;

+

+ /* Manufacturer Code */

+ info->manufacturer_code[0] = get_bits(edid[0x08], 2, 6);

+ info->manufacturer_code[1] = get_bits(edid[0x08], 0, 1) << 3;

+ info->manufacturer_code[1] |= get_bits(edid[0x09], 5, 7);

+ info->manufacturer_code[2] = get_bits(edid[0x09], 0, 4);

+ info->manufacturer_code[3] = '\0';

+

+ info->manufacturer_code[0] += 'A' - 1;

+ info->manufacturer_code[1] += 'A' - 1;

+ info->manufacturer_code[2] += 'A' - 1;

+

+ /* Product Code */

+ info->product_code = edid[0x0b] << 8 | edid[0x0a];

+

+ /* Serial Number */

+ info->serial_number = edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | edid[0x0f] << 24;

+

+ /* Week and Year */

+ is_model_year = FALSE;

+

+ switch (edid[0x10])

+ {

+ case 0x00:

+ info->production_week = -1;

+ break;

+

+ case 0xff:

+ info->production_week = -1;

+ is_model_year = TRUE;

+ break;

+

+ default:

+ info->production_week = edid[0x10];

+ break;

+ }

+

+ if (is_model_year)

+ {

+ info->production_year = -1;

+ info->model_year = 1990 + edid[0x11];

+ }

+ else

+ {

+ info->production_year = 1990 + edid[0x11];

+ info->model_year = -1;

+ }

+

+ return TRUE;

+}

+

+static int decode_edid_version(const uchar* edid, MonitorInfo* info)

+{

+ info->major_version = edid[0x12];

+ info->minor_version = edid[0x13];

+

+ return TRUE;

+}

+

+static int decode_display_parameters(const uchar* edid, MonitorInfo* info)

+{

+ /* Digital vs Analog */

+ info->is_digital = get_bit(edid[0x14], 7);

+

+ if (info->is_digital)

+ {

+ int bits;

+

+ static const int bit_depth[8] = {

+ -1, 6, 8, 10, 12, 14, 16, -1

+ };

+

+ static const Interface interfaces[6] = {

+ UNDEFINED, DVI, HDMI_A, HDMI_B, MDDI, DISPLAY_PORT

+ };

+

+ bits = get_bits(edid[0x14], 4, 6);

+ info->connector.digital.bits_per_primary = bit_depth[bits];

+

+ bits = get_bits(edid[0x14], 0, 3);

+

+ if (bits <= 5)

+ {

+ info->connector.digital.interface = interfaces[bits];

+ }

+ else

+ {

+ info->connector.digital.interface = UNDEFINED;

+ }

+ }

+ else

+ {

+ int bits = get_bits (edid[0x14], 5, 6);

+

+ static const double levels[][3] = {

+ { 0.7, 0.3, 1.0 },

+ { 0.714, 0.286, 1.0 },

+ { 1.0, 0.4, 1.4 },

+ { 0.7, 0.0, 0.7 },

+ };

+

+ info->connector.analog.video_signal_level = levels[bits][0];

+ info->connector.analog.sync_signal_level = levels[bits][1];

+ info->connector.analog.total_signal_level = levels[bits][2];

+

+ info->connector.analog.blank_to_black = get_bit (edid[0x14], 4);

+

+ info->connector.analog.separate_hv_sync = get_bit (edid[0x14], 3);

+ info->connector.analog.composite_sync_on_h = get_bit (edid[0x14], 2);

+ info->connector.analog.composite_sync_on_green = get_bit (edid[0x14], 1);

+

+ info->connector.analog.serration_on_vsync = get_bit (edid[0x14], 0);

+ }

+

+ /* Screen Size / Aspect Ratio */

+ if (edid[0x15] == 0 && edid[0x16] == 0)

+ {

+ info->width_mm = -1;

+ info->height_mm = -1;

+ info->aspect_ratio = -1.0;

+ }

+ else if (edid[0x16] == 0)

+ {

+ info->width_mm = -1;

+ info->height_mm = -1;

+ info->aspect_ratio = 100.0 / (edid[0x15] + 99);

+ }

+ else if (edid[0x15] == 0)

+ {

+ info->width_mm = -1;

+ info->height_mm = -1;

+ info->aspect_ratio = 100.0 / (edid[0x16] + 99);

+ info->aspect_ratio = 1/info->aspect_ratio; /* portrait */

+ }

+ else

+ {

+ info->width_mm = 10 * edid[0x15];

+ info->height_mm = 10 * edid[0x16];

+ }

+

+ /* Gamma */

+ if (edid[0x17] == 0xFF)

+ info->gamma = -1.0;

+ else

+ info->gamma = (edid[0x17] + 100.0) / 100.0;

+

+ /* Features */

+ info->standby = get_bit(edid[0x18], 7);

+ info->suspend = get_bit(edid[0x18], 6);

+ info->active_off = get_bit(edid[0x18], 5);

+

+ if (info->is_digital)

+ {

+ info->connector.digital.rgb444 = TRUE;

+

+ if (get_bit(edid[0x18], 3))

+ info->connector.digital.ycrcb444 = 1;

+ if (get_bit(edid[0x18], 4))

+ info->connector.digital.ycrcb422 = 1;

+ }

+ else

+ {

+ int bits = get_bits(edid[0x18], 3, 4);

+

+ ColorType color_type[4] = {

+ MONOCHROME, RGB, OTHER_COLOR, UNDEFINED_COLOR

+ };

+

+ info->connector.analog.color_type = color_type[bits];

+ }

+

+ info->srgb_is_standard = get_bit(edid[0x18], 2);

+

+ /* In 1.3 this is called "has preferred timing" */

+ info->preferred_timing_includes_native = get_bit(edid[0x18], 1);

+

+ /* FIXME: In 1.3 this indicates whether the monitor accepts GTF */

+ info->continuous_frequency = get_bit(edid[0x18], 0);

+

+ return TRUE;

+}

+

+static double decode_fraction(int high, int low)

+{

+ double result = 0.0;

+ int i;

+

+ high = (high << 2) | low;

+

+ for (i = 0; i < 10; ++i)

+ {

+ result += get_bit (high, i) * pow (2, i - 10);

+ }

+

+ return result;

+}

+

+static int decode_color_characteristics(const uchar* edid, MonitorInfo* info)

+{

+ info->red_x = decode_fraction(edid[0x1b], get_bits(edid[0x19], 6, 7));

+ info->red_y = decode_fraction(edid[0x1c], get_bits(edid[0x19], 5, 4));

+ info->green_x = decode_fraction(edid[0x1d], get_bits(edid[0x19], 2, 3));

+ info->green_y = decode_fraction(edid[0x1e], get_bits(edid[0x19], 0, 1));

+ info->blue_x = decode_fraction(edid[0x1f], get_bits(edid[0x1a], 6, 7));

+ info->blue_y = decode_fraction(edid[0x20], get_bits(edid[0x1a], 4, 5));

+ info->white_x = decode_fraction(edid[0x21], get_bits(edid[0x1a], 2, 3));

+ info->white_y = decode_fraction(edid[0x22], get_bits(edid[0x1a], 0, 1));

+

+ return TRUE;

+}

+

+static int decode_established_timings(const uchar* edid, MonitorInfo* info)

+{

+ static const Timing established[][8] = {

+ {

+ {800, 600, 60},

+ {800, 600, 56},

+ {640, 480, 75},

+ {640, 480, 72},

+ {640, 480, 67},

+ {640, 480, 60},

+ {720, 400, 88},

+ {720, 400, 70}

+ },

+ {

+ {1280, 1024, 75},

+ {1024, 768, 75},

+ {1024, 768, 70},

+ {1024, 768, 60},

+ {1024, 768, 87},

+ {832, 624, 75},

+ {800, 600, 75},

+ {800, 600, 72}

+ },

+ {

+ {0, 0, 0},

+ {0, 0, 0},

+ {0, 0, 0},

+ {0, 0, 0},

+ {0, 0, 0},

+ {0, 0, 0},

+ {0, 0, 0},

+ {1152, 870, 75}

+ },

+ };

+

+ int i, j, idx;

+

+ idx = 0;

+

+ for (i = 0; i < 3; ++i)

+ {

+ for (j = 0; j < 8; ++j)

+ {

+ int byte = edid[0x23 + i];

+

+ if (get_bit (byte, j) && established[i][j].frequency != 0)

+ {

+ info->established[idx++] = established[i][j];

+ }

+ }

+ }

+

+ return TRUE;

+}

+

+static int decode_standard_timings(const uchar* edid, MonitorInfo* info)

+{

+ int i;

+

+ for (i = 0; i < 8; i++)

+ {

+ int first = edid[0x26 + 2 * i];

+ int second = edid[0x27 + 2 * i];

+

+ if (first != 0x01 && second != 0x01)

+ {

+ int w = 8 * (first + 31);

+ int h;

+

+ switch (get_bits(second, 6, 7))

+ {

+ case 0x00:

+ h = (w / 16) * 10;

+ break;

+ case 0x01:

+ h = (w / 4) * 3;

+ break;

+ case 0x02:

+ h = (w / 5) * 4;

+ break;

+ case 0x03:

+ h = (w / 16) * 9;

+ break;

+ }

+

+ info->standard[i].width = w;

+ info->standard[i].height = h;

+ info->standard[i].frequency = get_bits(second, 0, 5) + 60;

+ }

+ }

+

+ return TRUE;

+}

+

+static void decode_lf_string(const uchar* s, int n_chars, char* result)

+{

+ int i;

+

+ for (i = 0; i < n_chars; ++i)

+ {

+ if (s[i] == 0x0a)

+ {

+ *result++ = '\0';

+ break;

+ }

+ else if (s[i] == 0x00)

+ {

+ /* Convert embedded 0's to spaces */

+ *result++ = ' ';

+ }

+ else

+ {

+ *result++ = s[i];

+ }

+ }

+}

+

+static void decode_display_descriptor(const uchar* desc, MonitorInfo* info)

+{

+ switch (desc[0x03])

+ {

+ case 0xFC:

+ decode_lf_string (desc + 5, 13, info->dsc_product_name);

+ break;

+ case 0xFF:

+ decode_lf_string (desc + 5, 13, info->dsc_serial_number);

+ break;

+ case 0xFE:

+ decode_lf_string (desc + 5, 13, info->dsc_string);

+ break;

+ case 0xFD:

+ /* Range Limits */

+ break;

+ case 0xFB:

+ /* Color Point */

+ break;

+ case 0xFA:

+ /* Timing Identifications */

+ break;

+ case 0xF9:

+ /* Color Management */

+ break;

+ case 0xF8:

+ /* Timing Codes */

+ break;

+ case 0xF7:

+ /* Established Timings */

+ break;

+ case 0x10:

+ break;

+ }

+}

+

+static void decode_detailed_timing(const uchar* timing, DetailedTiming* detailed)

+{

+ int bits;

+

+ StereoType stereo[] = {

+ NO_STEREO, NO_STEREO, FIELD_RIGHT, FIELD_LEFT,

+ TWO_WAY_RIGHT_ON_EVEN, TWO_WAY_LEFT_ON_EVEN,

+ FOUR_WAY_INTERLEAVED, SIDE_BY_SIDE

+ };

+

+ detailed->pixel_clock = (timing[0x00] | timing[0x01] << 8) * 10000;

+ detailed->h_addr = timing[0x02] | ((timing[0x04] & 0xf0) << 4);

+ detailed->h_blank = timing[0x03] | ((timing[0x04] & 0x0f) << 8);

+ detailed->v_addr = timing[0x05] | ((timing[0x07] & 0xf0) << 4);

+ detailed->v_blank = timing[0x06] | ((timing[0x07] & 0x0f) << 8);

+ detailed->h_front_porch = timing[0x08] | get_bits(timing[0x0b], 6, 7) << 8;

+ detailed->h_sync = timing[0x09] | get_bits(timing[0x0b], 4, 5) << 8;

+ detailed->v_front_porch =

+ get_bits (timing[0x0a], 4, 7) | get_bits(timing[0x0b], 2, 3) << 4;

+ detailed->v_sync =

+ get_bits (timing[0x0a], 0, 3) | get_bits(timing[0x0b], 0, 1) << 4;

+ detailed->width_mm = timing[0x0c] | get_bits(timing[0x0e], 4, 7) << 8;

+ detailed->height_mm = timing[0x0d] | get_bits(timing[0x0e], 0, 3) << 8;

+ detailed->right_border = timing[0x0f];

+ detailed->top_border = timing[0x10];

+

+ detailed->interlaced = get_bit(timing[0x11], 7);

+

+ /* Stereo */

+ bits = get_bits (timing[0x11], 5, 6) << 1 | get_bit(timing[0x11], 0);

+ detailed->stereo = stereo[bits];

+

+ /* Sync */

+ bits = timing[0x11];

+

+ detailed->digital_sync = get_bit(bits, 4);

+

+ if (detailed->digital_sync)

+ {

+ detailed->connector.digital.composite = !get_bit(bits, 3);

+

+ if (detailed->connector.digital.composite)

+ {

+ detailed->connector.digital.serrations = get_bit(bits, 2);

+ detailed->connector.digital.negative_vsync = FALSE;

+ }

+ else

+ {

+ detailed->connector.digital.serrations = FALSE;

+ detailed->connector.digital.negative_vsync = !get_bit(bits, 2);

+ }

+

+ detailed->connector.digital.negative_hsync = !get_bit(bits, 0);

+ }

+ else

+ {

+ detailed->connector.analog.bipolar = get_bit(bits, 3);

+ detailed->connector.analog.serrations = get_bit(bits, 2);

+ detailed->connector.analog.sync_on_green = !get_bit(bits, 1);

+ }

+}

+

+static int decode_descriptors(const uchar* edid, MonitorInfo* info)

+{

+ int i;

+ int timing_idx;

+

+ timing_idx = 0;

+

+ for (i = 0; i < 4; ++i)

+ {

+ int index = 0x36 + i * 18;

+

+ if (edid[index + 0] == 0x00 && edid[index + 1] == 0x00)

+ {

+ decode_display_descriptor(edid + index, info);

+ }

+ else

+ {

+ decode_detailed_timing(edid + index, &(info->detailed_timings[timing_idx++]));

+ }

+ }

+

+ info->n_detailed_timings = timing_idx;

+

+ return TRUE;

+}

+

+static void decode_check_sum(const uchar* edid, MonitorInfo* info)

+{

+ int i;

+ uchar check = 0;

+

+ for (i = 0; i < 128; ++i)

+ {

+ check += edid[i];

+ }

+

+ info->checksum = check;

+}

+

+MonitorInfo* decode_edid(const uchar* edid)

+{

+ MonitorInfo* info = g_new0(MonitorInfo, 1);

+

+ decode_check_sum(edid, info);

+

+ if (decode_header(edid) && decode_vendor_and_product_identification(edid, info) && decode_edid_version(edid, info) && decode_display_parameters(edid, info) && decode_color_characteristics(edid, info) && decode_established_timings(edid, info) && decode_standard_timings(edid, info) && decode_descriptors(edid, info))

+ {

+ return info;

+ }

+ else

+ {

+ g_free(info);

+ return NULL;

+ }

+}

+/* edid.h

+ *

+ * Copyright 2007, 2008, Red Hat, Inc.

+ *

+ * This file is part of the Mate Library.

+ *

+ * The Mate Library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License as

+ * published by the Free Software Foundation; either version 2 of the

+ * License, or (at your option) any later version.

+ *

+ * The Mate Library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with the Mate Library; see the file COPYING.LIB. If not,

+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ * Boston, MA 02111-1307, USA.

+ *

+ * Author: Soren Sandmann <[email protected]>

+ */

+

+#ifndef EDID_H

+#define EDID_H

+

+typedef unsigned char uchar;

+typedef struct MonitorInfo MonitorInfo;

+typedef struct Timing Timing;

+typedef struct DetailedTiming DetailedTiming;

+

+typedef enum {

+ UNDEFINED,

+ DVI,

+ HDMI_A,

+ HDMI_B,

+ MDDI,

+ DISPLAY_PORT

+} Interface;

+

+typedef enum {

+ UNDEFINED_COLOR,

+ MONOCHROME,

+ RGB,

+ OTHER_COLOR

+} ColorType;

+

+typedef enum {

+ NO_STEREO,

+ FIELD_RIGHT,

+ FIELD_LEFT,

+ TWO_WAY_RIGHT_ON_EVEN,

+ TWO_WAY_LEFT_ON_EVEN,

+ FOUR_WAY_INTERLEAVED,

+ SIDE_BY_SIDE

+} StereoType;

+

+struct Timing {

+ int width;

+ int height;

+ int frequency;

+};

+

+struct DetailedTiming {

+ int pixel_clock;

+ int h_addr;

+ int h_blank;

+ int h_sync;

+ int h_front_porch;

+ int v_addr;

+ int v_blank;

+ int v_sync;

+ int v_front_porch;

+ int width_mm;

+ int height_mm;

+ int right_border;

+ int top_border;

+ int interlaced;

+ StereoType stereo;

+

+ int digital_sync;

+

+ union {

+ struct {

+ int bipolar;

+ int serrations;

+ int sync_on_green;

+ } analog;

+

+ struct {

+ int composite;

+ int serrations;

+ int negative_vsync;

+ int negative_hsync;

+ } digital;

+ } connector;

+};

+

+struct MonitorInfo {

+ int checksum;

+ char manufacturer_code[4];

+ int product_code;

+ unsigned int serial_number;

+

+ int production_week; /* -1 if not specified */

+ int production_year; /* -1 if not specified */

+ int model_year; /* -1 if not specified */

+

+ int major_version;

+ int minor_version;

+

+ int is_digital;

+

+ union {

+ struct {

+ int bits_per_primary;

+ Interface interface;

+ int rgb444;

+ int ycrcb444;

+ int ycrcb422;

+ } digital;

+

+ struct {

+ double video_signal_level;

+ double sync_signal_level;

+ double total_signal_level;

+

+ int blank_to_black;

+

+ int separate_hv_sync;

+ int composite_sync_on_h;

+ int composite_sync_on_green;

+ int serration_on_vsync;

+ ColorType color_type;

+ } analog;

+ } connector;

+

+ int width_mm; /* -1 if not specified */

+ int height_mm; /* -1 if not specified */

+ double aspect_ratio; /* -1.0 if not specififed */

+

+ double gamma; /* -1.0 if not specified */

+

+ int standby;

+ int suspend;

+ int active_off;

+

+ int srgb_is_standard;

+ int preferred_timing_includes_native;

+ int continuous_frequency;

+

+ double red_x;

+ double red_y;

+ double green_x;

+ double green_y;

+ double blue_x;

+ double blue_y;

+ double white_x;

+ double white_y;

+

+ Timing established[24]; /* Terminated by 0x0x0 */

+ Timing standard[8];

+

+ int n_detailed_timings;

+ DetailedTiming detailed_timings[4];

+ /* If monitor has a preferred

+ * mode, it is the first one

+ * (whether it has, is

+ * determined by the

+ * preferred_timing_includes

+ * bit.

+ */

+

+ /* Optional product description */

+ char dsc_serial_number[14];

+ char dsc_product_name[14];

+ char dsc_string[14]; /* Unspecified ASCII data */

+};

+

+MonitorInfo* decode_edid(const uchar* data);

+char* make_display_name(const MonitorInfo* info);

+

+#endif /* !EDID_H */

+libmate_desktopdir = $(includedir)/mate-desktop-2.0/libmate

+libmate_desktop_HEADERS = \

+ mate-desktop-utils.h \

+ mate-desktop-item.h

+

+-include $(top_srcdir)/git.mk

+/* -*- Mode: C; c-set-style: linux indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

+/* mate-ditem.h - MATE Desktop File Representation

+

+ Copyright (C) 1999, 2000 Red Hat Inc.

+ Copyright (C) 2001 Sid Vicious

+ All rights reserved.

+

+ This file is part of the Mate Library.

+

+ The Mate Library is free software; you can redistribute it and/or

+ modify it under the terms of the GNU Library General Public License as

+ published by the Free Software Foundation; either version 2 of the

+ License, or (at your option) any later version.

+

+ The Mate Library is distributed in the hope that it will be useful,

+ but WITHOUT ANY WARRANTY; without even the implied warranty of

+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ Library General Public License for more details.

+

+ You should have received a copy of the GNU Library General Public

+ License along with the Mate Library; see the file COPYING.LIB. If not,

+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ Boston, MA 02111-1307, USA. */

+/*

+ @NOTATION@

+ */

+

+#ifndef MATE_DITEM_H

+#define MATE_DITEM_H

+

+#include <glib.h>

+#include <glib-object.h>

+

+#include <gdk/gdk.h>

+#include <gtk/gtk.h>

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+typedef enum {

+ MATE_DESKTOP_ITEM_TYPE_NULL = 0 /* This means its NULL, that is, not

+ * set */,

+ MATE_DESKTOP_ITEM_TYPE_OTHER /* This means it's not one of the below

+ strings types, and you must get the

+ Type attribute. */,

+

+ /* These are the standard compliant types: */

+ MATE_DESKTOP_ITEM_TYPE_APPLICATION,

+ MATE_DESKTOP_ITEM_TYPE_LINK,

+ MATE_DESKTOP_ITEM_TYPE_FSDEVICE,

+ MATE_DESKTOP_ITEM_TYPE_MIME_TYPE,

+ MATE_DESKTOP_ITEM_TYPE_DIRECTORY,

+ MATE_DESKTOP_ITEM_TYPE_SERVICE,

+ MATE_DESKTOP_ITEM_TYPE_SERVICE_TYPE

+} MateDesktopItemType;

+

+typedef enum {

+ MATE_DESKTOP_ITEM_UNCHANGED = 0,

+ MATE_DESKTOP_ITEM_CHANGED = 1,

+ MATE_DESKTOP_ITEM_DISAPPEARED = 2

+} MateDesktopItemStatus;

+

+#define MATE_TYPE_DESKTOP_ITEM (mate_desktop_item_get_type ())

+GType mate_desktop_item_get_type (void);

+

+typedef struct _MateDesktopItem MateDesktopItem;

+

+/* standard */

+#define MATE_DESKTOP_ITEM_ENCODING "Encoding" /* string */

+#define MATE_DESKTOP_ITEM_VERSION "Version" /* numeric */

+#define MATE_DESKTOP_ITEM_NAME "Name" /* localestring */

+#define MATE_DESKTOP_ITEM_GENERIC_NAME "GenericName" /* localestring */

+#define MATE_DESKTOP_ITEM_TYPE "Type" /* string */

+#define MATE_DESKTOP_ITEM_FILE_PATTERN "FilePattern" /* regexp(s) */

+#define MATE_DESKTOP_ITEM_TRY_EXEC "TryExec" /* string */

+#define MATE_DESKTOP_ITEM_NO_DISPLAY "NoDisplay" /* boolean */

+#define MATE_DESKTOP_ITEM_COMMENT "Comment" /* localestring */

+#define MATE_DESKTOP_ITEM_EXEC "Exec" /* string */

+#define MATE_DESKTOP_ITEM_ACTIONS "Actions" /* strings */

+#define MATE_DESKTOP_ITEM_ICON "Icon" /* string */

+#define MATE_DESKTOP_ITEM_MINI_ICON "MiniIcon" /* string */

+#define MATE_DESKTOP_ITEM_HIDDEN "Hidden" /* boolean */

+#define MATE_DESKTOP_ITEM_PATH "Path" /* string */

+#define MATE_DESKTOP_ITEM_TERMINAL "Terminal" /* boolean */

+#define MATE_DESKTOP_ITEM_TERMINAL_OPTIONS "TerminalOptions" /* string */

+#define MATE_DESKTOP_ITEM_SWALLOW_TITLE "SwallowTitle" /* string */

+#define MATE_DESKTOP_ITEM_SWALLOW_EXEC "SwallowExec" /* string */

+#define MATE_DESKTOP_ITEM_MIME_TYPE "MimeType" /* regexp(s) */

+#define MATE_DESKTOP_ITEM_PATTERNS "Patterns" /* regexp(s) */

+#define MATE_DESKTOP_ITEM_DEFAULT_APP "DefaultApp" /* string */

+#define MATE_DESKTOP_ITEM_DEV "Dev" /* string */

+#define MATE_DESKTOP_ITEM_FS_TYPE "FSType" /* string */

+#define MATE_DESKTOP_ITEM_MOUNT_POINT "MountPoint" /* string */

+#define MATE_DESKTOP_ITEM_READ_ONLY "ReadOnly" /* boolean */

+#define MATE_DESKTOP_ITEM_UNMOUNT_ICON "UnmountIcon" /* string */

+#define MATE_DESKTOP_ITEM_SORT_ORDER "SortOrder" /* strings */

+#define MATE_DESKTOP_ITEM_URL "URL" /* string */

+#define MATE_DESKTOP_ITEM_DOC_PATH "X-MATE-DocPath" /* string */

+

+/* The vfolder proposal */

+#define MATE_DESKTOP_ITEM_CATEGORIES "Categories" /* string */

+#define MATE_DESKTOP_ITEM_ONLY_SHOW_IN "OnlyShowIn" /* string */

+

+typedef enum {

+ /* Use the TryExec field to determine if this should be loaded */

+ MATE_DESKTOP_ITEM_LOAD_ONLY_IF_EXISTS = 1<<0,

+ MATE_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS = 1<<1

+} MateDesktopItemLoadFlags;

+

+typedef enum {

+ /* Never launch more instances even if the app can only

+ * handle one file and we have passed many */

+ MATE_DESKTOP_ITEM_LAUNCH_ONLY_ONE = 1<<0,

+ /* Use current directory instead of home directory */

+ MATE_DESKTOP_ITEM_LAUNCH_USE_CURRENT_DIR = 1<<1,

+ /* Append the list of URIs to the command if no Exec

+ * parameter is specified, instead of launching the

+ * app without parameters. */

+ MATE_DESKTOP_ITEM_LAUNCH_APPEND_URIS = 1<<2,

+ /* Same as above but instead append local paths */

+ MATE_DESKTOP_ITEM_LAUNCH_APPEND_PATHS = 1<<3,

+ /* Don't automatically reap child process. */

+ MATE_DESKTOP_ITEM_LAUNCH_DO_NOT_REAP_CHILD = 1<<4

+} MateDesktopItemLaunchFlags;

+

+typedef enum {

+ /* Don't check the kde directories */

+ MATE_DESKTOP_ITEM_ICON_NO_KDE = 1<<0

+} MateDesktopItemIconFlags;

+

+typedef enum {

+ MATE_DESKTOP_ITEM_ERROR_NO_FILENAME /* No filename set or given on save */,

+ MATE_DESKTOP_ITEM_ERROR_UNKNOWN_ENCODING /* Unknown encoding of the file */,

+ MATE_DESKTOP_ITEM_ERROR_CANNOT_OPEN /* Cannot open file */,

+ MATE_DESKTOP_ITEM_ERROR_NO_EXEC_STRING /* Cannot launch due to no execute string */,

+ MATE_DESKTOP_ITEM_ERROR_BAD_EXEC_STRING /* Cannot launch due to bad execute string */,

+ MATE_DESKTOP_ITEM_ERROR_NO_URL /* No URL on a url entry*/,

+ MATE_DESKTOP_ITEM_ERROR_NOT_LAUNCHABLE /* Not a launchable type of item */,

+ MATE_DESKTOP_ITEM_ERROR_INVALID_TYPE /* Not of type application/x-mate-app-info */

+} MateDesktopItemError;

+

+/* Note that functions can also return the G_FILE_ERROR_* errors */

+

+#define MATE_DESKTOP_ITEM_ERROR mate_desktop_item_error_quark ()

+GQuark mate_desktop_item_error_quark (void);

+

+/* Returned item from new*() and copy() methods have a refcount of 1 */

+MateDesktopItem * mate_desktop_item_new (void);

+MateDesktopItem * mate_desktop_item_new_from_file (const char *file,

+ MateDesktopItemLoadFlags flags,

+ GError **error);

+MateDesktopItem * mate_desktop_item_new_from_uri (const char *uri,

+ MateDesktopItemLoadFlags flags,

+ GError **error);

+MateDesktopItem * mate_desktop_item_new_from_string (const char *uri,

+ const char *string,

+ gssize length,

+ MateDesktopItemLoadFlags flags,

+ GError **error);

+MateDesktopItem * mate_desktop_item_new_from_basename (const char *basename,

+ MateDesktopItemLoadFlags flags,

+ GError **error);

+MateDesktopItem * mate_desktop_item_copy (const MateDesktopItem *item);

+

+/* if under is NULL save in original location */

+gboolean mate_desktop_item_save (MateDesktopItem *item,

+ const char *under,

+ gboolean force,

+ GError **error);

+MateDesktopItem * mate_desktop_item_ref (MateDesktopItem *item);

+void mate_desktop_item_unref (MateDesktopItem *item);

+int mate_desktop_item_launch (const MateDesktopItem *item,

+ GList *file_list,

+ MateDesktopItemLaunchFlags flags,

+ GError **error);

+int mate_desktop_item_launch_with_env (const MateDesktopItem *item,

+ GList *file_list,

+ MateDesktopItemLaunchFlags flags,

+ char **envp,

+ GError **error);

+

+int mate_desktop_item_launch_on_screen (const MateDesktopItem *item,

+ GList *file_list,

+ MateDesktopItemLaunchFlags flags,

+ GdkScreen *screen,

+ int workspace,

+ GError **error);

+

+/* A list of files or urls dropped onto an icon */

+int mate_desktop_item_drop_uri_list (const MateDesktopItem *item,

+ const char *uri_list,

+ MateDesktopItemLaunchFlags flags,

+ GError **error);

+

+int mate_desktop_item_drop_uri_list_with_env (const MateDesktopItem *item,

+ const char *uri_list,

+ MateDesktopItemLaunchFlags flags,

+ char **envp,

+ GError **error);

+

+gboolean mate_desktop_item_exists (const MateDesktopItem *item);

+

+MateDesktopItemType mate_desktop_item_get_entry_type (const MateDesktopItem *item);

+/* You could also just use the set_string on the TYPE argument */

+void mate_desktop_item_set_entry_type (MateDesktopItem *item,

+ MateDesktopItemType type);

+

+/* Get current location on disk */

+const char * mate_desktop_item_get_location (const MateDesktopItem *item);

+void mate_desktop_item_set_location (MateDesktopItem *item,

+ const char *location);

+void mate_desktop_item_set_location_file (MateDesktopItem *item,

+ const char *file);

+MateDesktopItemStatus mate_desktop_item_get_file_status (const MateDesktopItem *item);

+

+/*

+ * Get the icon, this is not as simple as getting the Icon attr as it actually tries to find

+ * it and returns %NULL if it can't

+ */

+char * mate_desktop_item_get_icon (const MateDesktopItem *item,

+ GtkIconTheme *icon_theme);

+

+char * mate_desktop_item_find_icon (GtkIconTheme *icon_theme,

+ const char *icon,

+ /* size is only a suggestion */

+ int desired_size,

+ int flags);

+

+

+/*

+ * Reading/Writing different sections, NULL is the standard section

+ */

+gboolean mate_desktop_item_attr_exists (const MateDesktopItem *item,

+ const char *attr);

+

+/*

+ * String type

+ */

+const char * mate_desktop_item_get_string (const MateDesktopItem *item,

+ const char *attr);

+

+void mate_desktop_item_set_string (MateDesktopItem *item,

+ const char *attr,

+ const char *value);

+

+const char * mate_desktop_item_get_attr_locale (const MateDesktopItem *item,

+ const char *attr);

+

+/*

+ * LocaleString type

+ */

+const char * mate_desktop_item_get_localestring (const MateDesktopItem *item,

+ const char *attr);

+const char * mate_desktop_item_get_localestring_lang (const MateDesktopItem *item,

+ const char *attr,

+ const char *language);

+/* use g_list_free only */

+GList * mate_desktop_item_get_languages (const MateDesktopItem *item,

+ const char *attr);

+

+void mate_desktop_item_set_localestring (MateDesktopItem *item,

+ const char *attr,

+ const char *value);

+void mate_desktop_item_set_localestring_lang (MateDesktopItem *item,

+ const char *attr,

+ const char *language,

+ const char *value);

+void mate_desktop_item_clear_localestring(MateDesktopItem *item,

+ const char *attr);

+

+/*

+ * Strings, Regexps types

+ */

+

+/* use mate_desktop_item_free_string_list */

+char ** mate_desktop_item_get_strings (const MateDesktopItem *item,

+ const char *attr);

+

+void mate_desktop_item_set_strings (MateDesktopItem *item,

+ const char *attr,

+ char **strings);

+

+/*

+ * Boolean type

+ */

+gboolean mate_desktop_item_get_boolean (const MateDesktopItem *item,

+ const char *attr);

+

+void mate_desktop_item_set_boolean (MateDesktopItem *item,

+ const char *attr,

+ gboolean value);

+

+/*

+ * Xserver time of user action that caused the application launch to start.

+ */

+void mate_desktop_item_set_launch_time (MateDesktopItem *item,

+ guint32 timestamp);

+

+/*

+ * Clearing attributes

+ */

+#define mate_desktop_item_clear_attr(item,attr) \

+ mate_desktop_item_set_string(item,attr,NULL)

+void mate_desktop_item_clear_section (MateDesktopItem *item,

+ const char *section);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* MATE_DITEM_H */

+/* -*- Mode: C; c-set-style: linux indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

+/* mate-ditem.h - Utilities for the MATE Desktop

+

+ Copyright (C) 1998 Tom Tromey

+ All rights reserved.

+

+ This file is part of the Mate Library.

+

+ The Mate Library is free software; you can redistribute it and/or

+ modify it under the terms of the GNU Library General Public License as

+ published by the Free Software Foundation; either version 2 of the

+ License, or (at your option) any later version.

+

+ The Mate Library is distributed in the hope that it will be useful,

+ but WITHOUT ANY WARRANTY; without even the implied warranty of

+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ Library General Public License for more details.

+

+ You should have received a copy of the GNU Library General Public

+ License along with the Mate Library; see the file COPYING.LIB. If not,

+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ Boston, MA 02111-1307, USA. */

+/*

+ @NOTATION@

+ */

+

+#ifndef MATE_DESKTOP_UTILS_H

+#define MATE_DESKTOP_UTILS_H

+

+#ifndef MATE_DESKTOP_USE_UNSTABLE_API

+#error mate-desktop-utils is unstable API. You must define MATE_DESKTOP_USE_UNSTABLE_API before including mate-desktop-utils.h

+#endif

+

+#include <glib.h>

+#include <glib-object.h>

+

+#include <gdk/gdk.h>

+#include <gtk/gtk.h>

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/* prepend the terminal command to a vector */

+void mate_desktop_prepend_terminal_to_vector (int *argc, char ***argv);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* MATE_DITEM_H */

+libmateui_desktopdir = $(includedir)/mate-desktop-2.0/libmateui

+libmateui_desktop_HEADERS = \

+ mate-bg.h \

+ mate-bg-crossfade.h \

+ mate-desktop-thumbnail.h \

+ mate-rr.h \

+ mate-rr-config.h \

+ mate-rr-labeler.h

+

+-include $(top_srcdir)/git.mk

+/* mate-bg-crossfade.h - fade window background between two pixmaps

+

+ Copyright 2008, Red Hat, Inc.

+

+ This file is part of the Mate Library.

+

+ The Mate Library is free software; you can redistribute it and/or

+ modify it under the terms of the GNU Library General Public License as

+ published by the Free Software Foundation; either version 2 of the

+ License, or (at your option) any later version.

+

+ The Mate Library is distributed in the hope that it will be useful,

+ but WITHOUT ANY WARRANTY; without even the implied warranty of

+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ Library General Public License for more details.

+

+ You should have received a copy of the GNU Library General Public

+ License along with the Mate Library; see the file COPYING.LIB. If not,

+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ Boston, MA 02111-1307, USA.

+

+ Author: Ray Strode <[email protected]>

+*/

+

+#ifndef __MATE_BG_CROSSFADE_H__

+#define __MATE_BG_CROSSFADE_H__

+

+#ifndef MATE_DESKTOP_USE_UNSTABLE_API

+#error MateBGCrossfade is unstable API. You must define MATE_DESKTOP_USE_UNSTABLE_API before including mate-bg-crossfade.h

+#endif

+

+#include <gdk/gdk.h>

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#define MATE_TYPE_BG_CROSSFADE (mate_bg_crossfade_get_type ())

+#define MATE_BG_CROSSFADE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MATE_TYPE_BG_CROSSFADE, MateBGCrossfade))

+#define MATE_BG_CROSSFADE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MATE_TYPE_BG_CROSSFADE, MateBGCrossfadeClass))

+#define MATE_IS_BG_CROSSFADE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MATE_TYPE_BG_CROSSFADE))

+#define MATE_IS_BG_CROSSFADE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MATE_TYPE_BG_CROSSFADE))

+#define MATE_BG_CROSSFADE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MATE_TYPE_BG_CROSSFADE, MateBGCrossfadeClass))

+

+typedef struct _MateBGCrossfadePrivate MateBGCrossfadePrivate;

+typedef struct _MateBGCrossfade MateBGCrossfade;

+typedef struct _MateBGCrossfadeClass MateBGCrossfadeClass;

+

+struct _MateBGCrossfade

+{

+ GObject parent_object;

+

+ MateBGCrossfadePrivate *priv;

+};

+

+struct _MateBGCrossfadeClass

+{

+ GObjectClass parent_class;

+

+ void (* finished) (MateBGCrossfade *fade, GdkWindow *window);

+};

+

+GType mate_bg_crossfade_get_type (void);

+MateBGCrossfade *mate_bg_crossfade_new (int width, int height);

+gboolean mate_bg_crossfade_set_start_pixmap (MateBGCrossfade *fade,

+ GdkPixmap *pixmap);

+gboolean mate_bg_crossfade_set_end_pixmap (MateBGCrossfade *fade,

+ GdkPixmap *pixmap);

+void mate_bg_crossfade_start (MateBGCrossfade *fade,

+ GdkWindow *window);

+gboolean mate_bg_crossfade_is_started (MateBGCrossfade *fade);

+void mate_bg_crossfade_stop (MateBGCrossfade *fade);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+/* mate-bg.h -

+

+ Copyright 2007, Red Hat, Inc.

+

+ This file is part of the Mate Library.

+

+ The Mate Library is free software; you can redistribute it and/or

+ modify it under the terms of the GNU Library General Public License as

+ published by the Free Software Foundation; either version 2 of the

+ License, or (at your option) any later version.

+

+ The Mate Library is distributed in the hope that it will be useful,

+ but WITHOUT ANY WARRANTY; without even the implied warranty of

+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ Library General Public License for more details.

+

+ You should have received a copy of the GNU Library General Public

+ License along with the Mate Library; see the file COPYING.LIB. If not,

+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ Boston, MA 02111-1307, USA.

+

+ Author: Soren Sandmann <[email protected]>

+*/

+

+#ifndef __MATE_BG_H__

+#define __MATE_BG_H__

+

+#ifndef MATE_DESKTOP_USE_UNSTABLE_API

+#error MateBG is unstable API. You must define MATE_DESKTOP_USE_UNSTABLE_API before including mate-bg.h

+#endif

+

+#include <gdk/gdk.h>

+#include <mateconf/mateconf-client.h>

+#include <libmateui/mate-desktop-thumbnail.h>

+#include <libmateui/mate-bg-crossfade.h>

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#define MATE_TYPE_BG (mate_bg_get_type ())

+#define MATE_BG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MATE_TYPE_BG, MateBG))

+#define MATE_BG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MATE_TYPE_BG, MateBGClass))

+#define MATE_IS_BG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MATE_TYPE_BG))

+#define MATE_IS_BG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MATE_TYPE_BG))

+#define MATE_BG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MATE_TYPE_BG, MateBGClass))

+

+#define MATE_BG_KEY_DIR "/desktop/mate/background"

+

+typedef struct _MateBG MateBG;

+typedef struct _MateBGClass MateBGClass;

+

+typedef enum {

+ MATE_BG_COLOR_SOLID,

+ MATE_BG_COLOR_H_GRADIENT,

+ MATE_BG_COLOR_V_GRADIENT

+} MateBGColorType;

+

+typedef enum {

+ MATE_BG_PLACEMENT_TILED,

+ MATE_BG_PLACEMENT_ZOOMED,

+ MATE_BG_PLACEMENT_CENTERED,

+ MATE_BG_PLACEMENT_SCALED,

+ MATE_BG_PLACEMENT_FILL_SCREEN,

+ MATE_BG_PLACEMENT_SPANNED

+} MateBGPlacement;

+

+GType mate_bg_get_type (void);

+MateBG * mate_bg_new (void);

+void mate_bg_load_from_preferences (MateBG *bg,

+ MateConfClient *client);

+void mate_bg_save_to_preferences (MateBG *bg,

+ MateConfClient *client);

+/* Setters */

+void mate_bg_set_filename (MateBG *bg,

+ const char *filename);

+void mate_bg_set_placement (MateBG *bg,

+ MateBGPlacement placement);

+void mate_bg_set_color (MateBG *bg,

+ MateBGColorType type,

+ GdkColor *primary,

+ GdkColor *secondary);

+/* Getters */

+MateBGPlacement mate_bg_get_placement (MateBG *bg);

+void mate_bg_get_color (MateBG *bg,

+ MateBGColorType *type,

+ GdkColor *primary,

+ GdkColor *secondary);

+const gchar * mate_bg_get_filename (MateBG *bg);

+

+/* Drawing and thumbnailing */

+void mate_bg_draw (MateBG *bg,

+ GdkPixbuf *dest,

+ GdkScreen *screen,

+ gboolean is_root);

+GdkPixmap * mate_bg_create_pixmap (MateBG *bg,

+ GdkWindow *window,

+ int width,

+ int height,

+ gboolean root);

+gboolean mate_bg_get_image_size (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ int best_width,

+ int best_height,

+ int *width,

+ int *height);

+GdkPixbuf * mate_bg_create_thumbnail (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ GdkScreen *screen,

+ int dest_width,

+ int dest_height);

+gboolean mate_bg_is_dark (MateBG *bg,

+ int dest_width,

+ int dest_height);

+gboolean mate_bg_has_multiple_sizes (MateBG *bg);

+gboolean mate_bg_changes_with_time (MateBG *bg);

+GdkPixbuf * mate_bg_create_frame_thumbnail (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ GdkScreen *screen,

+ int dest_width,

+ int dest_height,

+ int frame_num);

+

+/* Set a pixmap as root - not a MateBG method. At some point

+ * if we decide to stabilize the API then we may want to make

+ * these object methods, drop mate_bg_create_pixmap, etc.

+ */

+void mate_bg_set_pixmap_as_root (GdkScreen *screen,

+ GdkPixmap *pixmap);

+

+MateBGCrossfade *mate_bg_set_pixmap_as_root_with_crossfade (GdkScreen *screen,

+ GdkPixmap *pixmap);

+GdkPixmap *mate_bg_get_pixmap_from_root (GdkScreen *screen);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+/*

+ * mate-thumbnail.h: Utilities for handling thumbnails

+ *

+ * Copyright (C) 2002 Red Hat, Inc.

+ *

+ * This file is part of the Mate Library.

+ *

+ * The Mate Library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License as

+ * published by the Free Software Foundation; either version 2 of the

+ * License, or (at your option) any later version.

+ *

+ * The Mate Library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with the Mate Library; see the file COPYING.LIB. If not,

+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ * Boston, MA 02111-1307, USA.

+ *

+ * Author: Alexander Larsson <[email protected]>

+ */

+

+#ifndef MATE_DESKTOP_THUMBNAIL_H

+#define MATE_DESKTOP_THUMBNAIL_H

+

+#ifndef MATE_DESKTOP_USE_UNSTABLE_API

+#error MateDesktopThumbnail is unstable API. You must define MATE_DESKTOP_USE_UNSTABLE_API before including mate-desktop-thumbnail.h

+#endif

+

+#include <glib.h>

+#include <glib-object.h>

+#include <time.h>

+#include <gdk-pixbuf/gdk-pixbuf.h>

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+typedef enum {

+ MATE_DESKTOP_THUMBNAIL_SIZE_NORMAL,

+ MATE_DESKTOP_THUMBNAIL_SIZE_LARGE

+} MateDesktopThumbnailSize;

+

+#define MATE_DESKTOP_TYPE_THUMBNAIL_FACTORY (mate_desktop_thumbnail_factory_get_type ())

+#define MATE_DESKTOP_THUMBNAIL_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MATE_DESKTOP_TYPE_THUMBNAIL_FACTORY, MateDesktopThumbnailFactory))

+#define MATE_DESKTOP_THUMBNAIL_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MATE_DESKTOP_TYPE_THUMBNAIL_FACTORY, MateDesktopThumbnailFactoryClass))

+#define MATE_DESKTOP_IS_THUMBNAIL_FACTORY(obj) (G_TYPE_INSTANCE_CHECK_TYPE ((obj), MATE_DESKTOP_TYPE_THUMBNAIL_FACTORY))

+#define MATE_DESKTOP_IS_THUMBNAIL_FACTORY_CLASS(klass) (G_TYPE_CLASS_CHECK_CLASS_TYPE ((klass), MATE_DESKTOP_TYPE_THUMBNAIL_FACTORY))

+

+typedef struct _MateDesktopThumbnailFactory MateDesktopThumbnailFactory;

+typedef struct _MateDesktopThumbnailFactoryClass MateDesktopThumbnailFactoryClass;

+typedef struct _MateDesktopThumbnailFactoryPrivate MateDesktopThumbnailFactoryPrivate;

+

+struct _MateDesktopThumbnailFactory {

+ GObject parent;

+

+ MateDesktopThumbnailFactoryPrivate *priv;

+};

+

+struct _MateDesktopThumbnailFactoryClass {

+ GObjectClass parent;

+};

+

+GType mate_desktop_thumbnail_factory_get_type (void);

+MateDesktopThumbnailFactory *mate_desktop_thumbnail_factory_new (MateDesktopThumbnailSize size);

+

+char * mate_desktop_thumbnail_factory_lookup (MateDesktopThumbnailFactory *factory,

+ const char *uri,

+ time_t mtime);

+

+gboolean mate_desktop_thumbnail_factory_has_valid_failed_thumbnail (MateDesktopThumbnailFactory *factory,

+ const char *uri,

+ time_t mtime);

+gboolean mate_desktop_thumbnail_factory_can_thumbnail (MateDesktopThumbnailFactory *factory,

+ const char *uri,

+ const char *mime_type,

+ time_t mtime);

+GdkPixbuf * mate_desktop_thumbnail_factory_generate_thumbnail (MateDesktopThumbnailFactory *factory,

+ const char *uri,

+ const char *mime_type);

+void mate_desktop_thumbnail_factory_save_thumbnail (MateDesktopThumbnailFactory *factory,

+ GdkPixbuf *thumbnail,

+ const char *uri,

+ time_t original_mtime);

+void mate_desktop_thumbnail_factory_create_failed_thumbnail (MateDesktopThumbnailFactory *factory,

+ const char *uri,

+ time_t mtime);

+

+

+/* Thumbnailing utils: */

+gboolean mate_desktop_thumbnail_has_uri (GdkPixbuf *pixbuf,

+ const char *uri);

+gboolean mate_desktop_thumbnail_is_valid (GdkPixbuf *pixbuf,

+ const char *uri,

+ time_t mtime);

+char * mate_desktop_thumbnail_md5 (const char *uri);

+char * mate_desktop_thumbnail_path_for_uri (const char *uri,

+ MateDesktopThumbnailSize size);

+

+

+/* Pixbuf utils */

+

+GdkPixbuf *mate_desktop_thumbnail_scale_down_pixbuf (GdkPixbuf *pixbuf,

+ int dest_width,

+ int dest_height);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* MATE_DESKTOP_THUMBNAIL_H */

+/* mate-rr-config.h

+ *

+ * Copyright 2007, 2008, Red Hat, Inc.

+ *

+ * This file is part of the Mate Library.

+ *

+ * The Mate Library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License as

+ * published by the Free Software Foundation; either version 2 of the

+ * License, or (at your option) any later version.

+ *

+ * The Mate Library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with the Mate Library; see the file COPYING.LIB. If not,

+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ * Boston, MA 02111-1307, USA.

+ *

+ * Author: Soren Sandmann <[email protected]>

+ */

+#ifndef MATE_RR_CONFIG_H

+#define MATE_RR_CONFIG_H

+

+#ifndef MATE_DESKTOP_USE_UNSTABLE_API

+#error mate-rr-config.h is unstable API. You must define MATE_DESKTOP_USE_UNSTABLE_API before including mate-rr-config.h

+#endif

+

+#include <libmateui/mate-rr.h>

+#include <glib.h>

+

+typedef struct MateOutputInfo MateOutputInfo;

+typedef struct MateRRConfig MateRRConfig;

+

+/* FIXME:

+ *

+ * This structure is a Frankenstein monster where all of the fields

+ * are generated by the system, but some of them can be changed by

+ * the client.

+ */

+

+struct MateOutputInfo

+{

+ char * name;

+

+ gboolean on; /* whether there is a CRTC assigned to this output (i.e. a signal is being sent to it) */

+ int width;

+ int height;

+ int rate;

+ int x;

+ int y;

+ MateRRRotation rotation;

+

+ gboolean connected; /* whether the output is physically connected to a monitor */

+ char vendor[4];

+ guint product;

+ guint serial;

+ double aspect;

+ int pref_width;

+ int pref_height;

+ char * display_name;

+ gboolean primary;

+

+ gpointer user_data;

+};

+

+struct MateRRConfig

+{

+ /* "clone" means that at least two outputs are at (0, 0) offset and they

+ * have the same width/height. Those outputs are of course connected and on

+ * (i.e. they have a CRTC assigned).

+ */

+ gboolean clone;

+

+ MateOutputInfo ** outputs;

+};

+

+MateRRConfig *mate_rr_config_new_current (MateRRScreen *screen);

+MateRRConfig *mate_rr_config_new_stored (MateRRScreen *screen,

+ GError **error);

+void mate_rr_config_free (MateRRConfig *configuration);

+gboolean mate_rr_config_match (MateRRConfig *config1,

+ MateRRConfig *config2);

+gboolean mate_rr_config_equal (MateRRConfig *config1,

+ MateRRConfig *config2);

+gboolean mate_rr_config_save (MateRRConfig *configuration,

+ GError **error);

+void mate_rr_config_sanitize (MateRRConfig *configuration);

+

+#ifndef MATE_DISABLE_DEPRECATED

+gboolean mate_rr_config_apply (MateRRConfig *configuration,

+ MateRRScreen *screen,

+ GError **error);

+#endif

+

+gboolean mate_rr_config_apply_with_time (MateRRConfig *configuration,

+ MateRRScreen *screen,

+ guint32 timestamp,

+ GError **error);

+

+#ifndef MATE_DISABLE_DEPRECATED

+gboolean mate_rr_config_apply_stored (MateRRScreen *screen,

+ GError **error);

+#endif

+

+#ifndef MATE_DISABLE_DEPRECATED

+gboolean mate_rr_config_apply_from_filename (MateRRScreen *screen,

+ const char *filename,

+ GError **error);

+#endif

+

+gboolean mate_rr_config_apply_from_filename_with_time (MateRRScreen *screen,

+ const char *filename,

+ guint32 timestamp,

+ GError **error);

+

+gboolean mate_rr_config_applicable (MateRRConfig *configuration,

+ MateRRScreen *screen,

+ GError **error);

+

+char *mate_rr_config_get_backup_filename (void);

+char *mate_rr_config_get_intended_filename (void);

+

+/* A utility function that isn't really in the spirit of this file, but I don't

+ * don't know a better place for it.

+ */

+MateRRMode **mate_rr_create_clone_modes (MateRRScreen *screen);

+

+#endif

+/* mate-rr-labeler.h - Utility to label monitors to identify them

+ * while they are being configured.

+ *

+ * Copyright 2008, Novell, Inc.

+ *

+ * This file is part of the Mate Library.

+ *

+ * The Mate Library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License as

+ * published by the Free Software Foundation; either version 2 of the

+ * License, or (at your option) any later version.

+ *

+ * The Mate Library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with the Mate Library; see the file COPYING.LIB. If not,

+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ * Boston, MA 02111-1307, USA.

+ *

+ * Author: Federico Mena-Quintero <[email protected]>

+ */

+

+#ifndef MATE_RR_LABELER_H

+#define MATE_RR_LABELER_H

+

+#ifndef MATE_DESKTOP_USE_UNSTABLE_API

+#error MateRR is unstable API. You must define MATE_DESKTOP_USE_UNSTABLE_API before including materr.h

+#endif

+

+#include <libmateui/mate-rr-config.h>

+

+#define MATE_TYPE_RR_LABELER (mate_rr_labeler_get_type ())

+#define MATE_RR_LABELER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MATE_TYPE_RR_LABELER, MateRRLabeler))

+#define MATE_RR_LABELER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MATE_TYPE_RR_LABELER, MateRRLabelerClass))

+#define MATE_IS_RR_LABELER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MATE_TYPE_RR_LABELER))

+#define MATE_IS_RR_LABELER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MATE_TYPE_RR_LABELER))

+#define MATE_RR_LABELER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MATE_TYPE_RR_LABELER, MateRRLabelerClass))

+

+typedef struct _MateRRLabeler MateRRLabeler;

+typedef struct _MateRRLabelerClass MateRRLabelerClass;

+

+GType mate_rr_labeler_get_type (void);

+

+MateRRLabeler *mate_rr_labeler_new (MateRRConfig *config);

+

+void mate_rr_labeler_hide (MateRRLabeler *labeler);

+

+void mate_rr_labeler_get_color_for_output (MateRRLabeler *labeler, MateOutputInfo *output, GdkColor *color_out);

+

+#endif

+/* randrwrap.h

+ *

+ * Copyright 2007, 2008, Red Hat, Inc.

+ *

+ * This file is part of the Mate Library.

+ *

+ * The Mate Library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License as

+ * published by the Free Software Foundation; either version 2 of the

+ * License, or (at your option) any later version.

+ *

+ * The Mate Library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with the Mate Library; see the file COPYING.LIB. If not,

+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ * Boston, MA 02111-1307, USA.

+ *

+ * Author: Soren Sandmann <[email protected]>

+ */

+#ifndef RANDR_WRAP_H

+#define RANDR_WRAP_H

+

+#ifndef MATE_DESKTOP_USE_UNSTABLE_API

+#error MateRR is unstable API. You must define MATE_DESKTOP_USE_UNSTABLE_API before including materr.h

+#endif

+

+#include <glib.h>

+#include <gdk/gdk.h>

+

+typedef struct MateRRScreen MateRRScreen;

+typedef struct MateRROutput MateRROutput;

+typedef struct MateRRCrtc MateRRCrtc;

+typedef struct MateRRMode MateRRMode;

+

+typedef void (* MateRRScreenChanged) (MateRRScreen *screen, gpointer data);

+

+typedef enum

+{

+ MATE_RR_ROTATION_0 = (1 << 0),

+ MATE_RR_ROTATION_90 = (1 << 1),

+ MATE_RR_ROTATION_180 = (1 << 2),

+ MATE_RR_ROTATION_270 = (1 << 3),

+ MATE_RR_REFLECT_X = (1 << 4),

+ MATE_RR_REFLECT_Y = (1 << 5)

+} MateRRRotation;

+

+/* Error codes */

+

+#define MATE_RR_ERROR (mate_rr_error_quark ())

+

+GQuark mate_rr_error_quark (void);

+

+typedef enum {

+ MATE_RR_ERROR_UNKNOWN, /* generic "fail" */

+ MATE_RR_ERROR_NO_RANDR_EXTENSION, /* RANDR extension is not present */

+ MATE_RR_ERROR_RANDR_ERROR, /* generic/undescribed error from the underlying XRR API */

+ MATE_RR_ERROR_BOUNDS_ERROR, /* requested bounds of a CRTC are outside the maximum size */

+ MATE_RR_ERROR_CRTC_ASSIGNMENT, /* could not assign CRTCs to outputs */

+ MATE_RR_ERROR_NO_MATCHING_CONFIG, /* none of the saved configurations matched the current configuration */

+} MateRRError;

+

+#define MATE_RR_CONNECTOR_TYPE_PANEL "Panel" /* This is a laptop's built-in LCD */

+

+/* MateRRScreen */

+MateRRScreen * mate_rr_screen_new (GdkScreen *screen,

+ MateRRScreenChanged callback,

+ gpointer data,

+ GError **error);

+void mate_rr_screen_destroy (MateRRScreen *screen);

+MateRROutput **mate_rr_screen_list_outputs (MateRRScreen *screen);

+MateRRCrtc ** mate_rr_screen_list_crtcs (MateRRScreen *screen);

+MateRRMode ** mate_rr_screen_list_modes (MateRRScreen *screen);

+MateRRMode ** mate_rr_screen_list_clone_modes (MateRRScreen *screen);

+void mate_rr_screen_set_size (MateRRScreen *screen,

+ int width,

+ int height,

+ int mm_width,

+ int mm_height);

+MateRRCrtc * mate_rr_screen_get_crtc_by_id (MateRRScreen *screen,

+ guint32 id);

+gboolean mate_rr_screen_refresh (MateRRScreen *screen,

+ GError **error);

+MateRROutput * mate_rr_screen_get_output_by_id (MateRRScreen *screen,

+ guint32 id);

+MateRROutput * mate_rr_screen_get_output_by_name (MateRRScreen *screen,

+ const char *name);

+void mate_rr_screen_get_ranges (MateRRScreen *screen,

+ int *min_width,

+ int *max_width,

+ int *min_height,

+ int *max_height);

+void mate_rr_screen_get_timestamps (MateRRScreen *screen,

+ guint32 *change_timestamp_ret,

+ guint32 *config_timestamp_ret);

+

+void mate_rr_screen_set_primary_output (MateRRScreen *screen,

+ MateRROutput *output);

+

+/* MateRROutput */

+guint32 mate_rr_output_get_id (MateRROutput *output);

+const char * mate_rr_output_get_name (MateRROutput *output);

+gboolean mate_rr_output_is_connected (MateRROutput *output);

+int mate_rr_output_get_size_inches (MateRROutput *output);

+int mate_rr_output_get_width_mm (MateRROutput *outout);

+int mate_rr_output_get_height_mm (MateRROutput *output);

+const guint8 * mate_rr_output_get_edid_data (MateRROutput *output);

+MateRRCrtc ** mate_rr_output_get_possible_crtcs (MateRROutput *output);

+MateRRMode * mate_rr_output_get_current_mode (MateRROutput *output);

+MateRRCrtc * mate_rr_output_get_crtc (MateRROutput *output);

+const char * mate_rr_output_get_connector_type (MateRROutput *output);

+gboolean mate_rr_output_is_laptop (MateRROutput *output);

+void mate_rr_output_get_position (MateRROutput *output,

+ int *x,

+ int *y);

+gboolean mate_rr_output_can_clone (MateRROutput *output,

+ MateRROutput *clone);

+MateRRMode ** mate_rr_output_list_modes (MateRROutput *output);

+MateRRMode * mate_rr_output_get_preferred_mode (MateRROutput *output);

+gboolean mate_rr_output_supports_mode (MateRROutput *output,

+ MateRRMode *mode);

+gboolean mate_rr_output_get_is_primary (MateRROutput *output);

+

+/* MateRRMode */

+guint32 mate_rr_mode_get_id (MateRRMode *mode);

+guint mate_rr_mode_get_width (MateRRMode *mode);

+guint mate_rr_mode_get_height (MateRRMode *mode);

+int mate_rr_mode_get_freq (MateRRMode *mode);

+

+/* MateRRCrtc */

+guint32 mate_rr_crtc_get_id (MateRRCrtc *crtc);

+

+#ifndef MATE_DISABLE_DEPRECATED

+gboolean mate_rr_crtc_set_config (MateRRCrtc *crtc,

+ int x,

+ int y,

+ MateRRMode *mode,

+ MateRRRotation rotation,

+ MateRROutput **outputs,

+ int n_outputs,

+ GError **error);

+#endif

+

+gboolean mate_rr_crtc_set_config_with_time (MateRRCrtc *crtc,

+ guint32 timestamp,

+ int x,

+ int y,

+ MateRRMode *mode,

+ MateRRRotation rotation,

+ MateRROutput **outputs,

+ int n_outputs,

+ GError **error);

+gboolean mate_rr_crtc_can_drive_output (MateRRCrtc *crtc,

+ MateRROutput *output);

+MateRRMode * mate_rr_crtc_get_current_mode (MateRRCrtc *crtc);

+void mate_rr_crtc_get_position (MateRRCrtc *crtc,

+ int *x,

+ int *y);

+MateRRRotation mate_rr_crtc_get_current_rotation (MateRRCrtc *crtc);

+MateRRRotation mate_rr_crtc_get_rotations (MateRRCrtc *crtc);

+gboolean mate_rr_crtc_supports_rotation (MateRRCrtc *crtc,

+ MateRRRotation rotation);

+

+gboolean mate_rr_crtc_get_gamma (MateRRCrtc *crtc,

+ int *size,

+ unsigned short **red,

+ unsigned short **green,

+ unsigned short **blue);

+void mate_rr_crtc_set_gamma (MateRRCrtc *crtc,

+ int size,

+ unsigned short *red,

+ unsigned short *green,

+ unsigned short *blue);

+#endif

+/* mate-bg-crossfade.h - fade window background between two pixmaps

+ *

+ * Copyright (C) 2008 Red Hat, Inc.

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License

+ * as published by the Free Software Foundation; either version 2 of

+ * the License, or (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

+ * 02111-1307, USA.

+ *

+ * Author: Ray Strode <[email protected]>

+*/

+

+#include <string.h>

+#include <math.h>

+#include <stdarg.h>

+

+#include <gio/gio.h>

+

+#include <gdk/gdk.h>

+#include <gdk/gdkx.h>

+#include <X11/Xlib.h>

+#include <X11/Xatom.h>

+#include <gtk/gtk.h>

+

+#include <cairo.h>

+#include <cairo-xlib.h>

+

+#define MATE_DESKTOP_USE_UNSTABLE_API

+#include <libmateui/mate-bg.h>

+#include "libmateui/mate-bg-crossfade.h"

+

+struct _MateBGCrossfadePrivate

+{

+ GdkWindow *window;

+ int width;

+ int height;

+ GdkPixmap *fading_pixmap;

+ GdkPixmap *end_pixmap;

+ gdouble start_time;

+ gdouble total_duration;

+ guint timeout_id;

+ guint is_first_frame : 1;

+};

+

+enum {

+ PROP_0,

+ PROP_WIDTH,

+ PROP_HEIGHT,

+};

+

+enum {

+ FINISHED,

+ NUMBER_OF_SIGNALS

+};

+

+static guint signals[NUMBER_OF_SIGNALS] = { 0 };

+

+G_DEFINE_TYPE (MateBGCrossfade, mate_bg_crossfade, G_TYPE_OBJECT)

+#define MATE_BG_CROSSFADE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o),\

+ MATE_TYPE_BG_CROSSFADE,\

+ MateBGCrossfadePrivate))

+

+static void

+mate_bg_crossfade_set_property (GObject *object,

+ guint property_id,

+ const GValue *value,

+ GParamSpec *pspec)

+{

+ MateBGCrossfade *fade;

+

+ g_assert (MATE_IS_BG_CROSSFADE (object));

+

+ fade = MATE_BG_CROSSFADE (object);

+

+ switch (property_id)

+ {

+ case PROP_WIDTH:

+ fade->priv->width = g_value_get_int (value);

+ break;

+ case PROP_HEIGHT:

+ fade->priv->height = g_value_get_int (value);

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

+ break;

+ }

+}

+

+static void

+mate_bg_crossfade_get_property (GObject *object,

+ guint property_id,

+ GValue *value,

+ GParamSpec *pspec)

+{

+ MateBGCrossfade *fade;

+

+ g_assert (MATE_IS_BG_CROSSFADE (object));

+

+ fade = MATE_BG_CROSSFADE (object);

+

+ switch (property_id)

+ {

+ case PROP_WIDTH:

+ g_value_set_int (value, fade->priv->width);

+ break;

+ case PROP_HEIGHT:

+ g_value_set_int (value, fade->priv->height);

+ break;

+

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

+ break;

+ }

+}

+

+static void

+mate_bg_crossfade_finalize (GObject *object)

+{

+ MateBGCrossfade *fade;

+

+ fade = MATE_BG_CROSSFADE (object);

+

+ mate_bg_crossfade_stop (fade);

+

+ if (fade->priv->fading_pixmap != NULL) {

+ g_object_unref (fade->priv->fading_pixmap);

+ fade->priv->fading_pixmap = NULL;

+ }

+

+ if (fade->priv->end_pixmap != NULL) {

+ g_object_unref (fade->priv->end_pixmap);

+ fade->priv->end_pixmap = NULL;

+ }

+}

+

+static void

+mate_bg_crossfade_class_init (MateBGCrossfadeClass *fade_class)

+{

+ GObjectClass *gobject_class;

+

+ gobject_class = G_OBJECT_CLASS (fade_class);

+

+ gobject_class->get_property = mate_bg_crossfade_get_property;

+ gobject_class->set_property = mate_bg_crossfade_set_property;

+ gobject_class->finalize = mate_bg_crossfade_finalize;

+

+ /**

+ * MateBGCrossfade:width:

+ *

+ * When a crossfade is running, this is width of the fading

+ * pixmap.

+ */

+ g_object_class_install_property (gobject_class,

+ PROP_WIDTH,

+ g_param_spec_int ("width",

+ "Window Width",

+ "Width of window to fade",

+ 0, G_MAXINT, 0,

+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));

+

+ /**

+ * MateBGCrossfade:height:

+ *

+ * When a crossfade is running, this is height of the fading

+ * pixmap.

+ */

+ g_object_class_install_property (gobject_class,

+ PROP_HEIGHT,

+ g_param_spec_int ("height", "Window Height",

+ "Height of window to fade on",

+ 0, G_MAXINT, 0,

+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));

+

+ /**

+ * MateBGCrossfade::finished:

+ * @fade: the #MateBGCrossfade that received the signal

+ * @window: the #GdkWindow the crossfade happend on.

+ *

+ * When a crossfade finishes, @window will have a copy

+ * of the end pixmap as its background, and this signal will

+ * get emitted.

+ */

+ signals[FINISHED] = g_signal_new ("finished",

+ G_OBJECT_CLASS_TYPE (gobject_class),

+ G_SIGNAL_RUN_LAST, 0, NULL, NULL,

+ g_cclosure_marshal_VOID__OBJECT,

+ G_TYPE_NONE, 1, G_TYPE_OBJECT);

+

+ g_type_class_add_private (gobject_class, sizeof (MateBGCrossfadePrivate));

+}

+

+static void

+mate_bg_crossfade_init (MateBGCrossfade *fade)

+{

+ fade->priv = MATE_BG_CROSSFADE_GET_PRIVATE (fade);

+

+ fade->priv->fading_pixmap = NULL;

+ fade->priv->end_pixmap = NULL;

+ fade->priv->timeout_id = 0;

+}

+

+/**

+ * mate_bg_crossfade_new:

+ * @width: The width of the crossfading window

+ * @height: The height of the crossfading window

+ *

+ * Creates a new object to manage crossfading a

+ * window background between two #GdkPixmap drawables.

+ *

+ * Return value: the new #MateBGCrossfade

+ **/

+MateBGCrossfade *

+mate_bg_crossfade_new (int width,

+ int height)

+{

+ GObject *object;

+

+ object = g_object_new (MATE_TYPE_BG_CROSSFADE,

+ "width", width,

+ "height", height, NULL);

+

+ return (MateBGCrossfade *) object;

+}

+

+static GdkPixmap *

+tile_pixmap (GdkPixmap *pixmap,

+ int width,

+ int height)

+{

+ GdkPixmap *copy;

+ cairo_t *cr;

+

+ copy = gdk_pixmap_new (pixmap, width, height, pixmap == NULL? 24 : -1);

+

+ cr = gdk_cairo_create (copy);

+

+ if (pixmap != NULL) {

+ cairo_pattern_t *pattern;

+ gdk_cairo_set_source_pixmap (cr, pixmap, 0.0, 0.0);

+ pattern = cairo_get_source (cr);

+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);

+ } else {

+ GtkStyle *style;

+ style = gtk_widget_get_default_style ();

+ gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]);

+ }

+

+ cairo_paint (cr);

+

+ if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {

+ g_object_unref (copy);

+ copy = NULL;

+ }

+ cairo_destroy (cr);

+

+ return copy;

+}

+

+/**

+ * mate_bg_crossfade_set_start_pixmap:

+ * @fade: a #MateBGCrossfade

+ * @pixmap: The #GdkPixmap to fade from

+ *

+ * Before initiating a crossfade with mate_bg_crossfade_start()

+ * a start and end pixmap have to be set. This function sets

+ * the pixmap shown at the beginning of the crossfade effect.

+ *

+ * Return value: %TRUE if successful, or %FALSE if the pixmap

+ * could not be copied.

+ **/

+gboolean

+mate_bg_crossfade_set_start_pixmap (MateBGCrossfade *fade,

+ GdkPixmap *pixmap)

+{

+ g_return_val_if_fail (MATE_IS_BG_CROSSFADE (fade), FALSE);

+

+ if (fade->priv->fading_pixmap != NULL) {

+ g_object_unref (fade->priv->fading_pixmap);

+ fade->priv->fading_pixmap = NULL;

+ }

+

+ fade->priv->fading_pixmap = tile_pixmap (pixmap,

+ fade->priv->width,

+ fade->priv->height);

+

+ return fade->priv->fading_pixmap != NULL;

+}

+

+static gdouble

+get_current_time (void)

+{

+ const double microseconds_per_second = (double) G_USEC_PER_SEC;

+ double timestamp;

+ GTimeVal now;

+

+ g_get_current_time (&now);

+

+ timestamp = ((microseconds_per_second * now.tv_sec) + now.tv_usec) /

+ microseconds_per_second;

+

+ return timestamp;

+}

+

+/**

+ * mate_bg_crossfade_set_end_pixmap:

+ * @fade: a #MateBGCrossfade

+ * @pixmap: The #GdkPixmap to fade to

+ *

+ * Before initiating a crossfade with mate_bg_crossfade_start()

+ * a start and end pixmap have to be set. This function sets

+ * the pixmap shown at the end of the crossfade effect.

+ *

+ * Return value: %TRUE if successful, or %FALSE if the pixmap

+ * could not be copied.

+ **/

+gboolean

+mate_bg_crossfade_set_end_pixmap (MateBGCrossfade *fade,

+ GdkPixmap *pixmap)

+{

+ g_return_val_if_fail (MATE_IS_BG_CROSSFADE (fade), FALSE);

+

+ if (fade->priv->end_pixmap != NULL) {

+ g_object_unref (fade->priv->end_pixmap);

+ fade->priv->end_pixmap = NULL;

+ }

+

+ fade->priv->end_pixmap = tile_pixmap (pixmap,

+ fade->priv->width,

+ fade->priv->height);

+

+ /* Reset timer in case we're called while animating

+ */

+ fade->priv->start_time = get_current_time ();

+ return fade->priv->end_pixmap != NULL;

+}

+

+static gboolean

+animations_are_disabled (MateBGCrossfade *fade)

+{

+ GtkSettings *settings;

+ GdkScreen *screen;

+ gboolean are_enabled;

+

+ g_assert (fade->priv->window != NULL);

+

+ screen = gdk_drawable_get_screen (fade->priv->window);

+

+ settings = gtk_settings_get_for_screen (screen);

+

+ g_object_get (settings, "gtk-enable-animations", &are_enabled, NULL);

+

+ return !are_enabled;

+}

+

+static void

+draw_background (MateBGCrossfade *fade)

+{

+ if (GDK_WINDOW_TYPE (fade->priv->window) == GDK_WINDOW_ROOT) {

+ GdkDisplay *display;

+ display = gdk_drawable_get_display (fade->priv->window);

+ gdk_window_clear (fade->priv->window);

+ gdk_flush ();

+ } else {

+ gdk_window_invalidate_rect (fade->priv->window, NULL, FALSE);

+ gdk_window_process_updates (fade->priv->window, FALSE);

+ }

+}

+

+static gboolean

+on_tick (MateBGCrossfade *fade)

+{

+ gdouble now, percent_done;

+ cairo_t *cr;

+ cairo_status_t status;

+

+ g_return_val_if_fail (MATE_IS_BG_CROSSFADE (fade), FALSE);

+

+ now = get_current_time ();

+

+ percent_done = (now - fade->priv->start_time) / fade->priv->total_duration;

+ percent_done = CLAMP (percent_done, 0.0, 1.0);

+

+ /* If it's taking a long time to get to the first frame,

+ * then lengthen the duration, so the user will get to see

+ * the effect.

+ */

+ if (fade->priv->is_first_frame && percent_done > .33) {

+ fade->priv->is_first_frame = FALSE;

+ fade->priv->total_duration *= 1.5;

+ return on_tick (fade);

+ }

+

+ if (fade->priv->fading_pixmap == NULL) {

+ return FALSE;

+ }

+

+ if (animations_are_disabled (fade)) {

+ return FALSE;

+ }

+

+ /* We accumulate the results in place for performance reasons.

+ *

+ * This means 1) The fade is exponential, not linear (looks good!)

+ * 2) The rate of fade is not independent of frame rate. Slower machines

+ * will get a slower fade (but never longer than .75 seconds), and

+ * even the fastest machines will get *some* fade because the framerate

+ * is capped.

+ */

+ cr = gdk_cairo_create (fade->priv->fading_pixmap);

+

+ gdk_cairo_set_source_pixmap (cr, fade->priv->end_pixmap,

+ 0.0, 0.0);

+ cairo_paint_with_alpha (cr, percent_done);

+

+ status = cairo_status (cr);

+ cairo_destroy (cr);

+

+ if (status == CAIRO_STATUS_SUCCESS) {

+ draw_background (fade);

+ }

+ return percent_done <= .99;

+}

+

+static void

+on_finished (MateBGCrossfade *fade)

+{

+ if (fade->priv->timeout_id == 0)

+ return;

+

+ g_assert (fade->priv->end_pixmap != NULL);

+

+ gdk_window_set_back_pixmap (fade->priv->window,

+ fade->priv->end_pixmap,

+ FALSE);

+ draw_background (fade);

+

+ g_object_unref (fade->priv->end_pixmap);

+ fade->priv->end_pixmap = NULL;

+

+ g_assert (fade->priv->fading_pixmap != NULL);

+

+ g_object_unref (fade->priv->fading_pixmap);

+ fade->priv->fading_pixmap = NULL;

+

+ fade->priv->timeout_id = 0;

+ g_signal_emit (fade, signals[FINISHED], 0, fade->priv->window);

+}

+

+/**

+ * mate_bg_crossfade_start:

+ * @fade: a #MateBGCrossfade

+ * @window: The #GdkWindow to draw crossfade on

+ *

+ * This function initiates a quick crossfade between two pixmaps on

+ * the background of @window. Before initiating the crossfade both

+ * mate_bg_crossfade_start() and mate_bg_crossfade_end() need to

+ * be called. If animations are disabled, the crossfade is skipped,

+ * and the window background is set immediately to the end pixmap.

+ **/

+void

+mate_bg_crossfade_start (MateBGCrossfade *fade,

+ GdkWindow *window)

+{

+ GSource *source;

+ GMainContext *context;

+

+ g_return_if_fail (MATE_IS_BG_CROSSFADE (fade));

+ g_return_if_fail (window != NULL);

+ g_return_if_fail (fade->priv->fading_pixmap != NULL);

+ g_return_if_fail (fade->priv->end_pixmap != NULL);

+ g_return_if_fail (!mate_bg_crossfade_is_started (fade));

+ g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN);

+

+ source = g_timeout_source_new (1000 / 60.0);

+ g_source_set_callback (source,

+ (GSourceFunc) on_tick,

+ fade,

+ (GDestroyNotify) on_finished);

+ context = g_main_context_default ();

+ fade->priv->timeout_id = g_source_attach (source, context);

+ g_source_unref (source);

+

+ fade->priv->window = window;

+ gdk_window_set_back_pixmap (fade->priv->window,

+ fade->priv->fading_pixmap,

+ FALSE);

+ draw_background (fade);

+

+ fade->priv->is_first_frame = TRUE;

+ fade->priv->total_duration = .75;

+ fade->priv->start_time = get_current_time ();

+}

+

+

+/**

+ * mate_bg_crossfade_is_started:

+ * @fade: a #MateBGCrossfade

+ *

+ * This function reveals whether or not @fade is currently

+ * running on a window. See mate_bg_crossfade_start() for

+ * information on how to initiate a crossfade.

+ *

+ * Return value: %TRUE if fading, or %FALSE if not fading

+ **/

+gboolean

+mate_bg_crossfade_is_started (MateBGCrossfade *fade)

+{

+ g_return_val_if_fail (MATE_IS_BG_CROSSFADE (fade), FALSE);

+

+ return fade->priv->timeout_id != 0;

+}

+

+/**

+ * mate_bg_crossfade_stop:

+ * @fade: a #MateBGCrossfade

+ *

+ * This function stops any in progress crossfades that may be

+ * happening. It's harmless to call this function if @fade is

+ * already stopped.

+ **/

+void

+mate_bg_crossfade_stop (MateBGCrossfade *fade)

+{

+ g_return_if_fail (MATE_IS_BG_CROSSFADE (fade));

+

+ if (!mate_bg_crossfade_is_started (fade))

+ return;

+

+ g_assert (fade->priv->timeout_id != 0);

+ g_source_remove (fade->priv->timeout_id);

+ fade->priv->timeout_id = 0;

+}

+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-

+

+matebg.c: Object for the desktop background.

+

+Copyright (C) 2000 Eazel, Inc.

+Copyright (C) 2007-2008 Red Hat, Inc.

+

+This program is free software; you can redistribute it and/or

+modify it under the terms of the GNU Library General Public License as

+published by the Free Software Foundation; either version 2 of the

+License, or (at your option) any later version.

+

+This program is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+Library General Public License for more details.

+

+You should have received a copy of the GNU Library General Public

+License along with this program; if not, write to the

+Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+Boston, MA 02111-1307, USA.

+

+Derived from eel-background.c and eel-gdk-pixbuf-extensions.c by

+Darin Adler <[email protected]> and Ramiro Estrugo <[email protected]>

+

+Author: Soren Sandmann <[email protected]>

+

+*/

+

+#include <string.h>

+#include <math.h>

+#include <stdarg.h>

+#include <stdlib.h>

+

+#include <gio/gio.h>

+

+#include <gdk/gdkx.h>

+#include <X11/Xlib.h>

+#include <X11/Xatom.h>

+

+#include <cairo.h>

+

+#include <mateconf/mateconf-client.h>

+

+#define MATE_DESKTOP_USE_UNSTABLE_API

+#include <libmateui/mate-bg.h>

+#include <libmateui/mate-bg-crossfade.h>

+

+#define BG_KEY_DRAW_BACKGROUND MATE_BG_KEY_DIR "/draw_background"

+#define BG_KEY_PRIMARY_COLOR MATE_BG_KEY_DIR "/primary_color"

+#define BG_KEY_SECONDARY_COLOR MATE_BG_KEY_DIR "/secondary_color"

+#define BG_KEY_COLOR_TYPE MATE_BG_KEY_DIR "/color_shading_type"

+#define BG_KEY_PICTURE_PLACEMENT MATE_BG_KEY_DIR "/picture_options"

+#define BG_KEY_PICTURE_OPACITY MATE_BG_KEY_DIR "/picture_opacity"

+#define BG_KEY_PICTURE_FILENAME MATE_BG_KEY_DIR "/picture_filename"

+

+/* We keep the large pixbufs around if the next update

+ in the slideshow is less than 60 seconds away */

+#define KEEP_EXPENSIVE_CACHE_SECS 60

+

+typedef struct _SlideShow SlideShow;

+typedef struct _Slide Slide;

+

+struct _Slide {

+ double duration; /* in seconds */

+ gboolean fixed;

+

+ GSList* file1;

+ GSList* file2; /* NULL if fixed is TRUE */

+};

+

+typedef struct _FileSize FileSize;

+struct _FileSize {

+ gint width;

+ gint height;

+

+ char* file;

+};

+

+/* This is the size of the GdkRGB dither matrix, in order to avoid

+ * bad dithering when tiling the gradient

+ */

+#define GRADIENT_PIXMAP_TILE_SIZE 128

+

+typedef struct FileCacheEntry FileCacheEntry;

+#define CACHE_SIZE 4

+

+/*

+ * Implementation of the MateBG class

+ */

+struct _MateBG {

+ GObject parent_instance;

+ char* filename;

+ MateBGPlacement placement;

+ MateBGColorType color_type;

+ GdkColor primary;

+ GdkColor secondary;

+

+ gint last_pixmap_width;

+ gint last_pixmap_height;

+

+ GFileMonitor* file_monitor;

+

+ guint changed_id;

+ guint transitioned_id;

+ guint blow_caches_id;

+

+ /* Cached information, only access through cache accessor functions */

+ SlideShow* slideshow;

+ time_t file_mtime;

+ GdkPixbuf* pixbuf_cache;

+ int timeout_id;

+

+ GList* file_cache;

+};

+

+struct _MateBGClass {

+ GObjectClass parent_class;

+};

+

+enum {

+ CHANGED,

+ TRANSITIONED,

+ N_SIGNALS

+};

+

+static guint signals[N_SIGNALS] = {0};

+

+G_DEFINE_TYPE(MateBG, mate_bg, G_TYPE_OBJECT)

+

+static GdkPixmap* make_root_pixmap(GdkScreen* screen, gint width, gint height);

+

+/* Pixbuf utils */

+static guint32 pixbuf_average_value (GdkPixbuf *pixbuf);

+static GdkPixbuf *pixbuf_scale_to_fit (GdkPixbuf *src,

+ int max_width,

+ int max_height);

+static GdkPixbuf *pixbuf_scale_to_min (GdkPixbuf *src,

+ int min_width,

+ int min_height);

+static void pixbuf_draw_gradient (GdkPixbuf *pixbuf,

+ gboolean horizontal,

+ GdkColor *c1,

+ GdkColor *c2,

+ GdkRectangle *rect);

+static void pixbuf_tile (GdkPixbuf *src,

+ GdkPixbuf *dest);

+static void pixbuf_blend (GdkPixbuf *src,

+ GdkPixbuf *dest,

+ int src_x,

+ int src_y,

+ int width,

+ int height,

+ int dest_x,

+ int dest_y,

+ double alpha);

+

+/* Thumbnail utilities */

+static GdkPixbuf *create_thumbnail_for_filename (MateDesktopThumbnailFactory *factory,

+ const char *filename);

+static gboolean get_thumb_annotations (GdkPixbuf *thumb,

+ int *orig_width,

+ int *orig_height);

+

+/* Cache */

+static GdkPixbuf *get_pixbuf_for_size (MateBG *bg,

+ int width,

+ int height);

+static void clear_cache (MateBG *bg);

+static gboolean is_different (MateBG *bg,

+ const char *filename);

+static time_t get_mtime (const char *filename);

+static GdkPixbuf *create_img_thumbnail (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ GdkScreen *screen,

+ int dest_width,

+ int dest_height,

+ int frame_num);

+static SlideShow * get_as_slideshow (MateBG *bg,

+ const char *filename);

+static Slide * get_current_slide (SlideShow *show,

+ double *alpha);

+static gboolean slideshow_has_multiple_sizes (SlideShow *show);

+

+static SlideShow *read_slideshow_file (const char *filename,

+ GError **err);

+static SlideShow *slideshow_ref (SlideShow *show);

+static void slideshow_unref (SlideShow *show);

+

+static FileSize *find_best_size (GSList *sizes,

+ gint width,

+ gint height);

+

+static void

+color_from_string (const char *string,

+ GdkColor *colorp)

+{

+ /* If all else fails use black */

+ gdk_color_parse ("black", colorp);

+

+ if (!string)

+ return;

+

+ gdk_color_parse (string, colorp);

+}

+

+static char *

+color_to_string (const GdkColor *color)

+{

+ return g_strdup_printf ("#%02x%02x%02x",

+ color->red >> 8,

+ color->green >> 8,

+ color->blue >> 8);

+}

+

+static MateConfEnumStringPair placement_lookup[] = {

+ { MATE_BG_PLACEMENT_CENTERED, "centered" },

+ { MATE_BG_PLACEMENT_FILL_SCREEN, "stretched" },

+ { MATE_BG_PLACEMENT_SCALED, "scaled" },

+ { MATE_BG_PLACEMENT_ZOOMED, "zoom" },

+ { MATE_BG_PLACEMENT_TILED, "wallpaper" },

+ { MATE_BG_PLACEMENT_SPANNED, "spanned" },

+ { 0, NULL }

+};

+

+static MateConfEnumStringPair color_type_lookup[] = {

+ { MATE_BG_COLOR_SOLID, "solid" },

+ { MATE_BG_COLOR_H_GRADIENT, "horizontal-gradient" },

+ { MATE_BG_COLOR_V_GRADIENT, "vertical-gradient" },

+ { 0, NULL }

+};

+

+static void

+color_type_from_string (const char *string,

+ MateBGColorType *color_type)

+{

+ *color_type = MATE_BG_COLOR_SOLID;

+

+ if (string) {

+ mateconf_string_to_enum (color_type_lookup,

+ string, (int *)color_type);

+ }

+}

+

+static const char *

+color_type_to_string (MateBGColorType color_type)

+{

+ return mateconf_enum_to_string (color_type_lookup, color_type);

+}

+

+static void

+placement_from_string (const char *string,

+ MateBGPlacement *placement)

+{

+ *placement = MATE_BG_PLACEMENT_ZOOMED;

+

+ if (string) {

+ mateconf_string_to_enum (placement_lookup,

+ string, (int *)placement);

+ }

+}

+

+static const char *

+placement_to_string (MateBGPlacement placement)

+{

+ return mateconf_enum_to_string (placement_lookup, placement);

+}

+

+static gboolean

+do_changed (MateBG *bg)

+{

+ gboolean ignore_pending_change;

+ bg->changed_id = 0;

+

+ ignore_pending_change =

+ GPOINTER_TO_INT (g_object_get_data (G_OBJECT (bg),

+ "ignore-pending-change"));

+

+ if (!ignore_pending_change) {

+ g_signal_emit (G_OBJECT (bg), signals[CHANGED], 0);

+ }

+

+ return FALSE;

+}

+

+static void

+queue_changed (MateBG *bg)

+{

+ if (bg->changed_id > 0) {

+ g_source_remove (bg->changed_id);

+ }

+

+ /* We unset this here to allow apps to set it if they don't want

+ to get the change event. This is used by caja when it

+ gets the pixmap from the bg (due to a reason other than the changed

+ event). Because if there is no other change after this time the

+ pending changed event will just uselessly cause us to recreate

+ the pixmap. */

+ g_object_set_data (G_OBJECT (bg), "ignore-pending-change",

+ GINT_TO_POINTER (FALSE));

+ bg->changed_id = g_timeout_add_full (G_PRIORITY_LOW,

+ 100,

+ (GSourceFunc)do_changed,

+ bg,

+ NULL);

+}

+

+static gboolean

+do_transitioned (MateBG *bg)

+{

+ bg->transitioned_id = 0;

+

+ if (bg->pixbuf_cache) {

+ g_object_unref (bg->pixbuf_cache);

+ bg->pixbuf_cache = NULL;

+ }

+

+ g_signal_emit (G_OBJECT (bg), signals[TRANSITIONED], 0);

+

+ return FALSE;

+}

+

+static void

+queue_transitioned (MateBG *bg)

+{

+ if (bg->transitioned_id > 0) {

+ g_source_remove (bg->transitioned_id);

+ }

+

+ bg->transitioned_id = g_timeout_add_full (G_PRIORITY_LOW,

+ 100,

+ (GSourceFunc)do_transitioned,

+ bg,

+ NULL);

+}

+

+void

+mate_bg_load_from_preferences (MateBG *bg,

+ MateConfClient *client)

+{

+ char *tmp;

+ char *filename;

+ MateBGColorType ctype;

+ GdkColor c1, c2;

+ MateBGPlacement placement;

+

+ g_return_if_fail (MATE_IS_BG (bg));

+ g_return_if_fail (client != NULL);

+

+ /* Filename */

+ filename = NULL;

+ tmp = mateconf_client_get_string (client, BG_KEY_PICTURE_FILENAME, NULL);

+ if (tmp != NULL && *tmp != '\0') {

+ if (g_utf8_validate (tmp, -1, NULL) &&

+ g_file_test (tmp, G_FILE_TEST_EXISTS)) {

+ filename = g_strdup (tmp);

+ } else {

+ filename = g_filename_from_utf8 (tmp, -1, NULL, NULL, NULL);

+ }

+

+ /* Fall back to default background if filename was set

+ but no longer exists */

+ if (!g_file_test (filename, G_FILE_TEST_EXISTS)) {

+ MateConfValue *default_value;

+

+ g_free (filename);

+ filename = NULL;

+

+ default_value =

+ mateconf_client_get_default_from_schema (client,

+ BG_KEY_PICTURE_FILENAME,

+ NULL);

+ if (default_value != NULL) {

+ filename = g_strdup (mateconf_value_get_string (default_value));

+ mateconf_value_free (default_value);

+ }

+ }

+ }

+ g_free (tmp);

+

+ /* Colors */

+ tmp = mateconf_client_get_string (client, BG_KEY_PRIMARY_COLOR, NULL);

+ color_from_string (tmp, &c1);

+ g_free (tmp);

+

+ tmp = mateconf_client_get_string (client, BG_KEY_SECONDARY_COLOR, NULL);

+ color_from_string (tmp, &c2);

+ g_free (tmp);

+

+ /* Color type */

+ tmp = mateconf_client_get_string (client, BG_KEY_COLOR_TYPE, NULL);

+ color_type_from_string (tmp, &ctype);

+ g_free (tmp);

+

+ /* Placement */

+ tmp = mateconf_client_get_string (client, BG_KEY_PICTURE_PLACEMENT, NULL);

+ placement_from_string (tmp, &placement);

+ g_free (tmp);

+

+ mate_bg_set_color (bg, ctype, &c1, &c2);

+ mate_bg_set_placement (bg, placement);

+ mate_bg_set_filename (bg, filename);

+

+ g_free (filename);

+}

+

+void

+mate_bg_save_to_preferences (MateBG *bg,

+ MateConfClient *client)

+{

+ const char *color_type;

+ const char *placement;

+ const gchar *filename;

+ gchar *primary;

+ gchar *secondary;

+

+ primary = color_to_string (&bg->primary);

+ secondary = color_to_string (&bg->secondary);

+

+ color_type = color_type_to_string (bg->color_type);

+

+ if (bg->filename) {

+ filename = bg->filename;

+ placement = placement_to_string (bg->placement);

+ }

+ else {

+ filename = "(none)";

+ placement = "none";

+ }

+

+ mateconf_client_set_string (client, BG_KEY_PICTURE_FILENAME, filename, NULL);

+ mateconf_client_set_string (client, BG_KEY_PRIMARY_COLOR, primary, NULL);

+ mateconf_client_set_string (client, BG_KEY_SECONDARY_COLOR, secondary, NULL);

+ mateconf_client_set_string (client, BG_KEY_COLOR_TYPE, color_type, NULL);

+ mateconf_client_set_string (client, BG_KEY_PICTURE_PLACEMENT, placement, NULL);

+

+ g_free (primary);

+ g_free (secondary);

+}

+

+

+static void

+mate_bg_init (MateBG *bg)

+{

+}

+

+static void

+mate_bg_dispose (GObject *object)

+{

+ MateBG *bg = MATE_BG (object);

+

+ if (bg->file_monitor) {

+ g_object_unref (bg->file_monitor);

+ bg->file_monitor = NULL;

+ }

+

+ clear_cache (bg);

+

+ G_OBJECT_CLASS (mate_bg_parent_class)->dispose (object);

+}

+

+static void

+mate_bg_finalize (GObject *object)

+{

+ MateBG *bg = MATE_BG (object);

+

+ if (bg->changed_id != 0) {

+ g_source_remove (bg->changed_id);

+ bg->changed_id = 0;

+ }

+

+ if (bg->transitioned_id != 0) {

+ g_source_remove (bg->transitioned_id);

+ bg->transitioned_id = 0;

+ }

+

+ if (bg->blow_caches_id != 0) {

+ g_source_remove (bg->blow_caches_id);

+ bg->blow_caches_id = 0;

+ }

+

+ if (bg->filename) {

+ g_free (bg->filename);

+ bg->filename = NULL;

+ }

+

+ G_OBJECT_CLASS (mate_bg_parent_class)->finalize (object);

+}

+

+static void

+mate_bg_class_init (MateBGClass *klass)

+{

+ GObjectClass *object_class = G_OBJECT_CLASS (klass);

+

+ object_class->dispose = mate_bg_dispose;

+ object_class->finalize = mate_bg_finalize;

+

+ signals[CHANGED] = g_signal_new ("changed",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_LAST,

+ 0,

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+

+ signals[TRANSITIONED] = g_signal_new ("transitioned",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_LAST,

+ 0,

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+}

+

+MateBG *

+mate_bg_new (void)

+{

+ return g_object_new (MATE_TYPE_BG, NULL);

+}

+

+void

+mate_bg_set_color (MateBG *bg,

+ MateBGColorType type,

+ GdkColor *primary,

+ GdkColor *secondary)

+{

+ g_return_if_fail (bg != NULL);

+

+ if (bg->color_type != type ||

+ !gdk_color_equal (&bg->primary, primary) ||

+ (secondary && !gdk_color_equal (&bg->secondary, secondary))) {

+

+ bg->color_type = type;

+ bg->primary = *primary;

+ if (secondary) {

+ bg->secondary = *secondary;

+ }

+

+ queue_changed (bg);

+ }

+}

+

+void

+mate_bg_set_placement (MateBG *bg,

+ MateBGPlacement placement)

+{

+ g_return_if_fail (bg != NULL);

+

+ if (bg->placement != placement) {

+ bg->placement = placement;

+

+ queue_changed (bg);

+ }

+}

+

+MateBGPlacement

+mate_bg_get_placement (MateBG *bg)

+{

+ g_return_val_if_fail (bg != NULL, -1);

+

+ return bg->placement;

+}

+

+void

+mate_bg_get_color (MateBG *bg,

+ MateBGColorType *type,

+ GdkColor *primary,

+ GdkColor *secondary)

+{

+ g_return_if_fail (bg != NULL);

+

+ if (type)

+ *type = bg->color_type;

+

+ if (primary)

+ *primary = bg->primary;

+

+ if (secondary)

+ *secondary = bg->secondary;

+}

+

+const gchar *

+mate_bg_get_filename (MateBG *bg)

+{

+ g_return_val_if_fail (bg != NULL, NULL);

+

+ return bg->filename;

+}

+

+static void

+file_changed (GFileMonitor *file_monitor,

+ GFile *child,

+ GFile *other_file,

+ GFileMonitorEvent event_type,

+ gpointer user_data)

+{

+ MateBG *bg = MATE_BG (user_data);

+

+ clear_cache (bg);

+ queue_changed (bg);

+}

+

+void

+mate_bg_set_filename (MateBG *bg,

+ const char *filename)

+{

+ g_return_if_fail (bg != NULL);

+

+ if (is_different (bg, filename)) {

+ char *tmp = g_strdup (filename);

+

+ g_free (bg->filename);

+

+ bg->filename = tmp;

+ bg->file_mtime = get_mtime (bg->filename);

+

+ if (bg->file_monitor) {

+ g_object_unref (bg->file_monitor);

+ bg->file_monitor = NULL;

+ }

+

+ if (bg->filename) {

+ GFile *f = g_file_new_for_path (bg->filename);

+

+ bg->file_monitor = g_file_monitor_file (f, 0, NULL, NULL);

+ g_signal_connect (bg->file_monitor, "changed",

+ G_CALLBACK (file_changed), bg);

+

+ g_object_unref (f);

+ }

+

+ clear_cache (bg);

+

+ queue_changed (bg);

+ }

+}

+

+static void

+draw_color_area (MateBG *bg,

+ GdkPixbuf *dest,

+ GdkRectangle *rect)

+{

+ guint32 pixel;

+ GdkRectangle extent;

+

+ extent.x = 0;

+ extent.y = 0;

+ extent.width = gdk_pixbuf_get_width (dest);

+ extent.height = gdk_pixbuf_get_height (dest);

+

+ gdk_rectangle_intersect (rect, &extent, rect);

+

+ switch (bg->color_type) {

+ case MATE_BG_COLOR_SOLID:

+ /* not really a big deal to ignore the area of interest */

+ pixel = ((bg->primary.red >> 8) << 24) |

+ ((bg->primary.green >> 8) << 16) |

+ ((bg->primary.blue >> 8) << 8) |

+ (0xff);

+

+ gdk_pixbuf_fill (dest, pixel);

+ break;

+

+ case MATE_BG_COLOR_H_GRADIENT:

+ pixbuf_draw_gradient (dest, TRUE, &(bg->primary), &(bg->secondary), rect);

+ break;

+

+ case MATE_BG_COLOR_V_GRADIENT:

+ pixbuf_draw_gradient (dest, FALSE, &(bg->primary), &(bg->secondary), rect);

+ break;

+

+ default:

+ break;

+ }

+}

+

+static void

+draw_color (MateBG *bg,

+ GdkPixbuf *dest,

+ GdkScreen *screen)

+{

+ GdkRectangle rect;

+ rect.x = 0;

+ rect.y = 0;

+ rect.width = gdk_pixbuf_get_width (dest);

+ rect.height = gdk_pixbuf_get_height (dest);

+ draw_color_area (bg, dest, &rect);

+}

+

+static void

+draw_color_each_monitor (MateBG *bg,

+ GdkPixbuf *dest,

+ GdkScreen *screen)

+{

+ GdkRectangle rect;

+ gint num_monitors;

+ int monitor;

+

+ num_monitors = gdk_screen_get_n_monitors (screen);

+ for (monitor = 0; monitor < num_monitors; monitor++) {

+ gdk_screen_get_monitor_geometry (screen, monitor, &rect);

+ draw_color_area (bg, dest, &rect);

+ }

+}

+

+static GdkPixbuf *

+pixbuf_clip_to_fit (GdkPixbuf *src,

+ int max_width,

+ int max_height)

+{

+ int src_width, src_height;

+ int w, h;

+ int src_x, src_y;

+ GdkPixbuf *pixbuf;

+

+ src_width = gdk_pixbuf_get_width (src);

+ src_height = gdk_pixbuf_get_height (src);

+

+ if (src_width < max_width && src_height < max_height)

+ return g_object_ref (src);

+

+ w = MIN(src_width, max_width);

+ h = MIN(src_height, max_height);

+

+ pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,

+ gdk_pixbuf_get_has_alpha (src),

+ 8, w, h);

+

+ src_x = (src_width - w) / 2;

+ src_y = (src_height - h) / 2;

+ gdk_pixbuf_copy_area (src,

+ src_x, src_y,

+ w, h,

+ pixbuf,

+ 0, 0);

+ return pixbuf;

+}

+

+static GdkPixbuf *

+get_scaled_pixbuf (MateBGPlacement placement,

+ GdkPixbuf *pixbuf,

+ int width, int height,

+ int *x, int *y,

+ int *w, int *h)

+{

+ GdkPixbuf *new;

+

+#if 0

+ g_print ("original_width: %d %d\n",

+ gdk_pixbuf_get_width (pixbuf),

+ gdk_pixbuf_get_height (pixbuf));

+#endif

+

+ switch (placement) {

+ case MATE_BG_PLACEMENT_SPANNED:

+ new = pixbuf_scale_to_fit (pixbuf, width, height);

+ break;

+ case MATE_BG_PLACEMENT_ZOOMED:

+ new = pixbuf_scale_to_min (pixbuf, width, height);

+ break;

+

+ case MATE_BG_PLACEMENT_FILL_SCREEN:

+ new = gdk_pixbuf_scale_simple (pixbuf, width, height,

+ GDK_INTERP_BILINEAR);

+ break;

+

+ case MATE_BG_PLACEMENT_SCALED:

+ new = pixbuf_scale_to_fit (pixbuf, width, height);

+ break;

+

+ case MATE_BG_PLACEMENT_CENTERED:

+ case MATE_BG_PLACEMENT_TILED:

+ default:

+ new = pixbuf_clip_to_fit (pixbuf, width, height);

+ break;

+ }

+

+ *w = gdk_pixbuf_get_width (new);

+ *h = gdk_pixbuf_get_height (new);

+ *x = (width - *w) / 2;

+ *y = (height - *h) / 2;

+

+ return new;

+}

+

+static void

+draw_image_area (MateBGPlacement placement,

+ GdkPixbuf *pixbuf,

+ GdkPixbuf *dest,

+ GdkRectangle *area)

+{

+ int dest_width = area->width;

+ int dest_height = area->height;

+ int x, y, w, h;

+ GdkPixbuf *scaled;

+

+ if (!pixbuf)

+ return;

+

+ scaled = get_scaled_pixbuf (placement, pixbuf, dest_width, dest_height, &x, &y, &w, &h);

+

+ switch (placement) {

+ case MATE_BG_PLACEMENT_TILED:

+ pixbuf_tile (scaled, dest);

+ break;

+ case MATE_BG_PLACEMENT_ZOOMED:

+ case MATE_BG_PLACEMENT_CENTERED:

+ case MATE_BG_PLACEMENT_FILL_SCREEN:

+ case MATE_BG_PLACEMENT_SCALED:

+ pixbuf_blend (scaled, dest, 0, 0, w, h, x + area->x, y + area->y, 1.0);

+ break;

+ case MATE_BG_PLACEMENT_SPANNED:

+ pixbuf_blend (scaled, dest, 0, 0, w, h, x, y, 1.0);

+ break;

+ default:

+ g_assert_not_reached ();

+ break;

+ }

+

+ g_object_unref (scaled);

+}

+

+static void

+draw_image (MateBGPlacement placement,

+ GdkPixbuf *pixbuf,

+ GdkPixbuf *dest)

+{

+ GdkRectangle rect;

+

+ rect.x = 0;

+ rect.y = 0;

+ rect.width = gdk_pixbuf_get_width (dest);

+ rect.height = gdk_pixbuf_get_height (dest);

+

+ draw_image_area (placement, pixbuf, dest, &rect);

+}

+

+static void

+draw_once (MateBG *bg,

+ GdkPixbuf *dest,

+ GdkScreen *screen)

+{

+ GdkRectangle rect;

+ GdkPixbuf *pixbuf;

+

+ rect.x = 0;

+ rect.y = 0;

+ rect.width = gdk_pixbuf_get_width (dest);

+ rect.height = gdk_pixbuf_get_height (dest);

+

+ pixbuf = get_pixbuf_for_size (bg, gdk_pixbuf_get_width (dest), gdk_pixbuf_get_height (dest));

+ if (pixbuf) {

+ draw_image_area (bg->placement,

+ pixbuf,

+ dest,

+ &rect);

+ g_object_unref (pixbuf);

+ }

+}

+

+static void

+draw_each_monitor (MateBG *bg,

+ GdkPixbuf *dest,

+ GdkScreen *screen)

+{

+ GdkRectangle rect;

+ gint num_monitors;

+ int monitor;

+

+ num_monitors = gdk_screen_get_n_monitors (screen);

+ for (monitor = 0; monitor < num_monitors; monitor++) {

+ GdkPixbuf *pixbuf;

+ gdk_screen_get_monitor_geometry (screen, monitor, &rect);

+ pixbuf = get_pixbuf_for_size (bg, rect.width, rect.height);

+ if (pixbuf) {

+ draw_image_area (bg->placement,

+ pixbuf,

+ dest, &rect);

+ g_object_unref (pixbuf);

+ }

+ }

+}

+

+void

+mate_bg_draw (MateBG *bg,

+ GdkPixbuf *dest,

+ GdkScreen *screen,

+ gboolean is_root)

+{

+ if (!bg)

+ return;

+

+ if (is_root && (bg->placement != MATE_BG_PLACEMENT_SPANNED)) {

+ draw_color_each_monitor (bg, dest, screen);

+ draw_each_monitor (bg, dest, screen);

+ } else {

+ draw_color (bg, dest, screen);

+ draw_once (bg, dest, screen);

+ }

+}

+

+gboolean

+mate_bg_has_multiple_sizes (MateBG *bg)

+{

+ SlideShow *show;

+ gboolean ret;

+

+ g_return_val_if_fail (bg != NULL, FALSE);

+

+ ret = FALSE;

+

+ show = get_as_slideshow (bg, bg->filename);

+ if (show) {

+ ret = slideshow_has_multiple_sizes (show);

+ slideshow_unref (show);

+ }

+

+ return ret;

+}

+

+static void

+mate_bg_get_pixmap_size (MateBG *bg,

+ int width,

+ int height,

+ int *pixmap_width,

+ int *pixmap_height)

+{

+ int dummy;

+

+ if (!pixmap_width)

+ pixmap_width = &dummy;

+ if (!pixmap_height)

+ pixmap_height = &dummy;

+

+ *pixmap_width = width;

+ *pixmap_height = height;

+

+ if (!bg->filename) {

+ switch (bg->color_type) {

+ case MATE_BG_COLOR_SOLID:

+ *pixmap_width = 1;

+ *pixmap_height = 1;

+ break;

+

+ case MATE_BG_COLOR_H_GRADIENT:

+ case MATE_BG_COLOR_V_GRADIENT:

+ break;

+ }

+

+ return;

+ }

+}

+

+/**

+ * mate_bg_get_pixmap:

+ * @bg: MateBG

+ * @window:

+ * @width:

+ * @height:

+ *

+ * Create a pixmap that can be set as background for @window. If @root is TRUE,

+ * the pixmap created will be created by a temporary X server connection so

+ * that if someone calls XKillClient on it, it won't affect the application who

+ * created it.

+ *

+ * Since: 2.20

+ **/

+GdkPixmap *

+mate_bg_create_pixmap (MateBG *bg,

+ GdkWindow *window,

+ int width,

+ int height,

+ gboolean is_root)

+{

+ int pm_width, pm_height;

+ GdkPixmap *pixmap;

+ cairo_t *cr;

+

+ g_return_val_if_fail (bg != NULL, NULL);

+ g_return_val_if_fail (window != NULL, NULL);

+

+ if (bg->last_pixmap_width != width ||

+ bg->last_pixmap_height != height) {

+ if (bg->pixbuf_cache) {

+ g_object_unref (bg->pixbuf_cache);

+ bg->pixbuf_cache = NULL;

+ }

+ }

+ bg->last_pixmap_width = width;

+ bg->last_pixmap_height = height;

+

+ /* has the side effect of loading and caching pixbuf only when in tile mode */

+ mate_bg_get_pixmap_size (bg, width, height, &pm_width, &pm_height);

+

+ if (is_root) {

+ pixmap = make_root_pixmap (gdk_drawable_get_screen (window),

+ pm_width, pm_height);

+ }

+ else {

+ pixmap = gdk_pixmap_new (window, pm_width, pm_height, -1);

+ }

+

+ cr = gdk_cairo_create (pixmap);

+ if (!bg->filename && bg->color_type == MATE_BG_COLOR_SOLID) {

+ gdk_cairo_set_source_color (cr, &(bg->primary));

+ }

+ else {

+ GdkPixbuf *pixbuf;

+

+ pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,

+ width, height);

+ mate_bg_draw (bg, pixbuf, gdk_drawable_get_screen (GDK_DRAWABLE (window)), is_root);

+ gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);

+ g_object_unref (pixbuf);

+ }

+

+ cairo_paint (cr);

+

+ cairo_destroy (cr);

+

+ return pixmap;

+}

+

+

+/* determine if a background is darker or lighter than average, to help

+ * clients know what colors to draw on top with

+ */

+gboolean

+mate_bg_is_dark (MateBG *bg,

+ int width,

+ int height)

+{

+ GdkColor color;

+ int intensity;

+ GdkPixbuf *pixbuf;

+

+ g_return_val_if_fail (bg != NULL, FALSE);

+

+ if (bg->color_type == MATE_BG_COLOR_SOLID) {

+ color = bg->primary;

+ } else {

+ color.red = (bg->primary.red + bg->secondary.red) / 2;

+ color.green = (bg->primary.green + bg->secondary.green) / 2;

+ color.blue = (bg->primary.blue + bg->secondary.blue) / 2;

+ }

+ pixbuf = get_pixbuf_for_size (bg, width, height);

+ if (pixbuf) {

+ guint32 argb = pixbuf_average_value (pixbuf);

+ guchar a = (argb >> 24) & 0xff;

+ guchar r = (argb >> 16) & 0xff;

+ guchar g = (argb >> 8) & 0xff;

+ guchar b = (argb >> 0) & 0xff;

+

+ color.red = (color.red * (0xFF - a) + r * 0x101 * a) / 0xFF;

+ color.green = (color.green * (0xFF - a) + g * 0x101 * a) / 0xFF;

+ color.blue = (color.blue * (0xFF - a) + b * 0x101 * a) / 0xFF;

+ g_object_unref (pixbuf);

+ }

+

+ intensity = (color.red * 77 +

+ color.green * 150 +

+ color.blue * 28) >> 16;

+

+ return intensity < 160; /* biased slightly to be dark */

+}

+

+/*

+ * Create a persistent pixmap. We create a separate display

+ * and set the closedown mode on it to RetainPermanent.

+ */

+static GdkPixmap *

+make_root_pixmap (GdkScreen *screen, gint width, gint height)

+{

+ Display *display;

+ const char *display_name;

+ Pixmap result;

+ GdkPixmap *gdk_pixmap;

+ int screen_num;

+ int depth;

+

+ screen_num = gdk_screen_get_number (screen);

+

+ gdk_flush ();

+

+ display_name = gdk_display_get_name (gdk_screen_get_display (screen));

+ display = XOpenDisplay (display_name);

+

+ if (display == NULL) {

+ g_warning ("Unable to open display '%s' when setting "

+ "background pixmap\n",

+ (display_name) ? display_name : "NULL");

+ return NULL;

+ }

+

+ /* Desktop background pixmap should be created from

+ * dummy X client since most applications will try to

+ * kill it with XKillClient later when changing pixmap

+ */

+

+ XSetCloseDownMode (display, RetainPermanent);

+

+ depth = DefaultDepth (display, screen_num);

+

+ result = XCreatePixmap (display,

+ RootWindow (display, screen_num),

+ width, height, depth);

+

+ XCloseDisplay (display);

+

+ gdk_pixmap = gdk_pixmap_foreign_new_for_screen (screen, result,

+ width, height, depth);

+

+ gdk_drawable_set_colormap (

+ GDK_DRAWABLE (gdk_pixmap),

+ gdk_drawable_get_colormap (gdk_screen_get_root_window (screen)));

+

+ return gdk_pixmap;

+}

+

+static gboolean

+get_original_size (const char *filename,

+ int *orig_width,

+ int *orig_height)

+{

+ gboolean result;

+

+ if (gdk_pixbuf_get_file_info (filename, orig_width, orig_height))

+ result = TRUE;

+ else

+ result = FALSE;

+

+ return result;

+}

+

+static const char *

+get_filename_for_size (MateBG *bg, gint best_width, gint best_height)

+{

+ SlideShow *show;

+ Slide *slide;

+ FileSize *size;

+

+ if (!bg->filename)

+ return NULL;

+

+ show = get_as_slideshow (bg, bg->filename);

+ if (!show) {

+ return bg->filename;

+ }

+

+ slide = get_current_slide (show, NULL);

+ slideshow_unref (show);

+ size = find_best_size (slide->file1, best_width, best_height);

+ return size->file;

+}

+

+gboolean

+mate_bg_get_image_size (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ int best_width,

+ int best_height,

+ int *width,

+ int *height)

+{

+ GdkPixbuf *thumb;

+ gboolean result = FALSE;

+ const gchar *filename;

+

+ g_return_val_if_fail (bg != NULL, FALSE);

+ g_return_val_if_fail (factory != NULL, FALSE);

+

+ if (!bg->filename)

+ return FALSE;

+

+ filename = get_filename_for_size (bg, best_width, best_height);

+ thumb = create_thumbnail_for_filename (factory, filename);

+ if (thumb) {

+ if (get_thumb_annotations (thumb, width, height))

+ result = TRUE;

+

+ g_object_unref (thumb);

+ }

+

+ if (!result) {

+ if (get_original_size (filename, width, height))

+ result = TRUE;

+ }

+

+ return result;

+}

+

+static double

+fit_factor (int from_width, int from_height,

+ int to_width, int to_height)

+{

+ return MIN (to_width / (double) from_width, to_height / (double) from_height);

+}

+

+GdkPixbuf *

+mate_bg_create_thumbnail (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ GdkScreen *screen,

+ int dest_width,

+ int dest_height)

+{

+ GdkPixbuf *result;

+ GdkPixbuf *thumb;

+

+ g_return_val_if_fail (bg != NULL, NULL);

+

+ result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, dest_width, dest_height);

+

+ draw_color (bg, result, screen);

+

+ thumb = create_img_thumbnail (bg, factory, screen, dest_width, dest_height, -1);

+

+ if (thumb) {

+ draw_image (bg->placement, thumb, result);

+ g_object_unref (thumb);

+ }

+

+ return result;

+}

+

+/**

+ * mate_bg_get_pixmap_from_root:

+ * @screen: a #GdkScreen

+ *

+ * This function queries the _XROOTPMAP_ID property from

+ * the root window associated with @screen to determine

+ * the current root window background pixmap and returns

+ * a copy of it. If the _XROOTPMAP_ID is not set, then

+ * a black pixmap is returned.

+ *

+ * Return value: a #GdkPixmap if successful or %NULL

+ **/

+GdkPixmap *

+mate_bg_get_pixmap_from_root (GdkScreen *screen)

+{

+ int result;

+ gint format;

+ gulong nitems;

+ gulong bytes_after;

+ guchar *data;

+ Atom type;

+ Display *display;

+ int screen_num;

+ GdkPixmap *pixmap;

+ GdkPixmap *source_pixmap;

+ int width, height;

+ cairo_t *cr;

+ cairo_pattern_t *pattern;

+

+ display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));

+ screen_num = gdk_screen_get_number (screen);

+

+ result = XGetWindowProperty (display,

+ RootWindow (display, screen_num),

+ gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"),

+ 0L, 1L, False, XA_PIXMAP,

+ &type, &format, &nitems, &bytes_after,

+ &data);

+ pixmap = NULL;

+ source_pixmap = NULL;

+

+ if (result != Success || type != XA_PIXMAP ||

+ format != 32 || nitems != 1) {

+ XFree (data);

+ data = NULL;

+ }

+

+ if (data != NULL) {

+ gdk_error_trap_push ();

+ source_pixmap = gdk_pixmap_foreign_new (*(Pixmap *) data);

+ gdk_error_trap_pop ();

+

+ if (source_pixmap != NULL) {

+ gdk_drawable_set_colormap (source_pixmap,

+ gdk_screen_get_default_colormap (screen));

+ }

+ }

+

+ width = gdk_screen_get_width (screen);

+ height = gdk_screen_get_height (screen);

+

+ pixmap = gdk_pixmap_new (source_pixmap != NULL? source_pixmap :

+ gdk_screen_get_root_window (screen),

+ width, height, -1);

+

+ cr = gdk_cairo_create (pixmap);

+ if (source_pixmap != NULL) {

+ gdk_cairo_set_source_pixmap (cr, source_pixmap, 0, 0);

+ pattern = cairo_get_source (cr);

+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);

+ } else {

+ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);

+ }

+ cairo_paint (cr);

+

+ if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {

+ g_object_unref (pixmap);

+ pixmap = NULL;

+ }

+ cairo_destroy (cr);

+

+ if (source_pixmap != NULL)

+ g_object_unref (source_pixmap);

+

+ if (data != NULL)

+ XFree (data);

+

+ return pixmap;

+}

+

+static void

+mate_bg_set_root_pixmap_id (GdkScreen *screen,

+ GdkPixmap *pixmap)

+{

+ int result;

+ gint format;

+ gulong nitems;

+ gulong bytes_after;

+ guchar *data_esetroot;

+ Pixmap pixmap_id;

+ Atom type;

+ Display *display;

+ int screen_num;

+

+ screen_num = gdk_screen_get_number (screen);

+ data_esetroot = NULL;

+

+ display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));

+

+ result = XGetWindowProperty (display,

+ RootWindow (display, screen_num),

+ gdk_x11_get_xatom_by_name ("ESETROOT_PMAP_ID"),

+ 0L, 1L, False, XA_PIXMAP,

+ &type, &format, &nitems,

+ &bytes_after,

+ &data_esetroot);

+

+ if (data_esetroot != NULL) {

+ if (result == Success && type == XA_PIXMAP &&

+ format == 32 &&

+ nitems == 1) {

+ gdk_error_trap_push ();

+ XKillClient (display, *(Pixmap *)data_esetroot);

+ gdk_flush ();

+ gdk_error_trap_pop ();

+ }

+ XFree (data_esetroot);

+ }

+

+ pixmap_id = GDK_WINDOW_XWINDOW (pixmap);

+

+ XChangeProperty (display, RootWindow (display, screen_num),

+ gdk_x11_get_xatom_by_name ("ESETROOT_PMAP_ID"),

+ XA_PIXMAP, 32, PropModeReplace,

+ (guchar *) &pixmap_id, 1);

+ XChangeProperty (display, RootWindow (display, screen_num),

+ gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), XA_PIXMAP,

+ 32, PropModeReplace,

+ (guchar *) &pixmap_id, 1);

+}

+

+/**

+ * mate_bg_set_pixmap_as_root:

+ * @screen: the #GdkScreen to change root background on

+ * @pixmap: the #GdkPixmap to set root background from

+ *

+ * Set the root pixmap, and properties pointing to it. We

+ * do this atomically with a server grab to make sure that

+ * we won't leak the pixmap if somebody else it setting

+ * it at the same time. (This assumes that they follow the

+ * same conventions we do). @pixmap should come from a call

+ * to mate_bg_create_pixmap().

+ **/

+void

+mate_bg_set_pixmap_as_root (GdkScreen *screen, GdkPixmap *pixmap)

+{

+ Display *display;

+ int screen_num;

+

+ g_return_if_fail (screen != NULL);

+ g_return_if_fail (pixmap != NULL);

+

+ screen_num = gdk_screen_get_number (screen);

+

+ display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));

+

+ gdk_x11_display_grab (gdk_screen_get_display (screen));

+

+ mate_bg_set_root_pixmap_id (screen, pixmap);

+

+ XSetWindowBackgroundPixmap (display, RootWindow (display, screen_num),

+ GDK_PIXMAP_XID (pixmap));

+ XClearWindow (display, RootWindow (display, screen_num));

+

+ gdk_display_flush (gdk_screen_get_display (screen));

+ gdk_x11_display_ungrab (gdk_screen_get_display (screen));

+}

+

+/**

+ * mate_bg_set_pixmap_as_root_with_crossfade:

+ * @screen: the #GdkScreen to change root background on

+ * @pixmap: the #GdkPixmap to set root background from

+ * @context: a #GMainContext or %NULL

+ *

+ * Set the root pixmap, and properties pointing to it.

+ * This function differs from mate_bg_set_pixmap_as_root()

+ * in that it adds a subtle crossfade animation from the

+ * current root pixmap to the new one.

+ * same conventions we do).

+ *

+ * Return value: a #MateBGCrossfade object

+ **/

+MateBGCrossfade *

+mate_bg_set_pixmap_as_root_with_crossfade (GdkScreen *screen,

+ GdkPixmap *pixmap)

+{

+ GdkDisplay *display;

+ GdkWindow *root_window;

+ GdkPixmap *old_pixmap;

+ int width, height;

+ MateBGCrossfade *fade;

+

+ g_return_val_if_fail (screen != NULL, NULL);

+ g_return_val_if_fail (pixmap != NULL, NULL);

+

+ root_window = gdk_screen_get_root_window (screen);

+

+ width = gdk_screen_get_width (screen);

+ height = gdk_screen_get_height (screen);

+

+ fade = mate_bg_crossfade_new (width, height);

+

+ display = gdk_screen_get_display (screen);

+ gdk_x11_display_grab (display);

+ old_pixmap = mate_bg_get_pixmap_from_root (screen);

+ mate_bg_set_root_pixmap_id (screen, pixmap);

+ mate_bg_crossfade_set_start_pixmap (fade, old_pixmap);

+ g_object_unref (old_pixmap);

+ mate_bg_crossfade_set_end_pixmap (fade, pixmap);

+ gdk_display_flush (display);

+ gdk_x11_display_ungrab (display);

+

+ mate_bg_crossfade_start (fade, root_window);

+

+ return fade;

+}

+

+/* Implementation of the pixbuf cache */

+struct _SlideShow

+{

+ gint ref_count;

+ double start_time;

+ double total_duration;

+

+ GQueue *slides;

+

+ gboolean has_multiple_sizes;

+

+ /* used during parsing */

+ struct tm start_tm;

+ GQueue *stack;

+};

+

+

+static double

+now (void)

+{

+ GTimeVal tv;

+

+ g_get_current_time (&tv);

+

+ return (double)tv.tv_sec + (tv.tv_usec / 1000000.0);

+}

+

+static Slide *

+get_current_slide (SlideShow *show,

+ double *alpha)

+{

+ double delta = fmod (now() - show->start_time, show->total_duration);

+ GList *list;

+ double elapsed;

+ int i;

+

+ if (delta < 0)

+ delta += show->total_duration;

+

+ elapsed = 0;

+ i = 0;

+ for (list = show->slides->head; list != NULL; list = list->next) {

+ Slide *slide = list->data;

+

+ if (elapsed + slide->duration > delta) {

+ if (alpha)

+ *alpha = (delta - elapsed) / (double)slide->duration;

+ return slide;

+ }

+

+ i++;

+ elapsed += slide->duration;

+ }

+

+ /* this should never happen since we have slides and we should always

+ * find a current slide for the elapsed time since beginning -- we're

+ * looping with fmod() */

+ g_assert_not_reached ();

+

+ return NULL;

+}

+

+static GdkPixbuf *

+blend (GdkPixbuf *p1,

+ GdkPixbuf *p2,

+ double alpha)

+{

+ GdkPixbuf *result = gdk_pixbuf_copy (p1);

+ GdkPixbuf *tmp;

+

+ if (gdk_pixbuf_get_width (p2) != gdk_pixbuf_get_width (p1) ||

+ gdk_pixbuf_get_height (p2) != gdk_pixbuf_get_height (p1)) {

+ tmp = gdk_pixbuf_scale_simple (p2,

+ gdk_pixbuf_get_width (p1),

+ gdk_pixbuf_get_height (p1),

+ GDK_INTERP_BILINEAR);

+ }

+ else {

+ tmp = g_object_ref (p2);

+ }

+

+ pixbuf_blend (tmp, result, 0, 0, -1, -1, 0, 0, alpha);

+

+ g_object_unref (tmp);

+

+ return result;

+}

+

+typedef enum {

+ PIXBUF,

+ SLIDESHOW,

+ THUMBNAIL

+} FileType;

+

+struct FileCacheEntry

+{

+ FileType type;

+ char *filename;

+ union {

+ GdkPixbuf *pixbuf;

+ SlideShow *slideshow;

+ GdkPixbuf *thumbnail;

+ } u;

+};

+

+static void

+file_cache_entry_delete (FileCacheEntry *ent)

+{

+ g_free (ent->filename);

+

+ switch (ent->type) {

+ case PIXBUF:

+ g_object_unref (ent->u.pixbuf);

+ break;

+ case SLIDESHOW:

+ slideshow_unref (ent->u.slideshow);

+ break;

+ case THUMBNAIL:

+ g_object_unref (ent->u.thumbnail);

+ break;

+ }

+

+ g_free (ent);

+}

+

+static void

+bound_cache (MateBG *bg)

+{

+ while (g_list_length (bg->file_cache) >= CACHE_SIZE) {

+ GList *last_link = g_list_last (bg->file_cache);

+ FileCacheEntry *ent = last_link->data;

+

+ file_cache_entry_delete (ent);

+

+ bg->file_cache = g_list_delete_link (bg->file_cache, last_link);

+ }

+}

+

+static const FileCacheEntry *

+file_cache_lookup (MateBG *bg, FileType type, const char *filename)

+{

+ GList *list;

+

+ for (list = bg->file_cache; list != NULL; list = list->next) {

+ FileCacheEntry *ent = list->data;

+

+ if (ent && ent->type == type &&

+ strcmp (ent->filename, filename) == 0) {

+ return ent;

+ }

+ }

+

+ return NULL;

+}

+

+static FileCacheEntry *

+file_cache_entry_new (MateBG *bg,

+ FileType type,

+ const char *filename)

+{

+ FileCacheEntry *ent = g_new0 (FileCacheEntry, 1);

+

+ g_assert (!file_cache_lookup (bg, type, filename));

+

+ ent->type = type;

+ ent->filename = g_strdup (filename);

+

+ bg->file_cache = g_list_prepend (bg->file_cache, ent);

+

+ bound_cache (bg);

+

+ return ent;

+}

+

+static void

+file_cache_add_pixbuf (MateBG *bg,

+ const char *filename,

+ GdkPixbuf *pixbuf)

+{

+ FileCacheEntry *ent = file_cache_entry_new (bg, PIXBUF, filename);

+ ent->u.pixbuf = g_object_ref (pixbuf);

+}

+

+static void

+file_cache_add_thumbnail (MateBG *bg,

+ const char *filename,

+ GdkPixbuf *pixbuf)

+{

+ FileCacheEntry *ent = file_cache_entry_new (bg, THUMBNAIL, filename);

+ ent->u.thumbnail = g_object_ref (pixbuf);

+}

+

+static void

+file_cache_add_slide_show (MateBG *bg,

+ const char *filename,

+ SlideShow *show)

+{

+ FileCacheEntry *ent = file_cache_entry_new (bg, SLIDESHOW, filename);

+ ent->u.slideshow = slideshow_ref (show);

+}

+

+static GdkPixbuf *

+get_as_pixbuf_for_size (MateBG *bg,

+ const char *filename,

+ int best_width,

+ int best_height)

+{

+ const FileCacheEntry *ent;

+ if ((ent = file_cache_lookup (bg, PIXBUF, filename))) {

+ return g_object_ref (ent->u.pixbuf);

+ }

+ else {

+ GdkPixbufFormat *format;

+ GdkPixbuf *pixbuf;

+ gchar *tmp;

+

+ /* If scalable choose maximum size */

+ format = gdk_pixbuf_get_file_info (filename, NULL, NULL);

+ tmp = gdk_pixbuf_format_get_name (format);

+ if (format != NULL &&

+ strcmp (tmp, "svg") == 0 &&

+ (best_width > 0 && best_height > 0) &&

+ (bg->placement == MATE_BG_PLACEMENT_FILL_SCREEN ||

+ bg->placement == MATE_BG_PLACEMENT_SCALED ||

+ bg->placement == MATE_BG_PLACEMENT_ZOOMED))

+ pixbuf = gdk_pixbuf_new_from_file_at_size (filename, best_width, best_height, NULL);

+ else

+ pixbuf = gdk_pixbuf_new_from_file (filename, NULL);

+ g_free (tmp);

+

+ if (pixbuf)

+ file_cache_add_pixbuf (bg, filename, pixbuf);

+

+ return pixbuf;

+ }

+}

+

+static SlideShow *

+get_as_slideshow (MateBG *bg, const char *filename)

+{

+ const FileCacheEntry *ent;

+ if ((ent = file_cache_lookup (bg, SLIDESHOW, filename))) {

+ return slideshow_ref (ent->u.slideshow);

+ }

+ else {

+ SlideShow *show = read_slideshow_file (filename, NULL);

+

+ if (show)

+ file_cache_add_slide_show (bg, filename, show);

+

+ return show;

+ }

+}

+

+static GdkPixbuf *

+get_as_thumbnail (MateBG *bg, MateDesktopThumbnailFactory *factory, const char *filename)

+{

+ const FileCacheEntry *ent;

+ if ((ent = file_cache_lookup (bg, THUMBNAIL, filename))) {

+ return g_object_ref (ent->u.thumbnail);

+ }

+ else {

+ GdkPixbuf *thumb = create_thumbnail_for_filename (factory, filename);

+

+ if (thumb)

+ file_cache_add_thumbnail (bg, filename, thumb);

+

+ return thumb;

+ }

+}

+

+static gboolean

+blow_expensive_caches (gpointer data)

+{

+ MateBG *bg = data;

+ GList *list, *next;

+

+ bg->blow_caches_id = 0;

+

+ for (list = bg->file_cache; list != NULL; list = next) {

+ FileCacheEntry *ent = list->data;

+ next = list->next;

+

+ if (ent->type == PIXBUF) {

+ file_cache_entry_delete (ent);

+ bg->file_cache = g_list_delete_link (bg->file_cache,

+ list);

+ }

+ }

+

+ if (bg->pixbuf_cache) {

+ g_object_unref (bg->pixbuf_cache);

+ bg->pixbuf_cache = NULL;

+ }

+

+ return FALSE;

+}

+

+static void

+blow_expensive_caches_in_idle (MateBG *bg)

+{

+ if (bg->blow_caches_id == 0) {

+ bg->blow_caches_id =

+ g_idle_add (blow_expensive_caches,

+ bg);

+ }

+}

+

+

+static gboolean

+on_timeout (gpointer data)

+{

+ MateBG *bg = data;

+

+ bg->timeout_id = 0;

+

+ queue_transitioned (bg);

+

+ return FALSE;

+}

+

+static double

+get_slide_timeout (Slide *slide)

+{

+ double timeout;

+ if (slide->fixed) {

+ timeout = slide->duration;

+ } else {

+ /* Maybe the number of steps should be configurable? */

+

+ /* In the worst case we will do a fade from 0 to 256, which mean

+ * we will never use more than 255 steps, however in most cases

+ * the first and last value are similar and users can't percieve

+ * changes in pixel values as small as 1/255th. So, lets not waste

+ * CPU cycles on transitioning to often.

+ *

+ * 64 steps is enough for each step to be just detectable in a 16bit

+ * color mode in the worst case, so we'll use this as an approximation

+ * of whats detectable.

+ */

+ timeout = slide->duration / 64.0;

+ }

+ return timeout;

+}

+

+static void

+ensure_timeout (MateBG *bg,

+ Slide *slide)

+{

+ if (!bg->timeout_id) {

+ double timeout = get_slide_timeout (slide);

+ bg->timeout_id = g_timeout_add_full (

+ G_PRIORITY_LOW,

+ timeout * 1000, on_timeout, bg, NULL);

+

+ }

+}

+

+static time_t

+get_mtime (const char *filename)

+{

+ GFile *file;

+ GFileInfo *info;

+ time_t mtime;

+

+ mtime = (time_t)-1;

+

+ if (filename) {

+ file = g_file_new_for_path (filename);

+ info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED,

+ G_FILE_QUERY_INFO_NONE, NULL, NULL);

+ if (info) {

+ mtime = g_file_info_get_attribute_uint64 (info,

+ G_FILE_ATTRIBUTE_TIME_MODIFIED);

+ g_object_unref (info);

+ }

+ g_object_unref (file);

+ }

+

+ return mtime;

+}

+

+static GdkPixbuf *

+scale_thumbnail (MateBGPlacement placement,

+ const char *filename,

+ GdkPixbuf *thumb,

+ GdkScreen *screen,

+ int dest_width,

+ int dest_height)

+{

+ int o_width;

+ int o_height;

+

+ if (placement != MATE_BG_PLACEMENT_TILED &&

+ placement != MATE_BG_PLACEMENT_CENTERED) {

+

+ /* In this case, the pixbuf will be scaled to fit the screen anyway,

+ * so just return the pixbuf here

+ */

+ return g_object_ref (thumb);

+ }

+

+ if (get_thumb_annotations (thumb, &o_width, &o_height) ||

+ (filename && get_original_size (filename, &o_width, &o_height))) {

+

+ int scr_height = gdk_screen_get_height (screen);

+ int scr_width = gdk_screen_get_width (screen);

+ int thumb_width = gdk_pixbuf_get_width (thumb);

+ int thumb_height = gdk_pixbuf_get_height (thumb);

+ double screen_to_dest = fit_factor (scr_width, scr_height,

+ dest_width, dest_height);

+ double thumb_to_orig = fit_factor (thumb_width, thumb_height,

+ o_width, o_height);

+ double f = thumb_to_orig * screen_to_dest;

+ int new_width, new_height;

+

+ new_width = floor (thumb_width * f + 0.5);

+ new_height = floor (thumb_height * f + 0.5);

+

+ if (placement == MATE_BG_PLACEMENT_TILED) {

+ /* Heuristic to make sure tiles don't become so small that

+ * they turn into a blur.

+ *

+ * This is strictly speaking incorrect, but the resulting

+ * thumbnail gives a much better idea what the background

+ * will actually look like.

+ */

+

+ if ((new_width < 32 || new_height < 32) &&

+ (new_width < o_width / 4 || new_height < o_height / 4)) {

+ new_width = o_width / 4;

+ new_height = o_height / 4;

+ }

+ }

+

+ thumb = gdk_pixbuf_scale_simple (thumb, new_width, new_height,

+ GDK_INTERP_BILINEAR);

+ }

+ else

+ g_object_ref (thumb);

+

+ return thumb;

+}

+

+/* frame_num determines which slide to thumbnail.

+ * -1 means 'current slide'.

+ */

+static GdkPixbuf *

+create_img_thumbnail (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ GdkScreen *screen,

+ int dest_width,

+ int dest_height,

+ int frame_num)

+{

+ if (bg->filename) {

+ GdkPixbuf *thumb;

+

+ thumb = get_as_thumbnail (bg, factory, bg->filename);

+

+ if (thumb) {

+ GdkPixbuf *result;

+ result = scale_thumbnail (bg->placement,

+ bg->filename,

+ thumb,

+ screen,

+ dest_width,

+ dest_height);

+ g_object_unref (thumb);

+ return result;

+ }

+ else {

+ SlideShow *show = get_as_slideshow (bg, bg->filename);

+

+ if (show) {

+ double alpha;

+ Slide *slide;

+

+ if (frame_num == -1)

+ slide = get_current_slide (show, &alpha);

+ else

+ slide = g_queue_peek_nth (show->slides, frame_num);

+

+ if (slide->fixed) {

+ GdkPixbuf *tmp;

+ FileSize *fs;

+ fs = find_best_size (slide->file1, dest_width, dest_height);

+ tmp = get_as_thumbnail (bg, factory, fs->file);

+ if (tmp) {

+ thumb = scale_thumbnail (bg->placement,

+ fs->file,

+ tmp,

+ screen,

+ dest_width,

+ dest_height);

+ g_object_unref (tmp);

+ }

+ }

+ else {

+ FileSize *fs1, *fs2;

+ GdkPixbuf *p1, *p2;

+ fs1 = find_best_size (slide->file1, dest_width, dest_height);

+ p1 = get_as_thumbnail (bg, factory, fs1->file);

+

+ fs2 = find_best_size (slide->file2, dest_width, dest_height);

+ p2 = get_as_thumbnail (bg, factory, fs2->file);

+

+ if (p1 && p2) {

+ GdkPixbuf *thumb1, *thumb2;

+

+ thumb1 = scale_thumbnail (bg->placement,

+ fs1->file,

+ p1,

+ screen,

+ dest_width,

+ dest_height);

+

+ thumb2 = scale_thumbnail (bg->placement,

+ fs2->file,

+ p2,

+ screen,

+ dest_width,

+ dest_height);

+

+ thumb = blend (thumb1, thumb2, alpha);

+

+ g_object_unref (thumb1);

+ g_object_unref (thumb2);

+ }

+ if (p1)

+ g_object_unref (p1);

+ if (p2)

+ g_object_unref (p2);

+ }

+

+ ensure_timeout (bg, slide);

+

+ slideshow_unref (show);

+ }

+ }

+

+ return thumb;

+ }

+

+ return NULL;

+}

+

+/*

+ * Find the FileSize that best matches the given size.

+ * Do two passes; the first pass only considers FileSizes

+ * that are larger than the given size.

+ * We are looking for the image that best matches the aspect ratio.

+ * When two images have the same aspect ratio, prefer the one whose

+ * width is closer to the given width.

+ */

+static FileSize *

+find_best_size (GSList *sizes, gint width, gint height)

+{

+ GSList *s;

+ gdouble a, d, distance;

+ FileSize *best = NULL;

+ gint pass;

+

+ a = width/(gdouble)height;

+ distance = 10000.0;

+

+ for (pass = 0; pass < 2; pass++) {

+ for (s = sizes; s; s = s->next) {

+ FileSize *size = s->data;

+

+ if (pass == 0 && (size->width < width || size->height < height))

+ continue;

+

+ d = fabs (a - size->width/(gdouble)size->height);

+ if (d < distance) {

+ distance = d;

+ best = size;

+ }

+ else if (d == distance) {

+ if (abs (size->width - width) < abs (best->width - width)) {

+ best = size;

+ }

+ }

+ }

+

+ if (best)

+ break;

+ }

+

+ return best;

+}

+

+static GdkPixbuf *

+get_pixbuf_for_size (MateBG *bg,

+ gint best_width,

+ gint best_height)

+{

+ guint time_until_next_change;

+ gboolean hit_cache = FALSE;

+

+ /* only hit the cache if the aspect ratio matches */

+ if (bg->pixbuf_cache) {

+ int width, height;

+ width = gdk_pixbuf_get_width (bg->pixbuf_cache);

+ height = gdk_pixbuf_get_height (bg->pixbuf_cache);

+ hit_cache = 0.2 > fabs ((best_width / (double)best_height) - (width / (double)height));

+ if (!hit_cache) {

+ g_object_unref (bg->pixbuf_cache);

+ bg->pixbuf_cache = NULL;

+ }

+ }

+

+ if (!hit_cache && bg->filename) {

+ bg->file_mtime = get_mtime (bg->filename);

+

+ bg->pixbuf_cache = get_as_pixbuf_for_size (bg, bg->filename, best_width, best_height);

+ time_until_next_change = G_MAXUINT;

+ if (!bg->pixbuf_cache) {

+ SlideShow *show = get_as_slideshow (bg, bg->filename);

+

+ if (show) {

+ double alpha;

+ Slide *slide;

+

+ slideshow_ref (show);

+

+ slide = get_current_slide (show, &alpha);

+ time_until_next_change = (guint)get_slide_timeout (slide);

+ if (slide->fixed) {

+ FileSize *size;

+ size = find_best_size (slide->file1, best_width, best_height);

+ bg->pixbuf_cache = get_as_pixbuf_for_size (bg, size->file, best_width, best_height);

+ }

+ else {

+ FileSize *size;

+ GdkPixbuf *p1, *p2;

+ size = find_best_size (slide->file1, best_width, best_height);

+ p1 = get_as_pixbuf_for_size (bg, size->file, best_width, best_height);

+ size = find_best_size (slide->file2, best_width, best_height);

+ p2 = get_as_pixbuf_for_size (bg, size->file, best_width, best_height);

+

+ if (p1 && p2) {

+ bg->pixbuf_cache = blend (p1, p2, alpha);

+ }

+ if (p1)

+ g_object_unref (p1);

+ if (p2)

+ g_object_unref (p2);

+ }

+

+ ensure_timeout (bg, slide);

+

+ slideshow_unref (show);

+ }

+ }

+

+ /* If the next slideshow step is a long time away then

+ we blow away the expensive stuff (large pixbufs) from

+ the cache */

+ if (time_until_next_change > KEEP_EXPENSIVE_CACHE_SECS)

+ blow_expensive_caches_in_idle (bg);

+ }

+

+ if (bg->pixbuf_cache)

+ g_object_ref (bg->pixbuf_cache);

+

+ return bg->pixbuf_cache;

+}

+

+static gboolean

+is_different (MateBG *bg,

+ const char *filename)

+{

+ if (!filename && bg->filename) {

+ return TRUE;

+ }

+ else if (filename && !bg->filename) {

+ return TRUE;

+ }

+ else if (!filename && !bg->filename) {

+ return FALSE;

+ }

+ else {

+ time_t mtime = get_mtime (filename);

+

+ if (mtime != bg->file_mtime)

+ return TRUE;

+

+ if (strcmp (filename, bg->filename) != 0)

+ return TRUE;

+

+ return FALSE;

+ }

+}

+

+static void

+clear_cache (MateBG *bg)

+{

+ GList *list;

+

+ if (bg->file_cache) {

+ for (list = bg->file_cache; list != NULL; list = list->next) {

+ FileCacheEntry *ent = list->data;

+

+ file_cache_entry_delete (ent);

+ }

+ g_list_free (bg->file_cache);

+ bg->file_cache = NULL;

+ }

+

+ if (bg->pixbuf_cache) {

+ g_object_unref (bg->pixbuf_cache);

+

+ bg->pixbuf_cache = NULL;

+ }

+

+ if (bg->timeout_id) {

+ g_source_remove (bg->timeout_id);

+

+ bg->timeout_id = 0;

+ }

+}

+

+/* Pixbuf utilities */

+static guint32

+pixbuf_average_value (GdkPixbuf *pixbuf)

+{

+ guint64 a_total, r_total, g_total, b_total;

+ guint row, column;

+ int row_stride;

+ const guchar *pixels, *p;

+ int r, g, b, a;

+ guint64 dividend;

+ guint width, height;

+

+ width = gdk_pixbuf_get_width (pixbuf);

+ height = gdk_pixbuf_get_height (pixbuf);

+ row_stride = gdk_pixbuf_get_rowstride (pixbuf);

+ pixels = gdk_pixbuf_get_pixels (pixbuf);

+

+ /* iterate through the pixbuf, counting up each component */

+ a_total = 0;

+ r_total = 0;

+ g_total = 0;

+ b_total = 0;

+

+ if (gdk_pixbuf_get_has_alpha (pixbuf)) {

+ for (row = 0; row < height; row++) {

+ p = pixels + (row * row_stride);

+ for (column = 0; column < width; column++) {

+ r = *p++;

+ g = *p++;

+ b = *p++;

+ a = *p++;

+

+ a_total += a;

+ r_total += r * a;

+ g_total += g * a;

+ b_total += b * a;

+ }

+ }

+ dividend = height * width * 0xFF;

+ a_total *= 0xFF;

+ } else {

+ for (row = 0; row < height; row++) {

+ p = pixels + (row * row_stride);

+ for (column = 0; column < width; column++) {

+ r = *p++;

+ g = *p++;

+ b = *p++;

+

+ r_total += r;

+ g_total += g;

+ b_total += b;

+ }

+ }

+ dividend = height * width;

+ a_total = dividend * 0xFF;

+ }

+

+ return ((a_total + dividend / 2) / dividend) << 24

+ | ((r_total + dividend / 2) / dividend) << 16

+ | ((g_total + dividend / 2) / dividend) << 8

+ | ((b_total + dividend / 2) / dividend);

+}

+

+static GdkPixbuf *

+pixbuf_scale_to_fit (GdkPixbuf *src, int max_width, int max_height)

+{

+ double factor;

+ int src_width, src_height;

+ int new_width, new_height;

+

+ src_width = gdk_pixbuf_get_width (src);

+ src_height = gdk_pixbuf_get_height (src);

+

+ factor = MIN (max_width / (double) src_width, max_height / (double) src_height);

+

+ new_width = floor (src_width * factor + 0.5);

+ new_height = floor (src_height * factor + 0.5);

+

+ return gdk_pixbuf_scale_simple (src, new_width, new_height, GDK_INTERP_BILINEAR);

+}

+

+static GdkPixbuf *

+pixbuf_scale_to_min (GdkPixbuf *src, int min_width, int min_height)

+{

+ double factor;

+ int src_width, src_height;

+ int new_width, new_height;

+ GdkPixbuf *dest;

+

+ src_width = gdk_pixbuf_get_width (src);

+ src_height = gdk_pixbuf_get_height (src);

+

+ factor = MAX (min_width / (double) src_width, min_height / (double) src_height);

+

+ new_width = floor (src_width * factor + 0.5);

+ new_height = floor (src_height * factor + 0.5);

+

+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB,

+ gdk_pixbuf_get_has_alpha (src),

+ 8, min_width, min_height);

+ if (!dest)

+ return NULL;

+

+ /* crop the result */

+ gdk_pixbuf_scale (src, dest,

+ 0, 0,

+ min_width, min_height,

+ (new_width - min_width) / -2,

+ (new_height - min_height) / -2,

+ factor,

+ factor,

+ GDK_INTERP_BILINEAR);

+ return dest;

+}

+

+static guchar *

+create_gradient (const GdkColor *primary,

+ const GdkColor *secondary,

+ int n_pixels)

+{

+ guchar *result = g_malloc (n_pixels * 3);

+ int i;

+

+ for (i = 0; i < n_pixels; ++i) {

+ double ratio = (i + 0.5) / n_pixels;

+

+ result[3 * i + 0] = ((guint16) (primary->red * (1 - ratio) + secondary->red * ratio)) >> 8;

+ result[3 * i + 1] = ((guint16) (primary->green * (1 - ratio) + secondary->green * ratio)) >> 8;

+ result[3 * i + 2] = ((guint16) (primary->blue * (1 - ratio) + secondary->blue * ratio)) >> 8;

+ }

+

+ return result;

+}

+

+static void

+pixbuf_draw_gradient (GdkPixbuf *pixbuf,

+ gboolean horizontal,

+ GdkColor *primary,

+ GdkColor *secondary,

+ GdkRectangle *rect)

+{

+ int width;

+ int height;

+ int rowstride;

+ guchar *dst;

+ guchar *dst_limit;

+ int n_channels = 3;

+

+ rowstride = gdk_pixbuf_get_rowstride (pixbuf);

+ width = rect->width;

+ height = rect->height;

+ dst = gdk_pixbuf_get_pixels (pixbuf) + rect->x * n_channels + rowstride * rect->y;

+ dst_limit = dst + height * rowstride;

+

+ if (horizontal) {

+ guchar *gradient = create_gradient (primary, secondary, width);

+ int copy_bytes_per_row = width * n_channels;

+ int i;

+

+ for (i = 0; i < height; i++) {

+ guchar *d;

+ d = dst + rowstride * i;

+ memcpy (d, gradient, copy_bytes_per_row);

+ }

+ g_free (gradient);

+ } else {

+ guchar *gb, *gradient;

+ int i;

+

+ gradient = create_gradient (primary, secondary, height);

+ for (i = 0; i < height; i++) {

+ int j;

+ guchar *d;

+

+ d = dst + rowstride * i;

+ gb = gradient + n_channels * i;

+ for (j = width; j > 0; j--) {

+ int k;

+

+ for (k = 0; k < n_channels; k++) {

+ *(d++) = gb[k];

+ }

+ }

+ }

+

+ g_free (gradient);

+ }

+}

+

+static void

+pixbuf_blend (GdkPixbuf *src,

+ GdkPixbuf *dest,

+ int src_x,

+ int src_y,

+ int src_width,

+ int src_height,

+ int dest_x,

+ int dest_y,

+ double alpha)

+{

+ int dest_width = gdk_pixbuf_get_width (dest);

+ int dest_height = gdk_pixbuf_get_height (dest);

+ int offset_x = dest_x - src_x;

+ int offset_y = dest_y - src_y;

+

+ if (src_width < 0)

+ src_width = gdk_pixbuf_get_width (src);

+

+ if (src_height < 0)

+ src_height = gdk_pixbuf_get_height (src);

+

+ if (dest_x < 0)

+ dest_x = 0;

+

+ if (dest_y < 0)

+ dest_y = 0;

+

+ if (dest_x + src_width > dest_width) {

+ src_width = dest_width - dest_x;

+ }

+

+ if (dest_y + src_height > dest_height) {

+ src_height = dest_height - dest_y;

+ }

+

+ gdk_pixbuf_composite (src, dest,

+ dest_x, dest_y,

+ src_width, src_height,

+ offset_x, offset_y,

+ 1, 1, GDK_INTERP_NEAREST,

+ alpha * 0xFF + 0.5);

+}

+

+static void

+pixbuf_tile (GdkPixbuf *src, GdkPixbuf *dest)

+{

+ int x, y;

+ int tile_width, tile_height;

+ int dest_width = gdk_pixbuf_get_width (dest);

+ int dest_height = gdk_pixbuf_get_height (dest);

+

+ tile_width = gdk_pixbuf_get_width (src);

+ tile_height = gdk_pixbuf_get_height (src);

+

+ for (y = 0; y < dest_height; y += tile_height) {

+ for (x = 0; x < dest_width; x += tile_width) {

+ pixbuf_blend (src, dest, 0, 0,

+ tile_width, tile_height, x, y, 1.0);

+ }

+ }

+}

+

+static gboolean stack_is (SlideShow *parser, const char *s1, ...);

+

+/* Parser for fading background */

+static void

+handle_start_element (GMarkupParseContext *context,

+ const gchar *name,

+ const gchar **attr_names,

+ const gchar **attr_values,

+ gpointer user_data,

+ GError **err)

+{

+ SlideShow *parser = user_data;

+ gint i;

+

+ if (strcmp (name, "static") == 0 || strcmp (name, "transition") == 0) {

+ Slide *slide = g_new0 (Slide, 1);

+

+ if (strcmp (name, "static") == 0)

+ slide->fixed = TRUE;

+

+ g_queue_push_tail (parser->slides, slide);

+ }

+ else if (strcmp (name, "size") == 0) {

+ Slide *slide = parser->slides->tail->data;

+ FileSize *size = g_new0 (FileSize, 1);

+ for (i = 0; attr_names[i]; i++) {

+ if (strcmp (attr_names[i], "width") == 0)

+ size->width = atoi (attr_values[i]);

+ else if (strcmp (attr_names[i], "height") == 0)

+ size->height = atoi (attr_values[i]);

+ }

+ if (parser->stack->tail &&

+ (strcmp (parser->stack->tail->data, "file") == 0 ||

+ strcmp (parser->stack->tail->data, "from") == 0)) {

+ slide->file1 = g_slist_prepend (slide->file1, size);

+ }

+ else if (parser->stack->tail &&

+ strcmp (parser->stack->tail->data, "to") == 0) {

+ slide->file2 = g_slist_prepend (slide->file2, size);

+ }

+ }

+ g_queue_push_tail (parser->stack, g_strdup (name));

+}

+

+static void

+handle_end_element (GMarkupParseContext *context,

+ const gchar *name,

+ gpointer user_data,

+ GError **err)

+{

+ SlideShow *parser = user_data;

+

+ g_free (g_queue_pop_tail (parser->stack));

+}

+

+static gboolean

+stack_is (SlideShow *parser,

+ const char *s1,

+ ...)

+{

+ GList *stack = NULL;

+ const char *s;

+ GList *l1, *l2;

+ va_list args;

+

+ stack = g_list_prepend (stack, (gpointer)s1);

+

+ va_start (args, s1);

+

+ s = va_arg (args, const char *);

+ while (s) {

+ stack = g_list_prepend (stack, (gpointer)s);

+ s = va_arg (args, const char *);

+ }

+

+ l1 = stack;

+ l2 = parser->stack->head;

+

+ while (l1 && l2) {

+ if (strcmp (l1->data, l2->data) != 0) {

+ g_list_free (stack);

+ return FALSE;

+ }

+

+ l1 = l1->next;

+ l2 = l2->next;

+ }

+

+ g_list_free (stack);

+

+ return (!l1 && !l2);

+}

+

+static int

+parse_int (const char *text)

+{

+ return strtol (text, NULL, 0);

+}

+

+static void

+handle_text (GMarkupParseContext *context,

+ const gchar *text,

+ gsize text_len,

+ gpointer user_data,

+ GError **err)

+{

+ SlideShow *parser = user_data;

+ Slide *slide = parser->slides->tail? parser->slides->tail->data : NULL;

+ FileSize *fs;

+ gint i;

+

+ if (stack_is (parser, "year", "starttime", "background", NULL)) {

+ parser->start_tm.tm_year = parse_int (text) - 1900;

+ }

+ else if (stack_is (parser, "month", "starttime", "background", NULL)) {

+ parser->start_tm.tm_mon = parse_int (text) - 1;

+ }

+ else if (stack_is (parser, "day", "starttime", "background", NULL)) {

+ parser->start_tm.tm_mday = parse_int (text);

+ }

+ else if (stack_is (parser, "hour", "starttime", "background", NULL)) {

+ parser->start_tm.tm_hour = parse_int (text) - 1;

+ }

+ else if (stack_is (parser, "minute", "starttime", "background", NULL)) {

+ parser->start_tm.tm_min = parse_int (text);

+ }

+ else if (stack_is (parser, "second", "starttime", "background", NULL)) {

+ parser->start_tm.tm_sec = parse_int (text);

+ }

+ else if (stack_is (parser, "duration", "static", "background", NULL) ||

+ stack_is (parser, "duration", "transition", "background", NULL)) {

+ slide->duration = g_strtod (text, NULL);

+ parser->total_duration += slide->duration;

+ }

+ else if (stack_is (parser, "file", "static", "background", NULL) ||

+ stack_is (parser, "from", "transition", "background", NULL)) {

+ for (i = 0; text[i]; i++) {

+ if (!g_ascii_isspace (text[i]))

+ break;

+ }

+ if (text[i] == 0)

+ return;

+ fs = g_new (FileSize, 1);

+ fs->width = -1;

+ fs->height = -1;

+ fs->file = g_strdup (text);

+ slide->file1 = g_slist_prepend (slide->file1, fs);

+ if (slide->file1->next != NULL)

+ parser->has_multiple_sizes = TRUE;

+ }

+ else if (stack_is (parser, "size", "file", "static", "background", NULL) ||

+ stack_is (parser, "size", "from", "transition", "background", NULL)) {

+ fs = slide->file1->data;

+ fs->file = g_strdup (text);

+ if (slide->file1->next != NULL)

+ parser->has_multiple_sizes = TRUE;

+ }

+ else if (stack_is (parser, "to", "transition", "background", NULL)) {

+ for (i = 0; text[i]; i++) {

+ if (!g_ascii_isspace (text[i]))

+ break;

+ }

+ if (text[i] == 0)

+ return;

+ fs = g_new (FileSize, 1);

+ fs->width = -1;

+ fs->height = -1;

+ fs->file = g_strdup (text);

+ slide->file2 = g_slist_prepend (slide->file2, fs);

+ if (slide->file2->next != NULL)

+ parser->has_multiple_sizes = TRUE;

+ }

+ else if (stack_is (parser, "size", "to", "transition", "background", NULL)) {

+ fs = slide->file2->data;

+ fs->file = g_strdup (text);

+ if (slide->file2->next != NULL)

+ parser->has_multiple_sizes = TRUE;

+ }

+}

+

+static SlideShow *

+slideshow_ref (SlideShow *show)

+{

+ show->ref_count++;

+ return show;

+}

+

+static void

+slideshow_unref (SlideShow *show)

+{

+ GList *list;

+ GSList *slist;

+ FileSize *size;

+

+ show->ref_count--;

+ if (show->ref_count > 0)

+ return;

+

+ for (list = show->slides->head; list != NULL; list = list->next) {

+ Slide *slide = list->data;

+

+ for (slist = slide->file1; slist != NULL; slist = slist->next) {

+ size = slist->data;

+ g_free (size->file);

+ g_free (size);

+ }

+ g_slist_free (slide->file1);

+

+ for (slist = slide->file2; slist != NULL; slist = slist->next) {

+ size = slist->data;

+ g_free (size->file);

+ g_free (size);

+ }

+ g_slist_free (slide->file2);

+

+ g_free (slide);

+ }

+

+ g_queue_free (show->slides);

+

+ g_list_foreach (show->stack->head, (GFunc) g_free, NULL);

+ g_queue_free (show->stack);

+

+ g_free (show);

+}

+

+static void

+dump_bg (SlideShow *show)

+{

+#if 0

+ GList *list;

+ GSList *slist;

+

+ for (list = show->slides->head; list != NULL; list = list->next)

+ {

+ Slide *slide = list->data;

+

+ g_print ("\nSlide: %s\n", slide->fixed? "fixed" : "transition");

+ g_print ("duration: %f\n", slide->duration);

+ g_print ("File1:\n");

+ for (slist = slide->file1; slist != NULL; slist = slist->next) {

+ FileSize *size = slist->data;

+ g_print ("\t%s (%dx%d)\n",

+ size->file, size->width, size->height);

+ }

+ g_print ("File2:\n");

+ for (slist = slide->file2; slist != NULL; slist = slist->next) {

+ FileSize *size = slist->data;

+ g_print ("\t%s (%dx%d)\n",

+ size->file, size->width, size->height);

+ }

+ }

+#endif

+}

+

+static void

+threadsafe_localtime (time_t time, struct tm *tm)

+{

+ struct tm *res;

+

+ G_LOCK_DEFINE_STATIC (localtime_mutex);

+

+ G_LOCK (localtime_mutex);

+

+ res = localtime (&time);

+ if (tm) {

+ *tm = *res;

+ }

+

+ G_UNLOCK (localtime_mutex);

+}

+

+static SlideShow *

+read_slideshow_file (const char *filename,

+ GError **err)

+{

+ GMarkupParser parser = {

+ handle_start_element,

+ handle_end_element,

+ handle_text,

+ NULL, /* passthrough */

+ NULL, /* error */

+ };

+

+ GFile *file;

+ char *contents = NULL;

+ gsize len;

+ SlideShow *show = NULL;

+ GMarkupParseContext *context = NULL;

+ time_t t;

+

+ if (!filename)

+ return NULL;

+

+ file = g_file_new_for_path (filename);

+ if (!g_file_load_contents (file, NULL, &contents, &len, NULL, NULL)) {

+ g_object_unref (file);

+ return NULL;

+ }

+ g_object_unref (file);

+

+ show = g_new0 (SlideShow, 1);

+ show->ref_count = 1;

+ threadsafe_localtime ((time_t)0, &show->start_tm);

+ show->stack = g_queue_new ();

+ show->slides = g_queue_new ();

+

+ context = g_markup_parse_context_new (&parser, 0, show, NULL);

+

+ if (!g_markup_parse_context_parse (context, contents, len, err)) {

+ slideshow_unref (show);

+ show = NULL;

+ }

+

+

+ if (show) {

+ if (!g_markup_parse_context_end_parse (context, err)) {

+ slideshow_unref (show);

+ show = NULL;

+ }

+ }

+

+ g_markup_parse_context_free (context);

+

+ if (show) {

+ t = mktime (&show->start_tm);

+

+ show->start_time = (double)t;

+

+ dump_bg (show);

+

+ /* no slides, that's not a slideshow */

+ if (g_queue_get_length (show->slides) == 0) {

+ slideshow_unref (show);

+ show = NULL;

+ }

+ }

+

+ g_free (contents);

+

+ return show;

+}

+

+/* Thumbnail utilities */

+static GdkPixbuf *

+create_thumbnail_for_filename (MateDesktopThumbnailFactory *factory,

+ const char *filename)

+{

+ char *thumb;

+ time_t mtime;

+ GdkPixbuf *orig, *result = NULL;

+ char *uri;

+

+ mtime = get_mtime (filename);

+

+ if (mtime == (time_t)-1)

+ return NULL;

+

+ uri = g_filename_to_uri (filename, NULL, NULL);

+

+ thumb = mate_desktop_thumbnail_factory_lookup (factory, uri, mtime);

+

+ if (thumb) {

+ result = gdk_pixbuf_new_from_file (thumb, NULL);

+ g_free (thumb);

+ }

+ else {

+ orig = gdk_pixbuf_new_from_file (filename, NULL);

+ if (orig) {

+ int orig_width = gdk_pixbuf_get_width (orig);

+ int orig_height = gdk_pixbuf_get_height (orig);

+

+ result = pixbuf_scale_to_fit (orig, 128, 128);

+

+ g_object_set_data_full (G_OBJECT (result), "mate-thumbnail-height",

+ g_strdup_printf ("%d", orig_height), g_free);

+ g_object_set_data_full (G_OBJECT (result), "mate-thumbnail-width",

+ g_strdup_printf ("%d", orig_width), g_free);

+

+ g_object_unref (orig);

+

+ mate_desktop_thumbnail_factory_save_thumbnail (factory, result, uri, mtime);

+ }

+ else {

+ mate_desktop_thumbnail_factory_create_failed_thumbnail (factory, uri, mtime);

+ }

+ }

+

+ g_free (uri);

+

+ return result;

+}

+

+static gboolean

+get_thumb_annotations (GdkPixbuf *thumb,

+ int *orig_width,

+ int *orig_height)

+{

+ char *end;

+ const char *wstr, *hstr;

+

+ wstr = gdk_pixbuf_get_option (thumb, "tEXt::Thumb::Image::Width");

+ hstr = gdk_pixbuf_get_option (thumb, "tEXt::Thumb::Image::Height");

+

+ if (hstr && wstr) {

+ *orig_width = strtol (wstr, &end, 10);

+ if (*end != 0)

+ return FALSE;

+

+ *orig_height = strtol (hstr, &end, 10);

+ if (*end != 0)

+ return FALSE;

+

+ return TRUE;

+ }

+

+ return FALSE;

+}

+

+static gboolean

+slideshow_has_multiple_sizes (SlideShow *show)

+{

+ return show->has_multiple_sizes;

+}

+

+/*

+ * Returns whether the background is a slideshow.

+ */

+gboolean

+mate_bg_changes_with_time (MateBG *bg)

+{

+ SlideShow *show;

+

+ g_return_val_if_fail (bg != NULL, FALSE);

+

+ show = get_as_slideshow (bg, bg->filename);

+ if (show)

+ return g_queue_get_length (show->slides) > 1;

+

+ return FALSE;

+}

+

+/* Creates a thumbnail for a certain frame, where 'frame' is somewhat

+ * vaguely defined as 'suitable point to show while single-stepping

+ * through the slideshow'. Returns NULL if frame_num is out of bounds.

+ */

+GdkPixbuf *

+mate_bg_create_frame_thumbnail (MateBG *bg,

+ MateDesktopThumbnailFactory *factory,

+ GdkScreen *screen,

+ int dest_width,

+ int dest_height,

+ int frame_num)

+{

+ SlideShow *show;

+ GdkPixbuf *result;

+ GdkPixbuf *thumb;

+ GList *l;

+ int i, skipped;

+ gboolean found;

+

+ g_return_val_if_fail (bg != NULL, FALSE);

+

+ show = get_as_slideshow (bg, bg->filename);

+

+ if (!show)

+ return NULL;

+

+

+ if (frame_num < 0 || frame_num >= g_queue_get_length (show->slides))

+ return NULL;

+

+ i = 0;

+ skipped = 0;

+ found = FALSE;

+ for (l = show->slides->head; l; l = l->next) {

+ Slide *slide = l->data;

+ if (!slide->fixed) {

+ skipped++;

+ continue;

+ }

+ if (i == frame_num) {

+ found = TRUE;

+ break;

+ }

+ i++;

+ }

+ if (!found)

+ return NULL;

+

+

+ result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, dest_width, dest_height);

+

+ draw_color (bg, result, screen);

+

+ thumb = create_img_thumbnail (bg, factory, screen, dest_width, dest_height, frame_num + skipped);

+

+ if (thumb) {

+ draw_image (bg->placement, thumb, result);

+ g_object_unref (thumb);

+ }

+

+ return result;

+}

+

+prefix=@prefix@

+exec_prefix=@exec_prefix@

+libdir=@libdir@

+includedir=@includedir@

+

+Name: mate-desktop-2.0

+Description: Utility library for loading .desktop files

+Requires: gtk+-2.0 libmateui-2.0 @STARTUP_NOTIFICATION_PACKAGE@

+Version: @VERSION@

+Libs: ${pc_top_builddir}/${pcfiledir}/libmate-desktop-2.la

+Cflags: -I${pc_top_builddir}/${pcfiledir}

+prefix=@prefix@

+exec_prefix=@exec_prefix@

+libdir=@libdir@

+includedir=@includedir@

+

+Name: mate-desktop-2.0

+Description: Utility library for loading .desktop files

+Requires: gtk+-2.0 @STARTUP_NOTIFICATION_PACKAGE@

+Version: @VERSION@

+Libs: -L${libdir} -lmate-desktop-2

+Cflags: -I${includedir}/mate-desktop-2.0

+/* -*- Mode: C; c-set-style: linux indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

+/* mate-desktop-item.c - MATE Desktop File Representation

+

+ Copyright (C) 1999, 2000 Red Hat Inc.

+ Copyright (C) 2001 Sid Vicious

+ All rights reserved.

+

+ This file is part of the Mate Library.

+

+ Developed by Elliot Lee <[email protected]> and Sid Vicious

+

+ The Mate Library is free software; you can redistribute it and/or

+ modify it under the terms of the GNU Library General Public License as

+ published by the Free Software Foundation; either version 2 of the

+ License, or (at your option) any later version.

+

+ The Mate Library is distributed in the hope that it will be useful,

+ but WITHOUT ANY WARRANTY; without even the implied warranty of

+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ Library General Public License for more details.

+

+ You should have received a copy of the GNU Library General Public

+ License along with the Mate Library; see the file COPYING.LIB. If not,

+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

+ Boston, MA 02111-1307, USA. */

+/*

+ @NOTATION@

+ */

+

+#include "config.h"

+

+#include <limits.h>

+#include <ctype.h>

+#include <stdio.h>

+#include <glib.h>

+#include <sys/types.h>

+#include <dirent.h>

+#include <unistd.h>

+#include <time.h>

+#include <string.h>

+#include <glib/gi18n-lib.h>

+#include <locale.h>

+#include <stdlib.h>

+

+#include <gio/gio.h>

+

+#ifdef HAVE_STARTUP_NOTIFICATION

+#define SN_API_NOT_YET_FROZEN

+#include <libsn/sn.h>

+#include <gdk/gdk.h>

+#include <gdk/gdkx.h>

+#include <gtk/gtk.h>

+#endif

+

+#define sure_string(s) ((s)!=NULL?(s):"")

+

+#define MATE_DESKTOP_USE_UNSTABLE_API

+#undef MATE_DISABLE_DEPRECATED

+#include <libmate/mate-desktop-item.h>

+#include <libmate/mate-desktop-utils.h>

+

+#include "private.h"

+

+struct _MateDesktopItem {

+ int refcount;

+

+ /* all languages used */

+ GList *languages;

+

+ MateDesktopItemType type;

+

+ /* `modified' means that the ditem has been

+ * modified since the last save. */

+ gboolean modified;

+

+ /* Keys of the main section only */

+ GList *keys;

+

+ GList *sections;

+

+ /* This includes ALL keys, including

+ * other sections, separated by '/' */

+ GHashTable *main_hash;

+

+ char *location;

+

+ time_t mtime;

+

+ guint32 launch_time;

+};

+

+/* If mtime is set to this, set_location won't update mtime,

+ * this is to be used internally only. */

+#define DONT_UPDATE_MTIME ((time_t)-2)

+

+typedef struct {

+ char *name;

+ GList *keys;

+} Section;

+

+typedef enum {

+ ENCODING_UNKNOWN,

+ ENCODING_UTF8,

+ ENCODING_LEGACY_MIXED

+} Encoding;

+

+/*

+ * IO reading utils, that look like the libc buffered io stuff

+ */

+

+#define READ_BUF_SIZE (32 * 1024)

+

+typedef struct {

+ GFile *file;

+ GFileInputStream *stream;

+ char *uri;

+ char *buf;

+ gboolean buf_needs_free;

+ gboolean past_first_read;

+ gboolean eof;

+ guint64 size;

+ gsize pos;

+} ReadBuf;

+

+static MateDesktopItem *ditem_load (ReadBuf *rb,

+ gboolean no_translations,

+ GError **error);

+static gboolean ditem_save (MateDesktopItem *item,

+ const char *uri,

+ GError **error);

+

+static void mate_desktop_item_set_location_gfile (MateDesktopItem *item,

+ GFile *file);

+

+static MateDesktopItem *mate_desktop_item_new_from_gfile (GFile *file,

+ MateDesktopItemLoadFlags flags,

+ GError **error);

+

+static int

+readbuf_getc (ReadBuf *rb)

+{

+ if (rb->eof)

+ return EOF;

+

+ if (rb->size == 0 ||

+ rb->pos == rb->size) {

+ gssize bytes_read;

+

+ if (rb->stream == NULL)

+ bytes_read = 0;

+ else

+ bytes_read = g_input_stream_read (G_INPUT_STREAM (rb->stream),

+ rb->buf,

+ READ_BUF_SIZE,

+ NULL, NULL);

+

+ /* FIXME: handle errors other than EOF */

+ if (bytes_read <= 0) {

+ rb->eof = TRUE;

+ return EOF;

+ }

+

+ if (rb->size != 0)

+ rb->past_first_read = TRUE;

+ rb->size = bytes_read;

+ rb->pos = 0;

+

+ }

+

+ return (guchar) rb->buf[rb->pos++];

+}

+

+/* Note, does not include the trailing \n */

+static char *

+readbuf_gets (char *buf, gsize bufsize, ReadBuf *rb)

+{

+ int c;

+ gsize pos;

+

+ g_return_val_if_fail (buf != NULL, NULL);

+ g_return_val_if_fail (rb != NULL, NULL);

+

+ pos = 0;

+ buf[0] = '\0';

+

+ do {

+ c = readbuf_getc (rb);

+ if (c == EOF || c == '\n')

+ break;

+ buf[pos++] = c;

+ } while (pos < bufsize-1);

+

+ if (c == EOF && pos == 0)

+ return NULL;

+

+ buf[pos++] = '\0';

+

+ return buf;

+}

+

+static ReadBuf *

+readbuf_open (GFile *file, GError **error)

+{

+ GError *local_error;

+ GFileInputStream *stream;

+ char *uri;

+ ReadBuf *rb;

+

+ g_return_val_if_fail (file != NULL, NULL);

+

+ uri = g_file_get_uri (file);

+ local_error = NULL;

+ stream = g_file_read (file, NULL, &local_error);

+

+ if (stream == NULL) {

+ g_set_error (error,

+ /* FIXME: better errors */

+ MATE_DESKTOP_ITEM_ERROR,

+ MATE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,

+ _("Error reading file '%s': %s"),

+ uri, local_error->message);

+ g_error_free (local_error);

+ g_free (uri);

+ return NULL;

+ }

+

+ rb = g_new0 (ReadBuf, 1);

+ rb->stream = stream;

+ rb->file = g_file_dup (file);

+ rb->uri = uri;

+ rb->buf = g_malloc (READ_BUF_SIZE);

+ rb->buf_needs_free = TRUE;

+ /* rb->past_first_read = FALSE; */

+ /* rb->eof = FALSE; */

+ /* rb->size = 0; */

+ /* rb->pos = 0; */

+

+ return rb;

+}

+

+static ReadBuf *

+readbuf_new_from_string (const char *uri, const char *string, gssize length)

+{

+ ReadBuf *rb;

+

+ g_return_val_if_fail (string != NULL, NULL);

+ g_return_val_if_fail (length >= 0, NULL);

+

+ rb = g_new0 (ReadBuf, 1);

+ /* rb->file = NULL; */

+ /* rb->stream = NULL; */

+ rb->uri = g_strdup (uri);

+ rb->buf = (char *) string;

+ /* rb->buf_needs_free = FALSE; */

+ /* rb->past_first_read = FALSE; */

+ /* rb->eof = FALSE; */

+ rb->size = length;

+ /* rb->pos = 0; */

+

+ return rb;

+}

+

+static gboolean

+readbuf_rewind (ReadBuf *rb, GError **error)

+{

+ GError *local_error;

+

+ rb->eof = FALSE;

+ rb->pos = 0;

+

+ if (!rb->past_first_read)

+ return TRUE;

+

+ rb->size = 0;

+

+ if (g_seekable_seek (G_SEEKABLE (rb->stream),

+ 0, G_SEEK_SET, NULL, NULL))

+ return TRUE;

+

+ g_object_unref (rb->stream);

+ local_error = NULL;

+ rb->stream = g_file_read (rb->file, NULL, &local_error);

+

+ if (rb->stream == NULL) {

+ g_set_error (

+ error, MATE_DESKTOP_ITEM_ERROR,

+ MATE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,

+ _("Error rewinding file '%s': %s"),

+ rb->uri, local_error->message);

+ g_error_free (local_error);

+

+ return FALSE;

+ }

+

+ return TRUE;

+}

+

+static void

+readbuf_close (ReadBuf *rb)

+{

+ if (rb->stream != NULL)

+ g_object_unref (rb->stream);

+ if (rb->file != NULL)

+ g_object_unref (rb->file);

+ g_free (rb->uri);

+ if (rb->buf_needs_free)

+ g_free (rb->buf);

+ g_free (rb);

+}

+

+static MateDesktopItemType

+type_from_string (const char *type)

+{

+ if (!type)

+ return MATE_DESKTOP_ITEM_TYPE_NULL;

+

+ switch (type [0]) {

+ case 'A':

+ if (!strcmp (type, "Application"))

+ return MATE_DESKTOP_ITEM_TYPE_APPLICATION;

+ break;

+ case 'L':

+ if (!strcmp (type, "Link"))

+ return MATE_DESKTOP_ITEM_TYPE_LINK;

+ break;

+ case 'F':

+ if (!strcmp (type, "FSDevice"))

+ return MATE_DESKTOP_ITEM_TYPE_FSDEVICE;

+ break;

+ case 'M':

+ if (!strcmp (type, "MimeType"))

+ return MATE_DESKTOP_ITEM_TYPE_MIME_TYPE;

+ break;

+ case 'D':

+ if (!strcmp (type, "Directory"))

+ return MATE_DESKTOP_ITEM_TYPE_DIRECTORY;

+ break;

+ case 'S':

+ if (!strcmp (type, "Service"))

+ return MATE_DESKTOP_ITEM_TYPE_SERVICE;

+

+ else if (!strcmp (type, "ServiceType"))

+ return MATE_DESKTOP_ITEM_TYPE_SERVICE_TYPE;

+ break;

+ default:

+ break;

+ }

+

+ return MATE_DESKTOP_ITEM_TYPE_OTHER;

+}

+

+/**

+ * mate_desktop_item_new:

+ *

+ * Creates a MateDesktopItem object. The reference count on the returned value is set to '1'.

+ *

+ * Returns: The new MateDesktopItem

+ */

+MateDesktopItem *

+mate_desktop_item_new (void)

+{

+ MateDesktopItem *retval;

+

+ _mate_desktop_init_i18n ();

+

+ retval = g_new0 (MateDesktopItem, 1);

+

+ retval->refcount++;

+

+ retval->main_hash = g_hash_table_new_full (g_str_hash, g_str_equal,

+ (GDestroyNotify) g_free,

+ (GDestroyNotify) g_free);

+

+ /* These are guaranteed to be set */

+ mate_desktop_item_set_string (retval,

+ MATE_DESKTOP_ITEM_NAME,

+ /* Translators: the "name" mentioned

+ * here is the name of an application or

+ * a document */

+ _("No name"));

+ mate_desktop_item_set_string (retval,

+ MATE_DESKTOP_ITEM_ENCODING,

+ "UTF-8");

+ mate_desktop_item_set_string (retval,

+ MATE_DESKTOP_ITEM_VERSION,

+ "1.0");

+

+ retval->launch_time = 0;

+

+ return retval;

+}

+

+static Section *

+dup_section (Section *sec)

+{

+ GList *li;

+ Section *retval = g_new0 (Section, 1);

+

+ retval->name = g_strdup (sec->name);

+

+ retval->keys = g_list_copy (sec->keys);

+ for (li = retval->keys; li != NULL; li = li->next)

+ li->data = g_strdup (li->data);

+

+ return retval;

+}

+

+static void

+copy_string_hash (gpointer key, gpointer value, gpointer user_data)

+{

+ GHashTable *copy = user_data;

+ g_hash_table_replace (copy,

+ g_strdup (key),

+ g_strdup (value));

+}

+

+

+/**

+ * mate_desktop_item_copy:

+ * @item: The item to be copied

+ *

+ * Creates a copy of a MateDesktopItem. The new copy has a refcount of 1.

+ * Note: Section stack is NOT copied.

+ *

+ * Returns: The new copy

+ */

+MateDesktopItem *

+mate_desktop_item_copy (const MateDesktopItem *item)

+{

+ GList *li;

+ MateDesktopItem *retval;

+

+ g_return_val_if_fail (item != NULL, NULL);

+ g_return_val_if_fail (item->refcount > 0, NULL);

+

+ retval = mate_desktop_item_new ();

+

+ retval->type = item->type;

+ retval->modified = item->modified;

+ retval->location = g_strdup (item->location);

+ retval->mtime = item->mtime;

+ retval->launch_time = item->launch_time;

+

+ /* Languages */

+ retval->languages = g_list_copy (item->languages);

+ for (li = retval->languages; li != NULL; li = li->next)

+ li->data = g_strdup (li->data);

+

+ /* Keys */

+ retval->keys = g_list_copy (item->keys);

+ for (li = retval->keys; li != NULL; li = li->next)

+ li->data = g_strdup (li->data);

+

+ /* Sections */

+ retval->sections = g_list_copy (item->sections);

+ for (li = retval->sections; li != NULL; li = li->next)

+ li->data = dup_section (li->data);

+

+ retval->main_hash = g_hash_table_new_full (g_str_hash, g_str_equal,

+ (GDestroyNotify) g_free,

+ (GDestroyNotify) g_free);

+

+ g_hash_table_foreach (item->main_hash,

+ copy_string_hash,

+ retval->main_hash);

+

+ return retval;

+}

+

+static void

+read_sort_order (MateDesktopItem *item, GFile *dir)

+{

+ GFile *child;

+ char buf[BUFSIZ];

+ GString *str;

+ ReadBuf *rb;

+

+ child = g_file_get_child (dir, ".order");

+

+ rb = readbuf_open (child, NULL);

+ g_object_unref (child);

+

+ if (rb == NULL)

+ return;

+

+ str = NULL;

+ while (readbuf_gets (buf, sizeof (buf), rb) != NULL) {

+ if (str == NULL)

+ str = g_string_new (buf);

+ else

+ g_string_append (str, buf);

+ g_string_append_c (str, ';');

+ }

+ readbuf_close (rb);

+ if (str != NULL) {

+ mate_desktop_item_set_string (item, MATE_DESKTOP_ITEM_SORT_ORDER,

+ str->str);

+ g_string_free (str, TRUE);

+ }

+}

+

+static MateDesktopItem *

+make_fake_directory (GFile *dir)

+{

+ MateDesktopItem *item;

+ GFile *child;

+

+ item = mate_desktop_item_new ();

+ mate_desktop_item_set_entry_type (item,

+ MATE_DESKTOP_ITEM_TYPE_DIRECTORY);

+

+

+ item->mtime = DONT_UPDATE_MTIME; /* it doesn't exist, we know that */

+ child = g_file_get_child (dir, ".directory");

+ mate_desktop_item_set_location_gfile (item, child);

+ item->mtime = 0;

+ g_object_unref (child);

+

+ read_sort_order (item, dir);

+

+ return item;

+}

+

+/**

+ * mate_desktop_item_new_from_file:

+ * @file: The filename or directory path to load the MateDesktopItem from

+ * @flags: Flags to influence the loading process

+ *

+ * This function loads 'file' and turns it into a MateDesktopItem.

+ *

+ * Returns: The newly loaded item.

+ */

+MateDesktopItem *

+mate_desktop_item_new_from_file (const char *file,

+ MateDesktopItemLoadFlags flags,

+ GError **error)

+{

+ MateDesktopItem *retval;

+ GFile *gfile;

+

+ g_return_val_if_fail (file != NULL, NULL);

+

+ gfile = g_file_new_for_path (file);

+ retval = mate_desktop_item_new_from_gfile (gfile, flags, error);

+ g_object_unref (gfile);

+

+ return retval;

+}

+

+/**

+ * mate_desktop_item_new_from_uri:

+ * @uri: URI to load the MateDesktopItem from

+ * @flags: Flags to influence the loading process

+ *

+ * This function loads 'uri' and turns it into a MateDesktopItem.

+ *

+ * Returns: The newly loaded item.

+ */

+MateDesktopItem *

+mate_desktop_item_new_from_uri (const char *uri,

+ MateDesktopItemLoadFlags flags,

+ GError **error)

+{

+ MateDesktopItem *retval;

+ GFile *file;

+

+ g_return_val_if_fail (uri != NULL, NULL);

+

+ file = g_file_new_for_uri (uri);

+ retval = mate_desktop_item_new_from_gfile (file, flags, error);

+ g_object_unref (file);

+

+ return retval;

+}

+

+static MateDesktopItem *

+mate_desktop_item_new_from_gfile (GFile *file,

+ MateDesktopItemLoadFlags flags,

+ GError **error)

+{

+ MateDesktopItem *retval;

+ GFile *subfn;

+ GFileInfo *info;

+ GFileType type;

+ GFile *parent;

+ time_t mtime = 0;

+ ReadBuf *rb;

+

+ g_return_val_if_fail (file != NULL, NULL);

+

+ info = g_file_query_info (file,

+ G_FILE_ATTRIBUTE_STANDARD_TYPE","G_FILE_ATTRIBUTE_TIME_MODIFIED,

+ G_FILE_QUERY_INFO_NONE, NULL, error);

+ if (info == NULL)

+ return NULL;

+

+ type = g_file_info_get_file_type (info);

+

+ if (type != G_FILE_TYPE_REGULAR && type != G_FILE_TYPE_DIRECTORY) {

+ char *uri;

+

+ uri = g_file_get_uri (file);

+ g_set_error (error,

+ /* FIXME: better errors */

+ MATE_DESKTOP_ITEM_ERROR,

+ MATE_DESKTOP_ITEM_ERROR_INVALID_TYPE,

+ _("File '%s' is not a regular file or directory."),

+ uri);

+

+ g_free (uri);

+ g_object_unref (info);

+

+ return NULL;

+ }

+

+ mtime = g_file_info_get_attribute_uint64 (info,

+ G_FILE_ATTRIBUTE_TIME_MODIFIED);

+

+ g_object_unref (info);

+

+ if (type == G_FILE_TYPE_DIRECTORY) {

+ GFile *child;

+ GFileInfo *child_info;

+

+ child = g_file_get_child (file, ".directory");

+ child_info = g_file_query_info (child,

+ G_FILE_ATTRIBUTE_TIME_MODIFIED,

+ G_FILE_QUERY_INFO_NONE,

+ NULL, NULL);

+

+ if (child_info == NULL) {

+ g_object_unref (child);

+

+ if (flags & MATE_DESKTOP_ITEM_LOAD_ONLY_IF_EXISTS) {

+ return NULL;

+ } else {

+ return make_fake_directory (file);

+ }

+ }

+

+ mtime = g_file_info_get_attribute_uint64 (child_info,

+ G_FILE_ATTRIBUTE_TIME_MODIFIED);

+ g_object_unref (child_info);

+

+ subfn = child;

+ } else {

+ subfn = g_file_dup (file);

+ }

+

+ rb = readbuf_open (subfn, error);

+

+ if (rb == NULL) {

+ g_object_unref (subfn);

+ return NULL;

+ }

+

+ retval = ditem_load (rb,

+ (flags & MATE_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS) != 0,

+ error);

+

+ if (retval == NULL) {

+ g_object_unref (subfn);

+ return NULL;

+ }

+

+ if (flags & MATE_DESKTOP_ITEM_LOAD_ONLY_IF_EXISTS &&

+ ! mate_desktop_item_exists (retval)) {

+ mate_desktop_item_unref (retval);

+ g_object_unref (subfn);

+ return NULL;

+ }

+

+ retval->mtime = DONT_UPDATE_MTIME;

+ mate_desktop_item_set_location_gfile (retval, subfn);

+ retval->mtime = mtime;

+

+ parent = g_file_get_parent (file);

+ if (parent != NULL) {

+ read_sort_order (retval, parent);

+ g_object_unref (parent);

+ }

+

+ g_object_unref (subfn);

+

+ return retval;

+}

+

+/**

+ * mate_desktop_item_new_from_string:

+ * @string: string to load the MateDesktopItem from

+ * @length: length of string, or -1 to use strlen

+ * @flags: Flags to influence the loading process

+ * @error: place to put errors

+ *

+ * This function turns the contents of the string into a MateDesktopItem.

+ *

+ * Returns: The newly loaded item.

+ */

+MateDesktopItem *

+mate_desktop_item_new_from_string (const char *uri,

+ const char *string,

+ gssize length,

+ MateDesktopItemLoadFlags flags,

+ GError **error)

+{

+ MateDesktopItem *retval;

+ ReadBuf *rb;

+

+ g_return_val_if_fail (string != NULL, NULL);

+ g_return_val_if_fail (length >= -1, NULL);

+

+ if (length == -1) {

+ length = strlen (string);

+ }

+

+ rb = readbuf_new_from_string (uri, string, length);

+

+ retval = ditem_load (rb,

+ (flags & MATE_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS) != 0,

+ error);

+

+ if (retval == NULL) {

+ return NULL;

+ }

+

+ /* FIXME: Sort order? */

+

+ return retval;

+}

+

+static char *

+lookup_desktop_file_in_data_dir (const char *desktop_file,

+ const char *data_dir)

+{

+ char *path;

+

+ path = g_build_filename (data_dir, "applications", desktop_file, NULL);

+ if (!g_file_test (path, G_FILE_TEST_EXISTS)) {

+ g_free (path);

+ return NULL;

+ }

+ return path;

+}

+

+static char *

+file_from_basename (const char *basename)

+{

+ const char * const *system_data_dirs;

+ const char *user_data_dir;

+ char *retval;

+ int i;

+

+ user_data_dir = g_get_user_data_dir ();

+ system_data_dirs = g_get_system_data_dirs ();

+

+ if ((retval = lookup_desktop_file_in_data_dir (basename, user_data_dir))) {

+ return retval;

+ }

+ for (i = 0; system_data_dirs[i]; i++) {

+ if ((retval = lookup_desktop_file_in_data_dir (basename, system_data_dirs[i]))) {

+ return retval;

+ }

+ }

+ return NULL;

+}

+

+/**

+ * mate_desktop_item_new_from_basename:

+ * @basename: The basename of the MateDesktopItem to load.

+ * @flags: Flags to influence the loading process

+ *

+ * This function loads 'basename' from a system data directory and

+ * returns its MateDesktopItem.

+ *

+ * Returns: The newly loaded item.

+ */

+MateDesktopItem *

+mate_desktop_item_new_from_basename (const char *basename,

+ MateDesktopItemLoadFlags flags,

+ GError **error)

+{

+ MateDesktopItem *retval;

+ char *file;

+

+ g_return_val_if_fail (basename != NULL, NULL);

+

+ if (!(file = file_from_basename (basename))) {

+ g_set_error (error,

+ MATE_DESKTOP_ITEM_ERROR,

+ MATE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,

+ _("Cannot find file '%s'"),

+ basename);

+ return NULL;

+ }

+

+ retval = mate_desktop_item_new_from_file (file, flags, error);

+ g_free (file);

+

+ return retval;

+}

+

+/**

+ * mate_desktop_item_save:

+ * @item: A desktop item

+ * @under: A new uri (location) for this #MateDesktopItem

+ * @force: Save even if it wasn't modified

+ * @error: #GError return

+ *

+ * Writes the specified item to disk. If the 'under' is NULL, the original

+ * location is used. It sets the location of this entry to point to the

+ * new location.

+ *

+ * Returns: boolean. %TRUE if the file was saved, %FALSE otherwise

+ */

+gboolean

+mate_desktop_item_save (MateDesktopItem *item,

+ const char *under,

+ gboolean force,

+ GError **error)

+{

+ const char *uri;

+

+ if (under == NULL &&

+ ! force &&

+ ! item->modified)

+ return TRUE;

+

+ if (under == NULL)

+ uri = item->location;

+ else

+ uri = under;

+

+ if (uri == NULL) {

+ g_set_error (error,

+ MATE_DESKTOP_ITEM_ERROR,

+ MATE_DESKTOP_ITEM_ERROR_NO_FILENAME,

+ _("No filename to save to"));

+ return FALSE;

+ }

+

+ if ( ! ditem_save (item, uri, error))

+ return FALSE;

+

+ item->modified = FALSE;

+ item->mtime = time (NULL);

+

+ return TRUE;

+}

+

+/**

+ * mate_desktop_item_ref:

+ * @item: A desktop item

+ *

+ * Description: Increases the reference count of the specified item.

+ *

+ * Returns: the newly referenced @item

+ */

+MateDesktopItem *

+mate_desktop_item_ref (MateDesktopItem *item)

+{

+ g_return_val_if_fail (item != NULL, NULL);

+

+ item->refcount++;

+

+ return item;

+}

+

+static void

+free_section (gpointer data, gpointer user_data)

+{

+ Section *section = data;

+

+ g_free (section->name);

+ section->name = NULL;

+

+ g_list_foreach (section->keys, (GFunc)g_free, NULL);

+ g_list_free (section->keys);

+ section->keys = NULL;

+

+ g_free (section);

+}

+

+/**

+ * mate_desktop_item_unref:

+ * @item: A desktop item

+ *

+ * Decreases the reference count of the specified item, and destroys the item if there are no more references left.

+ */

+void

+mate_desktop_item_unref (MateDesktopItem *item)

+{

+ g_return_if_fail (item != NULL);

+ g_return_if_fail (item->refcount > 0);

+

+ item->refcount--;

+

+ if(item->refcount != 0)

+ return;

+

+ g_list_foreach (item->languages, (GFunc)g_free, NULL);

+ g_list_free (item->languages);

+ item->languages = NULL;

+

+ g_list_foreach (item->keys, (GFunc)g_free, NULL);

+ g_list_free (item->keys);

+ item->keys = NULL;

+

+ g_list_foreach (item->sections, free_section, NULL);

+ g_list_free (item->sections);

+ item->sections = NULL;

+

+ g_hash_table_destroy (item->main_hash);

+ item->main_hash = NULL;

+

+ g_free (item->location);

+ item->location = NULL;

+

+ g_free (item);

+}

+

+static Section *

+find_section (MateDesktopItem *item, const char *section)

+{

+ GList *li;

+ Section *sec;

+

+ if (section == NULL)

+ return NULL;

+ if (strcmp (section, "Desktop Entry") == 0)

+ return NULL;

+

+ for (li = item->sections; li != NULL; li = li->next) {

+ sec = li->data;

+ if (strcmp (sec->name, section) == 0)

+ return sec;

+ }

+

+ sec = g_new0 (Section, 1);

+ sec->name = g_strdup (section);

+ sec->keys = NULL;

+

+ item->sections = g_list_append (item->sections, sec);

+

+ /* Don't mark the item modified, this is just an empty section,

+ * it won't be saved even */

+

+ return sec;

+}

+

+static Section *

+section_from_key (MateDesktopItem *item, const char *key)

+{

+ char *p;

+ char *name;

+ Section *sec;

+

+ if (key == NULL)

+ return NULL;

+

+ p = strchr (key, '/');

+ if (p == NULL)

+ return NULL;

+

+ name = g_strndup (key, p - key);

+

+ sec = find_section (item, name);

+

+ g_free (name);

+

+ return sec;

+}

+

+static const char *

+key_basename (const char *key)

+{

+ char *p = strrchr (key, '/');

+ if (p != NULL)

+ return p+1;

+ else

+ return key;

+}

+

+

+static const char *

+lookup (const MateDesktopItem *item, const char *key)

+{

+ return g_hash_table_lookup (item->main_hash, key);

+}

+

+static const char *

+lookup_locale (const MateDesktopItem *item, const char *key, const char *locale)

+{

+ if (locale == NULL ||

+ strcmp (locale, "C") == 0) {

+ return lookup (item, key);

+ } else {

+ const char *ret;

+ char *full = g_strdup_printf ("%s[%s]", key, locale);

+ ret = lookup (item, full);

+ g_free (full);

+ return ret;

+ }

+}

+

+static const char *

+lookup_best_locale (const MateDesktopItem *item, const char *key)

+{

+ const char * const *langs_pointer;

+ int i;

+

+ langs_pointer = g_get_language_names ();

+ for (i = 0; langs_pointer[i] != NULL; i++) {

+ const char *ret = NULL;

+

+ ret = lookup_locale (item, key, langs_pointer[i]);

+ if (ret != NULL)

+ return ret;

+ }

+

+ return NULL;

+}

+

+static void

+set (MateDesktopItem *item, const char *key, const char *value)

+{

+ Section *sec = section_from_key (item, key);

+

+ if (sec != NULL) {

+ if (value != NULL) {

+ if (g_hash_table_lookup (item->main_hash, key) == NULL)

+ sec->keys = g_list_append

+ (sec->keys,

+ g_strdup (key_basename (key)));

+

+ g_hash_table_replace (item->main_hash,

+ g_strdup (key),

+ g_strdup (value));

+ } else {

+ GList *list = g_list_find_custom

+ (sec->keys, key_basename (key),

+ (GCompareFunc)strcmp);

+ if (list != NULL) {

+ g_free (list->data);

+ sec->keys =

+ g_list_delete_link (sec->keys, list);

+ }

+ g_hash_table_remove (item->main_hash, key);

+ }

+ } else {

+ if (value != NULL) {

+ if (g_hash_table_lookup (item->main_hash, key) == NULL)

+ item->keys = g_list_append (item->keys,

+ g_strdup (key));

+

+ g_hash_table_replace (item->main_hash,

+ g_strdup (key),

+ g_strdup (value));

+ } else {

+ GList *list = g_list_find_custom

+ (item->keys, key, (GCompareFunc)strcmp);

+ if (list != NULL) {

+ g_free (list->data);

+ item->keys =

+ g_list_delete_link (item->keys, list);

+ }

+ g_hash_table_remove (item->main_hash, key);

+ }

+ }

+ item->modified = TRUE;

+}

+

+static void

+set_locale (MateDesktopItem *item, const char *key,

+ const char *locale, const char *value)

+{

+ if (locale == NULL ||

+ strcmp (locale, "C") == 0) {

+ set (item, key, value);

+ } else {

+ char *full = g_strdup_printf ("%s[%s]", key, locale);

+ set (item, full, value);

+ g_free (full);

+

+ /* add the locale to the list of languages if it wasn't there

+ * before */

+ if (g_list_find_custom (item->languages, locale,

+ (GCompareFunc)strcmp) == NULL)

+ item->languages = g_list_prepend (item->languages,

+ g_strdup (locale));

+ }

+}

+

+static char **

+list_to_vector (GSList *list)

+{

+ int len = g_slist_length (list);

+ char **argv;

+ int i;

+ GSList *li;

+

+ argv = g_new0 (char *, len+1);

+

+ for (i = 0, li = list;

+ li != NULL;

+ li = li->next, i++) {

+ argv[i] = g_strdup (li->data);

+ }

+ argv[i] = NULL;

+

+ return argv;

+}

+

+static GSList *

+make_args (GList *files)

+{

+ GSList *list = NULL;

+ GList *li;

+

+ for (li = files; li != NULL; li = li->next) {

+ GFile *gfile;

+ const char *file = li->data;

+ if (file == NULL)

+ continue;

+ gfile = g_file_new_for_uri (file);

+ list = g_slist_prepend (list, gfile);

+ }

+

+ return g_slist_reverse (list);

+}

+

+static void

+free_args (GSList *list)

+{

+ GSList *li;

+

+ for (li = list; li != NULL; li = li->next) {

+ g_object_unref (G_FILE (li->data));

+ li->data = NULL;

+ }

+ g_slist_free (list);

+}

+

+static char *

+escape_single_quotes (const char *s,

+ gboolean in_single_quotes,

+ gboolean in_double_quotes)

+{

+ const char *p;

+ GString *gs;

+ const char *pre = "";

+ const char *post = "";

+

+ if ( ! in_single_quotes && ! in_double_quotes) {

+ pre = "'";

+ post = "'";

+ } else if ( ! in_single_quotes && in_double_quotes) {

+ pre = "\"'";

+ post = "'\"";

+ }

+

+ if (strchr (s, '\'') == NULL) {

+ return g_strconcat (pre, s, post, NULL);

+ }

+

+ gs = g_string_new (pre);

+

+ for (p = s; *p != '\0'; p++) {

+ if (*p == '\'')

+ g_string_append (gs, "'\\''");

+ else

+ g_string_append_c (gs, *p);

+ }

+

+ g_string_append (gs, post);

+

+ return g_string_free (gs, FALSE);

+}

+

+typedef enum {

+ URI_TO_STRING,

+ URI_TO_LOCAL_PATH,

+ URI_TO_LOCAL_DIRNAME,

+ URI_TO_LOCAL_BASENAME

+} ConversionType;

+

+static char *

+convert_uri (GFile *file,

+ ConversionType conversion)

+{

+ char *retval = NULL;

+

+ switch (conversion) {

+ case URI_TO_STRING:

+ retval = g_file_get_uri (file);

+ break;

+ case URI_TO_LOCAL_PATH:

+ retval = g_file_get_path (file);

+ break;

+ case URI_TO_LOCAL_DIRNAME:

+ {

+ char *local_path;

+

+ local_path = g_file_get_path (file);

+ retval = g_path_get_dirname (local_path);

+ g_free (local_path);

+ }

+ break;

+ case URI_TO_LOCAL_BASENAME:

+ retval = g_file_get_basename (file);

+ break;

+ default:

+ g_assert_not_reached ();

+ }

+

+ return retval;

+}

+

+typedef enum {

+ ADDED_NONE = 0,

+ ADDED_SINGLE,

+ ADDED_ALL

+} AddedStatus;

+

+static AddedStatus

+append_all_converted (GString *str,

+ ConversionType conversion,

+ GSList *args,

+ gboolean in_single_quotes,

+ gboolean in_double_quotes,

+ AddedStatus added_status)

+{

+ GSList *l;

+

+ for (l = args; l; l = l->next) {

+ char *converted;

+ char *escaped;

+

+ if (!(converted = convert_uri (l->data, conversion)))

+ continue;

+

+ g_string_append (str, " ");

+

+ escaped = escape_single_quotes (converted,

+ in_single_quotes,

+ in_double_quotes);

+ g_string_append (str, escaped);

+

+ g_free (escaped);

+ g_free (converted);

+ }

+

+ return ADDED_ALL;

+}

+

+static AddedStatus

+append_first_converted (GString *str,

+ ConversionType conversion,

+ GSList **arg_ptr,

+ gboolean in_single_quotes,

+ gboolean in_double_quotes,

+ AddedStatus added_status)

+{

+ GSList *l;

+ char *converted = NULL;

+ char *escaped;

+

+ for (l = *arg_ptr; l; l = l->next) {

+ if ((converted = convert_uri (l->data, conversion)))

+ break;

+

+ *arg_ptr = l->next;

+ }

+

+ if (!converted)

+ return added_status;

+

+ escaped = escape_single_quotes (converted, in_single_quotes, in_double_quotes);

+ g_string_append (str, escaped);

+ g_free (escaped);

+ g_free (converted);

+

+ return added_status != ADDED_ALL ? ADDED_SINGLE : added_status;

+}

+

+static gboolean

+do_percent_subst (const MateDesktopItem *item,

+ const char *arg,

+ GString *str,

+ gboolean in_single_quotes,

+ gboolean in_double_quotes,

+ GSList *args,

+ GSList **arg_ptr,

+ AddedStatus *added_status)

+{

+ char *esc;

+ const char *cs;

+

+ if (arg[0] != '%' || arg[1] == '\0') {

+ return FALSE;

+ }

+

+ switch (arg[1]) {

+ case '%':

+ g_string_append_c (str, '%');

+ break;

+ case 'U':

+ *added_status = append_all_converted (str,

+ URI_TO_STRING,

+ args,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'F':

+ *added_status = append_all_converted (str,

+ URI_TO_LOCAL_PATH,

+ args,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'N':

+ *added_status = append_all_converted (str,

+ URI_TO_LOCAL_BASENAME,

+ args,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'D':

+ *added_status = append_all_converted (str,

+ URI_TO_LOCAL_DIRNAME,

+ args,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'f':

+ *added_status = append_first_converted (str,

+ URI_TO_LOCAL_PATH,

+ arg_ptr,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'u':

+ *added_status = append_first_converted (str,

+ URI_TO_STRING,

+ arg_ptr,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'd':

+ *added_status = append_first_converted (str,

+ URI_TO_LOCAL_DIRNAME,

+ arg_ptr,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'n':

+ *added_status = append_first_converted (str,

+ URI_TO_LOCAL_BASENAME,

+ arg_ptr,

+ in_single_quotes,

+ in_double_quotes,

+ *added_status);

+ break;

+ case 'm':

+ /* Note: v0.9.4 of the spec says this is deprecated

+ * and replace with --miniicon iconname */

+ cs = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_MINI_ICON);

+ if (cs != NULL) {

+ g_string_append (str, "--miniicon=");

+ esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);

+ g_string_append (str, esc);

+ }

+ break;

+ case 'i':

+ /* Note: v0.9.4 of the spec says replace with --icon iconname */

+ cs = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_ICON);

+ if (cs != NULL) {

+ g_string_append (str, "--icon=");

+ esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);

+ g_string_append (str, esc);

+ }

+ break;

+ case 'c':

+ cs = mate_desktop_item_get_localestring (item, MATE_DESKTOP_ITEM_NAME);

+ if (cs != NULL) {

+ esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);

+ g_string_append (str, esc);

+ g_free (esc);

+ }

+ break;

+ case 'k':

+ if (item->location != NULL) {

+ esc = escape_single_quotes (item->location, in_single_quotes, in_double_quotes);

+ g_string_append (str, esc);

+ g_free (esc);

+ }

+ break;

+ case 'v':

+ cs = mate_desktop_item_get_localestring (item, MATE_DESKTOP_ITEM_DEV);

+ if (cs != NULL) {

+ esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);

+ g_string_append (str, esc);

+ g_free (esc);

+ }

+ break;

+ default:

+ /* Maintain special characters - e.g. "%20" */

+ if (g_ascii_isdigit (arg [1]))

+ g_string_append_c (str, '%');

+ return FALSE;

+ }

+

+ return TRUE;

+}

+

+static char *

+expand_string (const MateDesktopItem *item,

+ const char *s,

+ GSList *args,

+ GSList **arg_ptr,

+ AddedStatus *added_status)

+{

+ const char *p;

+ gboolean escape = FALSE;

+ gboolean single_quot = FALSE;

+ gboolean double_quot = FALSE;

+ GString *gs = g_string_new (NULL);

+

+ for (p = s; *p != '\0'; p++) {

+ if (escape) {

+ escape = FALSE;

+ g_string_append_c (gs, *p);

+ } else if (*p == '\\') {

+ if ( ! single_quot)

+ escape = TRUE;

+ g_string_append_c (gs, *p);

+ } else if (*p == '\'') {

+ g_string_append_c (gs, *p);

+ if ( ! single_quot && ! double_quot) {

+ single_quot = TRUE;

+ } else if (single_quot) {

+ single_quot = FALSE;

+ }

+ } else if (*p == '"') {

+ g_string_append_c (gs, *p);

+ if ( ! single_quot && ! double_quot) {

+ double_quot = TRUE;

+ } else if (double_quot) {

+ double_quot = FALSE;

+ }

+ } else if (*p == '%') {

+ if (do_percent_subst (item, p, gs,

+ single_quot, double_quot,

+ args, arg_ptr,

+ added_status)) {

+ p++;

+ }

+ } else {

+ g_string_append_c (gs, *p);

+ }

+ }

+ return g_string_free (gs, FALSE);

+}

+

+#ifdef HAVE_STARTUP_NOTIFICATION

+static void

+sn_error_trap_push (SnDisplay *display,

+ Display *xdisplay)

+{

+ gdk_error_trap_push ();

+}

+

+static void

+sn_error_trap_pop (SnDisplay *display,

+ Display *xdisplay)

+{

+ gdk_error_trap_pop ();

+}

+

+static char **

+make_spawn_environment_for_sn_context (SnLauncherContext *sn_context,

+ char **envp)

+{

+ char **retval;

+ char **freeme;

+ int i, j;

+ int desktop_startup_id_len;

+

+ retval = freeme = NULL;

+

+ if (envp == NULL) {

+ envp = freeme = g_listenv ();

+ for (i = 0; envp[i]; i++) {

+ char *name = envp[i];

+

+ envp[i] = g_strjoin ("=", name, g_getenv (name), NULL);

+ g_free (name);

+ }

+ } else {

+ for (i = 0; envp[i]; i++)

+ ;

+ }

+

+ retval = g_new (char *, i + 2);

+

+ desktop_startup_id_len = strlen ("DESKTOP_STARTUP_ID");

+

+ for (i = 0, j = 0; envp[i]; i++) {

+ if (strncmp (envp[i], "DESKTOP_STARTUP_ID", desktop_startup_id_len) != 0) {

+ retval[j] = g_strdup (envp[i]);

+ ++j;

+ }

+ }

+

+ retval[j] = g_strdup_printf ("DESKTOP_STARTUP_ID=%s",

+ sn_launcher_context_get_startup_id (sn_context));

+ ++j;

+ retval[j] = NULL;

+

+ g_strfreev (freeme);

+

+ return retval;

+}

+

+/* This should be fairly long, as it's confusing to users if a startup

+ * ends when it shouldn't (it appears that the startup failed, and

+ * they have to relaunch the app). Also the timeout only matters when

+ * there are bugs and apps don't end their own startup sequence.

+ *

+ * This timeout is a "last resort" timeout that ignores whether the

+ * startup sequence has shown activity or not. Marco and the

+ * tasklist have smarter, and correspondingly able-to-be-shorter

+ * timeouts. The reason our timeout is dumb is that we don't monitor

+ * the sequence (don't use an SnMonitorContext)

+ */

+#define STARTUP_TIMEOUT_LENGTH_SEC 30 /* seconds */

+#define STARTUP_TIMEOUT_LENGTH (STARTUP_TIMEOUT_LENGTH_SEC * 1000)

+

+typedef struct

+{

+ GdkScreen *screen;

+ GSList *contexts;

+ guint timeout_id;

+} StartupTimeoutData;

+

+static void

+free_startup_timeout (void *data)

+{

+ StartupTimeoutData *std = data;

+

+ g_slist_foreach (std->contexts,

+ (GFunc) sn_launcher_context_unref,

+ NULL);

+ g_slist_free (std->contexts);

+

+ if (std->timeout_id != 0) {

+ g_source_remove (std->timeout_id);

+ std->timeout_id = 0;

+ }

+

+ g_free (std);

+}

+

+static gboolean

+startup_timeout (void *data)

+{

+ StartupTimeoutData *std = data;

+ GSList *tmp;

+ GTimeVal now;

+ int min_timeout;

+

+ min_timeout = STARTUP_TIMEOUT_LENGTH;

+

+ g_get_current_time (&now);

+

+ tmp = std->contexts;

+ while (tmp != NULL) {

+ SnLauncherContext *sn_context = tmp->data;

+ GSList *next = tmp->next;

+ long tv_sec, tv_usec;

+ double elapsed;

+

+ sn_launcher_context_get_last_active_time (sn_context,

+ &tv_sec, &tv_usec);

+

+ elapsed =

+ ((((double)now.tv_sec - tv_sec) * G_USEC_PER_SEC +

+ (now.tv_usec - tv_usec))) / 1000.0;

+

+ if (elapsed >= STARTUP_TIMEOUT_LENGTH) {

+ std->contexts = g_slist_remove (std->contexts,

+ sn_context);

+ sn_launcher_context_complete (sn_context);

+ sn_launcher_context_unref (sn_context);

+ } else {

+ min_timeout = MIN (min_timeout, (STARTUP_TIMEOUT_LENGTH - elapsed));

+ }

+

+ tmp = next;

+ }

+

+ /* we'll use seconds for the timeout */

+ if (min_timeout < 1000)

+ min_timeout = 1000;

+

+ if (std->contexts == NULL) {

+ std->timeout_id = 0;

+ } else {

+ std->timeout_id = g_timeout_add_seconds (min_timeout / 1000,

+ startup_timeout,

+ std);

+ }

+

+ /* always remove this one, but we may have reinstalled another one. */

+ return FALSE;

+}

+

+static void

+add_startup_timeout (GdkScreen *screen,

+ SnLauncherContext *sn_context)

+{

+ StartupTimeoutData *data;

+

+ data = g_object_get_data (G_OBJECT (screen), "mate-startup-data");

+ if (data == NULL) {

+ data = g_new (StartupTimeoutData, 1);

+ data->screen = screen;

+ data->contexts = NULL;

+ data->timeout_id = 0;

+

+ g_object_set_data_full (G_OBJECT (screen), "mate-startup-data",

+ data, free_startup_timeout);

+ }

+

+ sn_launcher_context_ref (sn_context);

+ data->contexts = g_slist_prepend (data->contexts, sn_context);

+

+ if (data->timeout_id == 0) {

+ data->timeout_id = g_timeout_add_seconds (

+ STARTUP_TIMEOUT_LENGTH_SEC,

+ startup_timeout,

+ data);

+ }

+}

+#endif /* HAVE_STARTUP_NOTIFICATION */

+

+static inline char *

+stringify_uris (GSList *args)

+{

+ GString *str;

+

+ str = g_string_new (NULL);

+

+ append_all_converted (str, URI_TO_STRING, args, FALSE, FALSE, ADDED_NONE);

+

+ return g_string_free (str, FALSE);

+}

+

+static inline char *

+stringify_files (GSList *args)

+{

+ GString *str;

+

+ str = g_string_new (NULL);

+

+ append_all_converted (str, URI_TO_LOCAL_PATH, args, FALSE, FALSE, ADDED_NONE);

+

+ return g_string_free (str, FALSE);

+}

+

+static char **

+make_environment_for_screen (GdkScreen *screen,

+ char **envp)

+{

+ char **retval;

+ char **freeme;

+ char *display_name;

+ int display_index = -1;

+ int i, env_len;

+

+ g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);

+

+ retval = freeme = NULL;

+

+ if (envp == NULL) {

+ envp = freeme = g_listenv ();

+ for (i = 0; envp [i]; i++) {

+ char *name = envp[i];

+

+ envp[i] = g_strjoin ("=", name, g_getenv (name), NULL);

+ g_free (name);

+ }

+ }

+

+ for (env_len = 0; envp [env_len]; env_len++)

+ if (strncmp (envp [env_len], "DISPLAY", strlen ("DISPLAY")) == 0)

+ display_index = env_len;

+

+ retval = g_new (char *, env_len + 1);