DISTCHECK_CONFIGURE_FLAGS = \

--enable-gtk-doc \

if MATE_ABOUT_ENABLED

versiondir = $(datadir)/mate-about

mate-desktop 1.16.0

* mate-bg: remove unneeded ignore-pending-change property

m4_define([mate_platform], [1])

m4_define([mate_micro], [0])

m4_define(mate_version, [mate_platform.mate_minor.mate_micro]),

AC_DEFINE([GLIB_VERSION_MIN_REQUIRED], [GLIB_VERSION_2_36],

[Warn on use of APIs deprecated before GLib 2.36])

AC_ARG_ENABLE([mate-about],

[AS_HELP_STRING([--disable-mate-about],[do not build mate-about])],,

[enable_mate_about=yes])

EXTERNAL_PNP_IDS="$with_pnp_ids_path"

fi

GLIB_REQUIRED=2.36.0

GIO_REQUIRED=2.26.0

XRANDR_REQUIRED=1.3

dnl ----------------------------------------------------------------------------

dnl DCONF

dnl ----------------------------------------------------------------------------

dnl pkg-config dependency checks

AC_SUBST(MATE_ABOUT_CFLAGS)

AC_SUBST(MATE_ABOUT_LIBS)

Maintainer mode: ${USE_MAINTAINER_MODE}

Use *_DISABLE_DEPRECATED: ${enable_deprecation_flags}

Build mate-about: ${enable_mate_about}

Install mpaste: ${enable_mpaste}

Use external pnp.ids: ${EXTERNAL_PNP_IDS}

if HAVE_INTROSPECTION

MateDesktop-2.0.gir: libmate-desktop-2.la

MateDesktop_2_0_gir_CFLAGS = -DMATE_DESKTOP_USE_UNSTABLE_API -I$(top_srcdir)

MateDesktop_2_0_gir_LIBS = libmate-desktop-2.la

MateDesktop_2_0_gir_FILES = $(introspection_sources) $(libmate_desktop_HEADERS)

gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (dialog)), 5);

/* Widgets */

vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);

gtk_container_set_focus_chain (GTK_CONTAINER (vbox), NULL);

gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);

gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (dialog)), vbox, TRUE, TRUE, 0);

gtk_label_set_selectable (GTK_LABEL (priv->comments_label), TRUE);

gtk_label_set_justify (GTK_LABEL (priv->comments_label), GTK_JUSTIFY_CENTER);

gtk_label_set_line_wrap (GTK_LABEL (priv->comments_label), TRUE);

gtk_label_set_max_width_chars (GTK_LABEL (priv->comments_label), 60);

gtk_box_pack_start (GTK_BOX (vbox), priv->comments_label, FALSE, FALSE, 0);

priv->copyright_label = gtk_label_new (NULL);

gtk_label_set_justify (GTK_LABEL (priv->copyright_label), GTK_JUSTIFY_CENTER);

gtk_box_pack_start (GTK_BOX (vbox), priv->copyright_label, FALSE, FALSE, 0);

hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0);

priv->website_label = button = gtk_label_new ("");

gtk_window_set_resizable (GTK_WINDOW (about), FALSE);

gtk_widget_grab_default (close_button);

gtk_widget_grab_focus (close_button);

g_slist_foreach (priv->visited_links, (GFunc)g_free, NULL);

g_slist_free (priv->visited_links);

g_object_unref (priv->hand_cursor);

g_object_unref (priv->regular_cursor);

G_OBJECT_CLASS (mate_about_dialog_parent_class)->finalize (object);

}

GdkEventVisibility *event,

MateAboutDialog *about)

{

GdkDeviceManager *device_manager;

GdkDevice *device;

gint wx, wy, bx, by;

device_manager = gdk_display_get_device_manager (gtk_widget_get_display(text_view));

device = gdk_device_manager_get_client_pointer (device_manager);

gdk_window_get_device_position (gtk_widget_get_window (text_view), device, &wx, &wy, NULL);

gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),

GTK_TEXT_WINDOW_WIDGET,

#include <mate-bg.h>

#include "mate-bg-crossfade.h"

struct _MateBGCrossfadePrivate

{

GdkWindow *window;

cairo_surface_t *copy;

cairo_t *cr;

if (surface == NULL)

{

copy = gdk_window_create_similar_surface (gdk_get_default_root_window (),

cairo_surface_get_content (surface),

width, height);

}

cr = cairo_create (copy);

}

else

{

GtkStyleContext *context;

GdkRGBA bg;

context = gtk_style_context_new ();

gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg);

gdk_cairo_set_source_rgba(cr, &bg);

g_object_unref (G_OBJECT (context));

}

cairo_paint (cr);

* could not be copied.

**/

gboolean

mate_bg_crossfade_set_start_surface (MateBGCrossfade* fade, cairo_surface_t *surface)

{

g_return_val_if_fail (MATE_IS_BG_CROSSFADE (fade), FALSE);

* could not be copied.

**/

gboolean

mate_bg_crossfade_set_end_surface (MateBGCrossfade* fade, cairo_surface_t *surface)

{

g_return_val_if_fail (MATE_IS_BG_CROSSFADE (fade), FALSE);

g_assert (fade->priv->end_surface != NULL);

cairo_pattern_t *pattern;

pattern = cairo_pattern_create_for_surface (fade->priv->end_surface);

gdk_window_set_background_pattern (fade->priv->window, pattern);

cairo_pattern_destroy (pattern);

draw_background (fade);

cairo_surface_destroy (fade->priv->end_surface);

g_source_unref (source);

fade->priv->window = window;

cairo_pattern_t *pattern;

pattern = cairo_pattern_create_for_surface (fade->priv->fading_surface);

gdk_window_set_background_pattern (fade->priv->window, pattern);

cairo_pattern_destroy (pattern);

draw_background (fade);

fade->priv->is_first_frame = TRUE;

GType mate_bg_crossfade_get_type (void);

MateBGCrossfade *mate_bg_crossfade_new (int width, int height);

gboolean mate_bg_crossfade_set_start_surface (MateBGCrossfade *fade,

cairo_surface_t *surface);

gboolean mate_bg_crossfade_set_end_surface (MateBGCrossfade *fade,

cairo_surface_t *surface);

void mate_bg_crossfade_start (MateBGCrossfade *fade,

GdkWindow *window);

#include <mate-bg.h>

#include <mate-bg-crossfade.h>

# include <cairo-xlib.h>

#define MATE_BG_CACHE_DIR "mate/background"

char *filename;

MateBGPlacement placement;

MateBGColorType color_type;

GdkRGBA primary;

GdkRGBA secondary;

gboolean is_enabled;

GFileMonitor* file_monitor;

G_DEFINE_TYPE(MateBG, mate_bg, G_TYPE_OBJECT)

static cairo_surface_t *make_root_pixmap (GdkWindow *window,

gint width,

gint height);

/* Pixbuf utils */

static void pixbuf_average_value (GdkPixbuf *pixbuf,

GdkRGBA *result);

static GdkPixbuf *pixbuf_scale_to_fit (GdkPixbuf *src,

int max_width,

int max_height);

static void pixbuf_draw_gradient (GdkPixbuf *pixbuf,

gboolean horizontal,

GdkRGBA *c1,

GdkRGBA *c2,

GdkRectangle *rect);

static void pixbuf_tile (GdkPixbuf *src,

gint width,

gint height);

static void

color_from_string (const char *string,

GdkRGBA *colorp)

((guint) (color->green * 65535)) >> 8,

((guint) (color->blue * 65535)) >> 8);

}

static gboolean

do_changed (MateBG *bg)

char *tmp;

char *filename;

MateBGColorType ctype;

GdkRGBA c1, c2;

MateBGPlacement placement;

g_return_if_fail (MATE_IS_BG (bg));

void

mate_bg_set_color (MateBG *bg,

MateBGColorType type,

GdkRGBA *primary,

GdkRGBA *secondary)

{

g_return_if_fail (bg != NULL);

g_return_if_fail (primary != NULL);

if (bg->color_type != type ||

!gdk_rgba_equal (&bg->primary, primary) ||

(secondary && !gdk_rgba_equal (&bg->secondary, secondary))) {

bg->color_type = type;

bg->primary = *primary;

if (secondary) {

void

mate_bg_get_color (MateBG *bg,

MateBGColorType *type,

GdkRGBA *primary,

GdkRGBA *secondary)

{

g_return_if_fail (bg != NULL);

switch (bg->color_type) {

case MATE_BG_COLOR_SOLID:

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

pixel = (((guint) bg->primary.red * 65535) >> 8) << 24 |

(((guint) bg->primary.green * 65535) >> 8) << 24 |

(((guint) bg->primary.blue * 65535) >> 8) << 24 |

(0xff);

gdk_pixbuf_fill (dest, pixel);

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

* who created it.

**/

cairo_surface_t *

mate_bg_create_surface (MateBG *bg,

GdkWindow *window,

int width,

int height,

}

else

{

surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR,

pm_width, pm_height);

}

cr = cairo_create (surface);

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

gdk_cairo_set_source_rgba (cr, &(bg->primary));

}

else

{

int width,

int height)

{

GdkRGBA color;

int intensity;

GdkPixbuf *pixbuf;

}

pixbuf = get_pixbuf_for_size (bg, -1, width, height);

if (pixbuf) {

GdkRGBA argb;

guchar a, r, g, b;

r = argb.red * 0xff;

g = argb.green * 0xff;

b = argb.blue * 0xff;

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

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

g_object_unref (pixbuf);

}

intensity = ((guint) (color.red * 65535) * 77 +

(guint) (color.green * 65535) * 150 +

(guint) (color.blue * 65535) * 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 cairo_surface_t *

make_root_pixmap (GdkWindow *window, gint width, gint height)

{

GdkScreen *screen = gdk_window_get_screen(window);

XSetCloseDownMode (display, RetainPermanent);

XCloseDisplay (display);

surface = cairo_xlib_surface_create (GDK_SCREEN_XDISPLAY (screen), xpixmap,

GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (screen)),

width, height);

return surface;

}

*

* Return value: a #cairo_surface_t if successful or %NULL

**/

cairo_surface_t *

mate_bg_get_surface_from_root (GdkScreen *screen)

{

int result;

gint format;

if (data != NULL) {

gdk_error_trap_push ();

Pixmap xpixmap = *(Pixmap *) data;

Window root_return;

int x_ret, y_ret;

}

gdk_error_trap_pop_ignored ();

}

width = gdk_screen_get_width (screen);

height = gdk_screen_get_height (screen);

if (source_pixmap) {

surface = cairo_surface_create_similar (source_pixmap,

CAIRO_CONTENT_COLOR,

CAIRO_CONTENT_COLOR,

width, height);

}

if (source_pixmap != NULL)

cairo_surface_destroy (source_pixmap);

if (esetrootpmap && esetrootpmap != xrootpmap) {

XKillClient (display, esetrootpmap);

}

gdk_error_trap_pop_ignored ();

}

}

* to mate_bg_create_surface().

**/

void

mate_bg_set_surface_as_root (GdkScreen *screen, cairo_surface_t *surface)

{

g_return_if_fail (screen != NULL);

g_return_if_fail (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_XLIB);

/* Desktop background pixmap should be created from dummy X client since most

* applications will try to kill it with XKillClient later when changing pixmap

* Return value: (transfer full): a #MateBGCrossfade object

**/

MateBGCrossfade *

mate_bg_set_surface_as_root_with_crossfade (GdkScreen *screen,

cairo_surface_t *surface)

{

g_return_val_if_fail (screen != NULL, NULL);

g_return_val_if_fail (surface != NULL, NULL);

}

/* Pixbuf utilities */

static void

pixbuf_average_value (GdkPixbuf *pixbuf,

GdkRGBA *result)

{

guint64 a_total, r_total, g_total, b_total;

guint row, column;

int r, g, b, a;

guint64 dividend;

guint width, height;

gdouble dd;

width = gdk_pixbuf_get_width (pixbuf);

height = gdk_pixbuf_get_height (pixbuf);

dividend = height * width;

a_total = dividend * 0xFF;

}

dd = dividend * 0xFF;

result->alpha = a_total / dd;

result->red = r_total / dd;

result->green = g_total / dd;

result->blue = b_total / dd;

}

static GdkPixbuf *

}

static guchar *

create_gradient (const GdkRGBA *primary,

const GdkRGBA *secondary,

int n_pixels)

{

guchar *result = g_malloc (n_pixels * 3);

for (i = 0; i < n_pixels; ++i) {

double ratio = (i + 0.5) / n_pixels;

result[3 * i + 0] = (guchar) ((primary->red * (1 - ratio) + secondary->red * ratio) * 0x100);

result[3 * i + 1] = (guchar) ((primary->green * (1 - ratio) + secondary->green * ratio) * 0x100);

result[3 * i + 2] = (guchar) ((primary->blue * (1 - ratio) + secondary->blue * ratio) * 0x100);

}

return result;

static void

pixbuf_draw_gradient (GdkPixbuf *pixbuf,

gboolean horizontal,

GdkRGBA *primary,

GdkRGBA *secondary,

GdkRectangle *rect)

{

int width;

MateBGPlacement placement);

void mate_bg_set_color (MateBG *bg,

MateBGColorType type,

GdkRGBA *primary,

GdkRGBA *secondary);

void mate_bg_set_draw_background (MateBG *bg,

gboolean draw_background);

/* Getters */

MateBGPlacement mate_bg_get_placement (MateBG *bg);

void mate_bg_get_color (MateBG *bg,

MateBGColorType *type,

GdkRGBA *primary,

GdkRGBA *secondary);

const gchar * mate_bg_get_filename (MateBG *bg);

/* Drawing and thumbnailing */

GdkScreen *screen,

gboolean is_root);

cairo_surface_t *mate_bg_create_surface (MateBG *bg,

GdkWindow *window,

int width,

int height,

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

* these object methods, drop mate_bg_create_surface, etc.

*/

void mate_bg_set_surface_as_root (GdkScreen *screen,

cairo_surface_t *surface);

MateBGCrossfade *mate_bg_set_surface_as_root_with_crossfade (GdkScreen *screen,

cairo_surface_t *surface);

cairo_surface_t *mate_bg_get_surface_from_root (GdkScreen *screen);

G_END_DECLS

#endif

/* Handle exposure events for the color picker's drawing area */

static gboolean

draw (GtkWidget *widget,

cairo_t *cr,

gpointer data)

{

MateColorButton *color_button = MATE_COLOR_BUTTON (data);

cairo_pattern_t *checkered;

if (mate_color_button_has_alpha (color_button))

{

cairo_save (cr);

cairo_pattern_destroy (checkered);

}

return FALSE;

}

/* Create the widgets */

color_button->priv = MATE_COLOR_BUTTON_GET_PRIVATE (color_button);

alignment = gtk_alignment_new (0.5, 0.5, 0.5, 1.0);

gtk_container_set_border_width (GTK_CONTAINER (alignment), 1);

gtk_container_add (GTK_CONTAINER (color_button), alignment);

g_object_unref (layout);

gtk_widget_set_size_request (color_button->priv->draw_area, rect.width - 2, rect.height - 2);

g_signal_connect (color_button->priv->draw_area, "draw",

G_CALLBACK (draw), color_button);

gtk_container_add (GTK_CONTAINER (frame), color_button->priv->draw_area);

gtk_widget_show (color_button->priv->draw_area);

G_CALLBACK (mate_color_button_drag_data_received), color_button);

g_signal_connect (color_button, "drag-data-get",

G_CALLBACK (mate_color_button_drag_data_get), color_button);

}

static void

g_object_notify (G_OBJECT (color_button), "color");

}

/**

* mate_color_button_set_rgba:

* @color_button: a #MateColorButton.

g_object_notify (G_OBJECT (color_button), "color");

}

/**

* mate_color_button_set_alpha:

color->blue = color_button->priv->color.blue;

}

/**

* mate_color_button_get_rgba:

* @color_button: a #MateColorButton.

color->blue = color_button->priv->color.blue / 65535.;

color->alpha = color_button->priv->alpha / 65535.;

}

/**

* mate_color_button_get_alpha:

GtkWidget *mate_color_button_new_with_color (const GdkColor *color);

void mate_color_button_set_color (MateColorButton *color_button,

const GdkColor *color);

void mate_color_button_set_rgba (MateColorButton *color_button,

const GdkRGBA *color);

void mate_color_button_set_alpha (MateColorButton *color_button,

guint16 alpha);

void mate_color_button_get_color (MateColorButton *color_button,

GdkColor *color);

void mate_color_button_get_rgba (MateColorButton *color_button,

GdkRGBA *color);

guint16 mate_color_button_get_alpha (MateColorButton *color_button);

void mate_color_button_set_use_alpha (MateColorButton *color_button,

gboolean use_alpha);

#include <glib/gi18n-lib.h>

#include "mate-colorsel.h"

#define DEFAULT_COLOR_PALETTE "#ef2929:#fcaf3e:#fce94f:#8ae234:#729fcf:#ad7fa8:#e9b96e:#888a85:#eeeeec:#cc0000:#f57900:#edd400:#73d216:#3465a4:#75507b:#c17d11:#555753:#d3d7cf:#a40000:#ce5c00:#c4a000:#4e9a06:#204a87:#5c3566:#8f5902:#2e3436:#babdb6:#000000:#2e3436:#555753:#888a85:#babdb6:#d3d7cf:#eeeeec:#f3f3f3:#ffffff"

/* Number of elements in the custom palatte */

static MateColorSelectionChangePaletteFunc noscreen_change_palette_hook = default_noscreen_change_palette_func;

static MateColorSelectionChangePaletteWithScreenFunc change_palette_hook = default_change_palette_func;

static const guchar dropper_bits[] = {

"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\377\377\377\377\377\377\377"

"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\0\0\0\0\0"

"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};

G_DEFINE_TYPE (MateColorSelection, mate_color_selection, GTK_TYPE_BOX)

_mate_desktop_init_i18n ();

priv = colorsel->private_data = G_TYPE_INSTANCE_GET_PRIVATE (colorsel, MATE_TYPE_COLOR_SELECTION, ColorSelectionPrivate);

priv->changing = FALSE;

priv->default_set = FALSE;

priv->default_alpha_set = FALSE;

top_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

gtk_box_pack_start (GTK_BOX (colorsel), top_hbox, FALSE, FALSE, 0);

vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

priv->triangle_colorsel = gtk_hsv_new ();

g_signal_connect (priv->triangle_colorsel, "changed",

G_CALLBACK (hsv_changed), colorsel);

gtk_widget_set_tooltip_text (priv->triangle_colorsel,

_("Select the color you want from the outer ring. Select the darkness or lightness of that color using the inner triangle."));

hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

frame = gtk_frame_new (NULL);

gtk_widget_set_tooltip_text (button,

_("Click the eyedropper, then click a color anywhere on your screen to select that color."));

top_right_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

gtk_box_pack_start (GTK_BOX (top_hbox), top_right_vbox, FALSE, FALSE, 0);

table = gtk_table_new (8, 6, FALSE);

gtk_box_pack_start (GTK_BOX (top_right_vbox), table, FALSE, FALSE, 0);

}

}

set_selected_palette (colorsel, 0, 0);

priv->palette_frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

label = gtk_label_new_with_mnemonic (_("_Palette:"));

#if GTK_CHECK_VERSION (3, 16, 0)

gtk_label_set_xalign (GTK_LABEL (label), 0.0);

atk_object_set_role (gtk_widget_get_accessible (GTK_WIDGET (colorsel)), ATK_ROLE_COLOR_CHOOSER);

make_all_relations (atk_obj, priv);

}

}

/* GObject methods */

*

*/

static void color_sample_draw_sample (MateColorSelection *colorsel, cairo_t *cr, int which);

static void color_sample_update_samples (MateColorSelection *colorsel);

static void

/* which = 0 means draw old sample, which = 1 means draw new */

static void

color_sample_draw_sample (MateColorSelection *colorsel, cairo_t *cr, int which)

{

GtkWidget *da;

gint x, y, wid, heig, goff;

ColorSelectionPrivate *priv;

GtkAllocation allocation;

g_return_if_fail (colorsel != NULL);

goff = allocation.width % 32;

}

gtk_widget_get_allocation (da, &allocation);

wid = allocation.width;

heig = allocation.height;

cairo_rectangle (cr, 0, 0, wid, heig);

cairo_fill (cr);

}

gtk_widget_queue_draw (priv->cur_sample);

}

static gboolean

color_old_sample_draw (GtkWidget *da,

cairo_t *cr,

color_sample_draw_sample (colorsel, cr, 1);

return FALSE;

}

static void

color_sample_setup_dnd (MateColorSelection *colorsel, GtkWidget *sample)

priv = colorsel->private_data;

priv->sample_area = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

priv->old_sample = gtk_drawing_area_new ();

priv->cur_sample = gtk_drawing_area_new ();

gtk_box_pack_start (GTK_BOX (priv->sample_area), priv->cur_sample,

TRUE, TRUE, 0);

g_signal_connect (priv->old_sample, "draw",

G_CALLBACK (color_old_sample_draw),

colorsel);

g_signal_connect (priv->cur_sample, "draw",

G_CALLBACK (color_cur_sample_draw),

colorsel);

color_sample_setup_dnd (colorsel, priv->old_sample);

color_sample_setup_dnd (colorsel, priv->cur_sample);

static void

palette_paint (GtkWidget *drawing_area,

cairo_t *cr,

gpointer data)

{

gint focus_width;

GtkAllocation allocation;

gtk_widget_get_allocation (drawing_area, &allocation);

gdk_cairo_set_source_color (cr, &gtk_widget_get_style (drawing_area)->bg[GTK_STATE_NORMAL]);

cairo_rectangle (cr, 0, 0, allocation.width, allocation.height);

cairo_fill (cr);

if (gtk_widget_has_focus (drawing_area))

allocation.height - focus_width);

cairo_stroke (cr);

}

}

static void

}

static gboolean

palette_draw (GtkWidget *drawing_area,

cairo_t *cr,

gpointer data)

{

if (gtk_widget_get_window (drawing_area) == NULL)

return FALSE;

palette_paint (drawing_area, cr, data);

return FALSE;

}

| GDK_ENTER_NOTIFY_MASK

| GDK_LEAVE_NOTIFY_MASK);

g_signal_connect (retval, "draw",

G_CALLBACK (palette_draw), colorsel);

g_signal_connect (retval, "button-press-event",

G_CALLBACK (palette_press), colorsel);

g_signal_connect (retval, "button-release-event",

if (!cursor)

{

GdkPixbuf *pixbuf;

pixbuf = gdk_pixbuf_new_from_data (dropper_bits,

cursor = gdk_cursor_new_from_pixbuf (gdk_screen_get_display (screen),

pixbuf,

DROPPER_X_HOT, DROPPER_Y_HOT);

g_object_unref (pixbuf);

}

return cursor;

priv = colorsel->private_data;

pixbuf = gdk_pixbuf_get_from_window (root_window,

x_root, y_root,

1, 1);

if (!pixbuf)

{

gint x, y;

GdkWindow *window = gdk_display_get_window_at_pointer (display, &x, &y);

if (!window)

return;

pixbuf = gdk_pixbuf_get_from_window (window,

x, y,

1, 1);

if (!pixbuf)

return;

}

NULL,

picker_cursor,

time);

g_object_unref (picker_cursor);

if (grab_status != GDK_GRAB_SUCCESS)

{

gtk_widget_hide (colorseldiag->help_button);

gtk_window_set_title (GTK_WINDOW (colorseldiag),

_("Color Selection"));

Name: mate-desktop-2.0

Description: Utility library for loading .desktop files

Version: @VERSION@

Libs: ${pc_top_builddir}/${pcfiledir}/libmate-desktop-2.la

Cflags: -I${pc_top_builddir}/${pcfiledir}

Name: mate-desktop-2.0

Description: Utility library for loading .desktop files

Requires.private: dconf

Version: @VERSION@

Libs: -L${libdir} -lmate-desktop-2

sn_error_trap_pop (SnDisplay *display,

Display *xdisplay)

{

gdk_error_trap_pop_ignored ();

}

static char **

full = NULL;

if (info) {

full = g_strdup (gtk_icon_info_get_filename (info));

g_object_unref (info);

}

g_free (icon_no_extension);

}

#include "private.h"

static void

gtk_style_shade (GdkRGBA *a,

GdkRGBA *b,

hls_to_rgb (gdouble *h,

gdouble *l,

gdouble *s);

/**

* mate_desktop_prepend_terminal_to_vector:

appinfo = g_app_info_create_from_commandline (command, NULL, G_APP_INFO_CREATE_NONE, error);

if (appinfo) {

context = gdk_display_get_app_launch_context (gdk_screen_get_display (screen));

res = g_app_info_launch (appinfo, NULL, G_APP_LAUNCH_CONTEXT (context), error);

g_object_unref (context);

g_object_unref (appinfo);

}

}

/**

* gtk_style_shade:

* @a: the starting colour

gtk_style_context_get_background_color (style, state, color);

gtk_style_shade (color, color, DARKNESS_MULT);

}

/* replace gdk_spawn_command_line_on_screen, not available in GTK3 */

gboolean mate_gdk_spawn_command_line_on_screen (GdkScreen *screen, const gchar *command, GError **error);

void

mate_desktop_gtk_style_get_light_color (GtkStyleContext *style,

GtkStateFlags state,

mate_desktop_gtk_style_get_dark_color (GtkStyleContext *style,

GtkStateFlags state,

GdkRGBA *color);

G_END_DECLS

int num_outputs;

GdkRGBA *palette;

GtkWidget **windows;

GdkScreen *screen;

g_assert (labeler->priv->num_outputs > 0);

labeler->priv->palette = g_new (GdkRGBA, labeler->priv->num_outputs);

start_hue = 0.0; /* red */

end_hue = 2.0/3; /* blue */

gtk_hsv_to_rgb (h, s, v, &r, &g, &b);

labeler->priv->palette[i].red = r;

labeler->priv->palette[i].green = g;

labeler->priv->palette[i].blue = b;

labeler->priv->palette[i].alpha = 1.0;

}

}

#define LABEL_WINDOW_PADDING 12

static gboolean

label_window_draw_event_cb (GtkWidget *widget, cairo_t *cr, gpointer data)

{

GdkRGBA *color;

GtkAllocation allocation;

color = g_object_get_data (G_OBJECT (widget), "color");

gtk_widget_get_allocation (widget, &allocation);

/* edge outline */

cairo_set_source_rgb (cr, 0, 0, 0);

cairo_stroke (cr);

/* fill */

gdk_cairo_set_source_rgba (cr, color);

cairo_rectangle (cr,

LABEL_WINDOW_EDGE_THICKNESS,

LABEL_WINDOW_EDGE_THICKNESS,

allocation.height - LABEL_WINDOW_EDGE_THICKNESS * 2);

cairo_fill (cr);

return FALSE;

}

gtk_window_move (GTK_WINDOW (window), workarea.x, workarea.y);

}

static GtkWidget *

create_label_window (MateRRLabeler *labeler, MateRROutputInfo *output, GdkRGBA *color)

{

GtkWidget *window;

GtkWidget *widget;

*/

g_object_set_data (G_OBJECT (window), "color", color);

g_signal_connect (window, "draw",

G_CALLBACK (label_window_draw_event_cb), labeler);

if (mate_rr_config_get_clone (labeler->priv->config)) {

/* Keep this string in sync with mate-control-center/capplets/display/xrandr-capplet.c:get_display_name() */

* theme's colors, since the label is always shown against a light

* pastel background. See bgo#556050

*/

gtk_widget_modify_fg (widget, gtk_widget_get_state_flags (widget), &black);

gtk_container_add (GTK_CONTAINER (window), widget);

priv->windows = NULL;

}

/**

* mate_rr_labeler_get_rgba_for_output:

* @labeler: A #MateRRLabeler

color_out->blue = 1.0;

color_out->alpha = 1.0;

}

void mate_rr_labeler_hide (MateRRLabeler *labeler);

void mate_rr_labeler_get_rgba_for_output (MateRRLabeler *labeler, MateRROutputInfo *output, GdkRGBA *color_out);

#endif

info->primary = None;

gdk_error_trap_push ();

info->primary = XRRGetOutputPrimary (xdisplay, xroot);

gdk_error_trap_pop_ignored ();

return TRUE;

#else

gdk_error_trap_push ();

XRRSetScreenSize (screen->priv->xdisplay, screen->priv->xroot,

width, height, mm_width, mm_height);

gdk_error_trap_pop_ignored ();

#endif

}

textdomain(package);

#endif

static void mate_about_on_activate(GtkApplication* app)

{

GList* list;

}

}

void mate_about_run(void)

{

mate_about_dialog = (MateAboutDialog*) mate_about_dialog_new();

* displayed in the about box to give credit to the translator(s). */

mate_about_dialog_set_translator_credits(mate_about_dialog, _("translator-credits"));

gtk_window_set_application(GTK_WINDOW(mate_about_dialog), mate_about_application);

// start and destroy

gtk_dialog_run((GtkDialog*) mate_about_dialog);

mate_gettext(GETTEXT_PACKAGE, LOCALE_DIR, "UTF-8");

GOptionContext* context = g_option_context_new(NULL);

g_option_context_add_main_entries(context, command_entries, GETTEXT_PACKAGE);

g_option_context_add_group(context, gtk_get_option_group(TRUE));

g_option_context_parse(context, &argc, &argv, NULL);

g_option_context_free(context);

if (mate_about_nogui == TRUE)

{

gtk_init(&argc, &argv);

mate_about_application = gtk_application_new("org.mate.about", 0);

g_signal_connect(mate_about_application, "activate", G_CALLBACK(mate_about_on_activate), NULL);

status = g_application_run(G_APPLICATION(mate_about_application), argc, argv);

g_object_unref(mate_about_application);

}

return status;

// widget for mate-about window

MateAboutDialog* mate_about_dialog = FALSE;

GtkApplication* mate_about_application;

/**

* If this value is set to TRUE, then mate_about_dialog will not be called

void mate_about_run(void);

void mate_about_release_version(void);

static void mate_about_on_activate(GtkApplication* app);

// arguments definitions

static GOptionEntry command_entries[] = {