uidir = $(datadir)/mate-panel/ui

ui_DATA = \

panel-properties-dialog-gtk3.ui \

panel-run-dialog.ui \

panel-test-applets.ui

}

/* Set up theme and transparency support */

GtkWidget *toplevel = gtk_widget_get_toplevel (menu);

/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */

GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));

context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));

gtk_style_context_add_class(context,"gnome-panel-menu-bar");

gtk_style_context_add_class(context,"mate-panel-menu-bar");

return menu;

}

{

GtkAllocation allocation;

GtkRequisition requisition;

GdkDevice *device;

GdkScreen *screen;

GtkWidget *parent;

int menu_x = 0;

screen = gtk_widget_get_screen (applet);

gtk_widget_get_preferred_size (GTK_WIDGET (menu), &requisition, NULL);

gdk_window_get_origin (gtk_widget_get_window (applet), &menu_x, &menu_y);

#if GTK_CHECK_VERSION(3, 20, 0)

device = gdk_seat_get_pointer (gdk_display_get_default_seat (gtk_widget_get_display (applet)));

gdk_window_get_device_position (gtk_widget_get_window (applet), device, &pointer_x, &pointer_y, NULL);

device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gtk_widget_get_display (applet)));

gdk_window_get_device_position (gtk_widget_get_window (applet), device, &pointer_x, &pointer_y, NULL);

#endif

gtk_widget_get_allocation (applet, &allocation);

*x = menu_x;

*y = menu_y;

*push_in = FALSE;

}

static void

static void

button_widget_realize(GtkWidget *widget)

{

gtk_widget_add_events (widget, GDK_POINTER_MOTION_MASK |

GDK_POINTER_MOTION_HINT_MASK |

GDK_KEY_PRESS_MASK);

GTK_WIDGET_CLASS (button_widget_parent_class)->realize (widget);

BUTTON_WIDGET (widget)->priv->icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));

g_signal_connect_object (BUTTON_WIDGET (widget)->priv->icon_theme,

"changed",

G_CALLBACK (button_widget_icon_theme_changed),

widget,

G_CONNECT_SWAPPED);

button_widget_reload_pixbuf (BUTTON_WIDGET (widget));

static void

button_widget_unrealize (GtkWidget *widget)

{

g_signal_handlers_disconnect_by_func (BUTTON_WIDGET (widget)->priv->icon_theme,

G_CALLBACK (button_widget_icon_theme_changed),

widget);

GTK_WIDGET_CLASS (button_widget_parent_class)->unrealize (widget);

}

g_free (error);

}

gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_pixbuf (button->priv->pixbuf));

}

int button_height,

int *x,

int *y,

gdouble *angle,

gdouble *size)

{

GtkArrowType retval = GTK_ARROW_UP;

double scale;

scale = (orientation & PANEL_HORIZONTAL_MASK ? button_height : button_width) / 48.0;

*size = 12 * scale;

*angle = 0;

switch (orientation) {

case PANEL_ORIENTATION_TOP:

*x = scale * 3;

*y = scale * (48 - 13);

*angle = G_PI;

retval = GTK_ARROW_DOWN;

break;

case PANEL_ORIENTATION_BOTTOM:

*x = scale * (48 - 13);

*y = scale * 1;

*angle = 0;

retval = GTK_ARROW_UP;

break;

case PANEL_ORIENTATION_LEFT:

*x = scale * (48 - 13);

*y = scale * 3;

*angle = G_PI / 2;

retval = GTK_ARROW_RIGHT;

break;

case PANEL_ORIENTATION_RIGHT:

*x = scale * 1;

*y = scale * 3;

*angle = 3 * (G_PI / 2);

retval = GTK_ARROW_LEFT;

break;

}

}

static gboolean

button_widget_draw (GtkWidget *widget,

cairo_t *cr)

{

ButtonWidget *button_widget;

int width;

int height;

GtkStyleContext *context;

GtkStateFlags state_flags;

int off;

int x, y, w, h;

GdkPixbuf *pb = NULL;

g_return_val_if_fail (BUTTON_IS_WIDGET (widget), FALSE);

button_widget = BUTTON_WIDGET (widget);

if (!button_widget->priv->pixbuf_hc && !button_widget->priv->pixbuf)

return FALSE;

state_flags = gtk_widget_get_state_flags (widget);

width = gtk_widget_get_allocated_width (widget);

height = gtk_widget_get_allocated_height (widget);

/* offset for pressed buttons */

off = (button_widget->priv->activatable &&

(state_flags & GTK_STATE_FLAG_PRELIGHT) && (state_flags & GTK_STATE_FLAG_ACTIVE)) ?

BUTTON_WIDGET_DISPLACEMENT * height / 48.0 : 0;

if (!button_widget->priv->activatable) {

pb = gdk_pixbuf_copy (button_widget->priv->pixbuf);

0.8,

TRUE);

} else if (panel_global_config_get_highlight_when_over () &&

(state_flags & GTK_STATE_FLAG_PRELIGHT || gtk_widget_has_focus (widget)))

pb = g_object_ref (button_widget->priv->pixbuf_hc);

else

pb = g_object_ref (button_widget->priv->pixbuf);

w = gdk_pixbuf_get_width (pb);

h = gdk_pixbuf_get_height (pb);

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

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

cairo_save (cr);

gdk_cairo_set_source_pixbuf (cr, pb, x, y);

cairo_paint (cr);

cairo_restore (cr);

g_object_unref (pb);

context = gtk_widget_get_style_context (widget);

if (button_widget->priv->arrow) {

gtk_style_context_restore (context);

}

return FALSE;

}

static void

button_widget_get_preferred_width (GtkWidget *widget,

gint *minimal_width,

*minimal_height = *natural_height = size;

}

static void

button_widget_size_allocate (GtkWidget *widget,

ButtonWidget *button_widget = BUTTON_WIDGET (widget);

int size;

GTK_WIDGET_CLASS (button_widget_parent_class)->size_allocate (widget, allocation);

if (button_widget->priv->orientation & PANEL_HORIZONTAL_MASK)

size = allocation->height;

button_widget_reload_pixbuf (button_widget);

}

}

static void

g_return_val_if_fail (BUTTON_IS_WIDGET (widget), FALSE);

GtkStateFlags state_flags = gtk_widget_get_state_flags (widget);

in_button = state_flags & GTK_STATE_FLAG_PRELIGHT;

GTK_WIDGET_CLASS (button_widget_parent_class)->enter_notify_event (widget, event);

state_flags = gtk_widget_get_state_flags (widget);

if (in_button != (state_flags & GTK_STATE_FLAG_PRELIGHT) &&

panel_global_config_get_highlight_when_over ())

gtk_widget_queue_draw (widget);

g_return_val_if_fail (BUTTON_IS_WIDGET (widget), FALSE);

GtkStateFlags state_flags = gtk_widget_get_state_flags (widget);

in_button = state_flags & GTK_STATE_FLAG_PRELIGHT;

GTK_WIDGET_CLASS (button_widget_parent_class)->leave_notify_event (widget, event);

state_flags = gtk_widget_get_state_flags (widget);

if (in_button != (state_flags & GTK_STATE_FLAG_PRELIGHT) &&

panel_global_config_get_highlight_when_over ())

gtk_widget_queue_draw (widget);

widget_class->realize = button_widget_realize;

widget_class->unrealize = button_widget_unrealize;

widget_class->size_allocate = button_widget_size_allocate;

widget_class->get_preferred_width = button_widget_get_preferred_width;

widget_class->get_preferred_height = button_widget_get_preferred_height;

widget_class->draw = button_widget_draw;

widget_class->button_press_event = button_widget_button_press;

widget_class->enter_notify_event = button_widget_enter_notify;

widget_class->leave_notify_event = button_widget_leave_notify;

#define __EGG_SM_CLIENT_PRIVATE_H__

#include <gtk/gtk.h>

#include "eggsmclient.h"

#ifdef __cplusplus

xsmp->client_id = g_strdup (ret_client_id);

free (ret_client_id);

gdk_x11_set_sm_client_id (xsmp->client_id);

g_debug ("Got client ID \"%s\"", xsmp->client_id);

}

EggSMClientXSMP *xsmp = data;

EggSMClient *client = data;

xsmp->idle = 0;

if (xsmp->waiting_to_emit_quit)

}

out:

return FALSE;

}

{

IceProcessMessagesStatus status;

status = IceProcessMessages (ice_conn, NULL, NULL);

switch (status)

{

#include <string.h>

#include <gtk/gtk.h>

#include <gtk/gtkx.h>

#include "panel-applet-container.h"

#include "panel-marshal.h"

#include "panel-color.h"

/**

* rgb_to_hls:

* @r: on input, red; on output, hue

b->green = green;

b->blue = blue;

}

#ifndef PANEL_COLOR_H

#define PANEL_COLOR_H

G_BEGIN_DECLS

void gtk_style_shade (GdkRGBA *a, GdkRGBA *b, gdouble k);

G_END_DECLS

if (info) {

path = g_strdup (gtk_icon_info_get_filename (info));

g_object_unref (info);

}

}

g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);

g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

GdkDisplay *display = gdk_display_get_default ();

context = gdk_display_get_app_launch_context (display);

gdk_app_launch_context_set_screen (context, screen);

gdk_app_launch_context_set_timestamp (context, timestamp);

#ifndef PANEL_SHOW_H

#define PANEL_SHOW_H

#ifdef __cplusplus

extern "C" {

#include <glib.h>

#include <gio/gio.h>

#include "panel-xdg.h"

#ifndef PANEL_XDG_H

#define PANEL_XDG_H

#ifdef __cplusplus

extern "C" {

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include <libmate-desktop/mate-gsettings.h>

#include <libpanel-util/panel-keyfile.h>

#include <libpanel-util/panel-xdg.h>

if (viewable)

xgrab_shell = parent;

parent = gtk_menu_shell_get_parent_shell (GTK_MENU_SHELL (parent));

}

/*only grab if this HAD a grab before*/

/* FIXME fix for GTK3 */

if (xgrab_shell && (GTK_MENU_SHELL (xgrab_shell)->have_xgrab))

{

GdkWindow *window = gtk_widget_get_window (xgrab_shell);

if (viewable)

xgrab_shell = parent;

parent = gtk_menu_shell_get_parent_shell (GTK_MENU_SHELL (parent));

}

if (xgrab_shell)

{

gboolean status;

GdkDisplay *display;

GdkDevice *pointer;

#else

GdkDeviceManager *device_manager;

#endif

GdkWindow *window = gtk_widget_get_window (xgrab_shell);

GdkCursor *cursor = gdk_cursor_new_for_display (gdk_display_get_default (),

GDK_ARROW);

display = gdk_window_get_display (window);

#if GTK_CHECK_VERSION(3, 20, 0)

seat = gdk_display_get_default_seat (display);

GDK_KEY_PRESS | GDK_KEY_RELEASE,

NULL, GDK_CURRENT_TIME) == GDK_GRAB_SUCCESS)

{

/* FIXME fix for GTK3 */

GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;

#endif

}

else

{

gdk_device_ungrab (pointer, GDK_CURRENT_TIME);

}

}

g_object_unref (cursor);

}

}

/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */

GtkWidget *toplevel = gtk_widget_get_toplevel (menu);

GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));

GdkVisual *visual = gdk_screen_get_rgba_visual(screen);

gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);

return menu;

}

GtkWidget *

{

guint idle_id;

GList *list, *l;

list = gtk_container_get_children (GTK_CONTAINER (menu));

for (l = list; l; l = l->next)

gtk_widget_destroy (l->data);

g_list_free (list);

g_object_set_data_full (G_OBJECT (menu),

"panel-menu-tree-directory",

matemenu_tree_unref (tree);

/*HACK Fix any failures of compiz/other wm's to communicate with gtk for transparency */

GtkWidget *toplevel = gtk_widget_get_toplevel (menu);

GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));

GdkVisual *visual = gdk_screen_get_rgba_visual(screen);

gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);

return menu;

}

GdkEventKey *event)

{

gboolean retval = FALSE;

GtkWidget *active_menu_item = NULL;

if ((event->keyval == GDK_KEY_Menu) ||

(event->keyval == GDK_KEY_F10 &&

(event->state & gtk_accelerator_get_default_mod_mask ()) == GDK_SHIFT_MASK)) {

GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget);

active_menu_item = gtk_menu_shell_get_selected_item (menu_shell);

if (active_menu_item && gtk_menu_item_get_submenu (GTK_MENU_ITEM (active_menu_item)) == NULL) {

GdkEventButton bevent;

bevent.button = 3;

bevent.time = GDK_CURRENT_TIME;

retval = show_item_menu (active_menu_item, &bevent);

}

}

#include "panel-widget.h"

#include "applet.h"

#include <gio/gio.h>

#ifdef __cplusplus

#include "panel-util.h"

#include "nothing.h"

static void

pixbuf_reverse (GdkPixbuf *gp)

{

gtk_widget_set_double_buffered (GTK_WIDGET (geginv_canvas), FALSE);

gtk_widget_set_size_request (geginv_canvas, inv_width, inv_height);

vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

gtk_container_add (GTK_CONTAINER (geginv), vbox);

gtk_box_pack_start (GTK_BOX (vbox), geginv_canvas, TRUE, TRUE, 0);

extern "C" {

#endif

void start_screen_check (void);

void start_geginv (void);

gboolean panel_dialog_window_event (GtkWidget *window,

}

static void

panel_action_button_style_updated (PanelActionButton *button)

{

if (actions [button->priv->type].icon_name != NULL)

button_widget_set_icon_name (BUTTON_WIDGET (button), actions [button->priv->type].icon_name);

panel_action_button_connect_to_gsettings (button);

g_signal_connect (button, "style-updated",

G_CALLBACK (panel_action_button_style_updated), NULL);

}

void

{

GdkWindow *window;

GdkScreen *screen;

GdkDisplay *display;

XEvent *xevent = (XEvent *) gdk_xevent;

if (xevent->type != ClientMessage)

(xevent->xclient.message_type != atom_gnome_panel_action))

return GDK_FILTER_CONTINUE;

screen = gdk_event_get_screen (event);

display = gdk_screen_get_display (screen);

window = gdk_x11_window_lookup_for_display (display, xevent->xclient.window);

if (!window)

return GDK_FILTER_CONTINUE;

if (window != gdk_screen_get_root_window (screen))

return GDK_FILTER_CONTINUE;

if (xevent->xclient.data.l [0] == atom_mate_panel_action_main_menu)

panel_action_protocol_main_menu (screen, xevent->xclient.data.l [1]);

g_signal_connect (dialog->addto_dialog, "destroy",

G_CALLBACK (panel_addto_dialog_destroy), dialog);

inner_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0);

find_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0);

dialog->label = gtk_label_new_with_mnemonic ("");

#ifndef __PANEL_ADDTO_H__

#define __PANEL_ADDTO_H__

#ifdef __cplusplus

extern "C" {

#endif

guint has_handle : 1;

};

static gboolean

mate_panel_applet_frame_draw (GtkWidget *widget,

cairo_t *cr)

return FALSE;

}

static void

mate_panel_applet_frame_update_background_size (MatePanelAppletFrame *frame,

mate_panel_applet_frame_change_background (frame, background->type);

}

static void

mate_panel_applet_frame_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)

{

break;

}

}

static void

mate_panel_applet_frame_size_allocate (GtkWidget *widget,

{

MatePanelAppletFrame *frame;

gboolean handled = FALSE;

GdkDisplay *display;

#if GTK_CHECK_VERSION (3, 20, 0)

GdkSeat *seat;

GdkDevice *pointer;

GdkDeviceManager *device_manager;

#endif

frame = MATE_PANEL_APPLET_FRAME (widget);

display = gtk_widget_get_display (widget);

seat = gdk_display_get_default_seat (display);

gdk_seat_ungrab (seat);

display = gtk_widget_get_display (widget);

device_manager = gdk_display_get_device_manager (display);

pointer = gdk_device_manager_get_client_pointer (device_manager);

gdk_device_ungrab (pointer, GDK_CURRENT_TIME);

#endif

MATE_PANEL_APPLET_FRAME_GET_CLASS (frame)->popup_menu (frame,

gobject_class->finalize = mate_panel_applet_frame_finalize;

widget_class->draw = mate_panel_applet_frame_draw;

widget_class->get_preferred_width = mate_panel_applet_frame_get_preferred_width;

widget_class->get_preferred_height = mate_panel_applet_frame_get_preferred_height;

widget_class->size_allocate = mate_panel_applet_frame_size_allocate;

widget_class->button_press_event = mate_panel_applet_frame_button_changed;

widget_class->button_release_event = mate_panel_applet_frame_button_changed;

#else

background = &PANEL_WIDGET (parent)->background;

#endif

panel_background_apply_css (background, GTK_WIDGET (frame));

}

MATE_PANEL_APPLET_FRAME_GET_CLASS (frame)->change_background (frame, type);

Atom xatom;

GdkAtom gdkatom;

cairo_surface_t *surface;

GdkPixbuf *gdkpixbuf;

int width;

G_DEFINE_TYPE (PanelBackgroundMonitor, panel_background_monitor, G_TYPE_OBJECT)

static PanelBackgroundMonitor *global_background_monitor = NULL;

static guint signals [LAST_SIGNAL] = { 0 };

gboolean gdk_window_check_composited_wm(GdkWindow* window)

{

return gdk_screen_is_composited(gdk_window_get_screen(window));

}

static void

panel_background_monitor_finalize (GObject *object)

g_signal_handlers_disconnect_by_func (monitor->screen,

panel_background_monitor_changed, monitor);

if (monitor->surface)

cairo_surface_destroy (monitor->surface);

monitor->surface= NULL;

if (monitor->gdkpixbuf)

g_object_unref (monitor->gdkpixbuf);

monitor->gdkatom = gdk_atom_intern_static_string ("_XROOTPMAP_ID");

monitor->xatom = gdk_x11_atom_to_xatom (monitor->gdkatom);

monitor->surface = NULL;

monitor->gdkpixbuf = NULL;

monitor->display_grabbed = FALSE;

PanelBackgroundMonitor *

panel_background_monitor_get_for_screen (GdkScreen *screen)

{

if (!global_background_monitor) {

global_background_monitor = panel_background_monitor_new (screen);

}

return g_object_ref (global_background_monitor);

}

static void

panel_background_monitor_changed (PanelBackgroundMonitor *monitor)

{

if (monitor->surface)

cairo_surface_destroy (monitor->surface);

monitor->surface = NULL;

if (monitor->gdkpixbuf)

g_object_unref (monitor->gdkpixbuf);

return GDK_FILTER_CONTINUE;

}

static GdkPixbuf *

panel_background_monitor_tile_background (PanelBackgroundMonitor *monitor,

int width,

static void

panel_background_monitor_setup_pixbuf (PanelBackgroundMonitor *monitor)

{

GdkDisplay *display;

int rwidth, rheight;

int pwidth, pheight;

gdk_x11_display_grab (display);

monitor->display_grabbed = TRUE;

if (!monitor->surface)

monitor->surface = mate_bg_get_surface_from_root (monitor->screen);

if (!monitor->surface)

{

g_warning ("couldn't get background pixmap\n");

gdk_x11_display_ungrab (display);

return;

}

pwidth = cairo_xlib_surface_get_width (monitor->surface);

pheight = cairo_xlib_surface_get_height (monitor->surface);

gdk_window_get_geometry (monitor->gdkwindow,

NULL, NULL, &rwidth, &rheight);

monitor->width = MIN (pwidth, rwidth);

monitor->height = MIN (pheight, rheight);

g_assert (monitor->gdkpixbuf == NULL);

monitor->gdkpixbuf = gdk_pixbuf_get_from_surface (monitor->surface,

0, 0,

monitor->width, monitor->height);

gdk_x11_display_ungrab (display);

monitor->display_grabbed = FALSE;

#include <glib.h>

#include <glib-object.h>

#define PANEL_TYPE_BACKGROUND_MONITOR (panel_background_monitor_get_type ())

#define PANEL_BACKGROUND_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), \

typedef struct _PanelBackgroundMonitorClass PanelBackgroundMonitorClass;

typedef struct _PanelBackgroundMonitor PanelBackgroundMonitor;

gboolean gdk_window_check_composited_wm (GdkWindow* window);

GType panel_background_monitor_get_type (void);

PanelBackgroundMonitor *panel_background_monitor_get_for_screen (GdkScreen *screen);

GdkPixbuf *panel_background_monitor_get_region (PanelBackgroundMonitor *monitor,

#include <gdk/gdk.h>

#include <gtk/gtk.h>

#include <cairo.h>

#include <cairo-xlib.h>

#include "panel-background-monitor.h"

#include "panel-util.h"

static void

set_pixbuf_background (PanelBackground *background)

{

g_assert (background->composited_pattern != NULL);

gdk_window_set_background_pattern (background->window, background->composited_pattern);

}

void panel_background_apply_css (PanelBackground *background, GtkWidget *widget)

{

GtkStyleContext *context;

GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);

g_object_unref (provider);

}

static gboolean

panel_background_prepare (PanelBackground *background)

PanelBackgroundType effective_type;

GtkWidget *widget = NULL;

if (!background->transformed)

return FALSE;

effective_type = panel_background_effective_type (background);

switch (effective_type) {

case PANEL_BACK_NONE:

if (background->default_pattern) {

/* the theme background-image pattern must be scaled by

&background->color);

}

break;

case PANEL_BACK_IMAGE:

set_pixbuf_background (background);

* decide how to draw themselves. Therefore, we need to

* make sure that all drawing has been completed before

* the applet looks at the pixmap. */

gdk_display_sync (gdk_window_get_display (background->window));

gdk_window_get_user_data (GDK_WINDOW (background->window),

(gpointer) &widget);

if (GTK_IS_WIDGET (widget)) {

panel_background_apply_css (background, gtk_widget_get_toplevel(widget));

gtk_widget_set_app_paintable(widget,TRUE);

gtk_widget_queue_draw (widget);

}

static void

free_composited_resources (PanelBackground *background)

{

background->composited = FALSE;

if (background->composited_pattern)

cairo_pattern_destroy (background->composited_pattern);

background->composited_pattern = NULL;

}

static void _panel_background_transparency(GdkScreen* screen,PanelBackground* background)

{

panel_background_composite(background);

}

static void

background_changed (PanelBackgroundMonitor *monitor,

if (!background->monitor) {

background->monitor =

panel_background_monitor_get_for_screen (

gdk_window_get_screen (background->window));

background->monitor_signal =

g_signal_connect (

background->monitor, "changed",

G_CALLBACK (background_changed), background);

}

g_signal_connect(gdk_window_get_screen(background->window), "composited-changed",

G_CALLBACK(_panel_background_transparency),

background);

desktop = panel_background_monitor_get_region (

background->monitor,

background->region.x,

return desktop;

}

static cairo_pattern_t *

composite_image_onto_desktop (PanelBackground *background)

{

int width, height;

cairo_t *cr;

cairo_surface_t *surface;

width = gdk_pixbuf_get_width (background->desktop);

height = gdk_pixbuf_get_height (background->desktop);

surface = gdk_window_create_similar_surface (background->window,

CAIRO_CONTENT_COLOR_ALPHA,

width, height);

cairo_surface_destroy (surface);

return NULL;

}

cr = cairo_create (surface);

if(!gdk_window_check_composited_wm(background->window)){

}

gdk_cairo_set_source_pixbuf (cr, background->transformed_image, 0, 0);

pattern = cairo_get_source (cr);

cairo_destroy (cr);

pattern = cairo_pattern_create_for_surface (surface);

cairo_surface_destroy (surface);

return pattern;

}

static cairo_pattern_t *

composite_color_onto_desktop (PanelBackground *background)

{

return pattern;

}

static cairo_pattern_t *

get_composited_pattern (PanelBackground *background)

{

cairo_pattern_t *retval = NULL;

switch (background->type) {

case PANEL_BACK_NONE:

break;

case PANEL_BACK_IMAGE:

retval = composite_image_onto_desktop (background);

break;

default:

g_assert_not_reached ();

break;

case PANEL_BACK_COLOR:

if (background->has_alpha)

background->composited_pattern =

get_composited_pattern (background);

break;

case PANEL_BACK_IMAGE:

if (background->transformed_image) {

background->composited_pattern =

get_composited_pattern (background);

}

break;

default:

gboolean has_alpha = FALSE;

if (background->type == PANEL_BACK_COLOR)

has_alpha = (background->color.alpha < 1.);

else if (background->type == PANEL_BACK_IMAGE &&

background->loaded_image)

panel_background_transform (background);

}

static void

panel_background_set_opacity_no_update (PanelBackground *background,

guint16 opacity)

{

background->color.alpha = opacity / 65535.0;

panel_background_update_has_alpha (background);

}

panel_background_set_opacity (PanelBackground *background,

guint16 opacity)

{

if (background->color.alpha == (opacity / 65535.0))

return;

free_transformed_resources (background);

static void

panel_background_set_color_no_update (PanelBackground *background,

const GdkRGBA *color)

{

g_return_if_fail (color != NULL);

if (gdk_rgba_equal (color, &background->color))

return;

background->color = *color;

panel_background_update_has_alpha (background);

}

void

panel_background_set_color (PanelBackground *background,

const GdkRGBA *color)

{

g_return_if_fail (color != NULL);

if (gdk_rgba_equal (color, &background->color))

return;

free_transformed_resources (background);

void

panel_background_set (PanelBackground *background,

PanelBackgroundType type,

const GdkRGBA *color,

const char *image,

gboolean fit_image,

gboolean stretch_image,

void

panel_background_set_default_style (PanelBackground *background,

GdkRGBA *color,

cairo_pattern_t *pattern)

{

g_return_if_fail (color != NULL);

background->default_color = *color;

if (pattern)

cairo_pattern_reference (pattern);

cairo_pattern_destroy (background->default_pattern);

background->default_pattern = pattern;

if (background->type == PANEL_BACK_NONE)

panel_background_prepare (background);

}

{

g_return_if_fail (window != NULL);

if (background->window)

return;

background->window = g_object_ref (window);

panel_background_prepare_css ();

panel_background_prepare (background);

}

void

panel_background_unrealized (PanelBackground *background)

{

if (background->window)

g_object_unref (background->window);

background->window = NULL;

}

void

background->notify_changed = notify_changed;

background->user_data = user_data;

background->color.red = 0.;

background->color.blue = 0.;

background->color.green = 0.;

background->color.alpha = 1.;

background->image = NULL;

background->loaded_image = NULL;

background->region.width = -1;

background->region.height = -1;

background->transformed_image = NULL;

background->composited_pattern = NULL;

background->monitor = NULL;

background->desktop = NULL;

background->monitor_signal = -1;

background->window = NULL;

background->default_pattern = NULL;

background->default_color.red = 0.;

background->default_color.green = 0.;

background->default_color.blue = 0.;

background->default_color.alpha = 1.;

background->fit_image = FALSE;

background->stretch_image = FALSE;

g_object_unref (background->window);

background->window = NULL;

if (background->default_pattern)

cairo_pattern_destroy (background->default_pattern);

background->default_pattern = NULL;

}

char *

effective_type = panel_background_effective_type (background);

if (effective_type == PANEL_BACK_IMAGE ||

(effective_type == PANEL_BACK_COLOR && background->has_alpha

&& (!gdk_window_check_composited_wm(background->window)))) {

g_free (rgba);

} else

retval = g_strdup ("none:");

return retval;

}

return background->type;

}

const GdkRGBA *

panel_background_get_color (PanelBackground *background)

{

return &(background->color);

}

/* What are we actually rendering - e.g. if we're supposed to

* be rendering an image, but haven't got a valid image, then

* we're rendering the default gtk background.

PanelBackgroundType retval;

retval = background->type;

if (background->type == PANEL_BACK_IMAGE && !background->composited_pattern)

retval = PANEL_BACK_NONE;

return retval;

}

PanelBackgroundChangedNotify notify_changed;

gpointer user_data;

GdkRGBA color;

char *image;

GdkPixbuf *loaded_image;

GtkOrientation orientation;

GdkRectangle region;

GdkPixbuf *transformed_image;

cairo_pattern_t *composited_pattern;

PanelBackgroundMonitor *monitor;

GdkPixbuf *desktop;

gulong monitor_signal;

GdkWindow *window;

cairo_pattern_t *default_pattern;

GdkRGBA default_color;

guint fit_image : 1;

guint stretch_image : 1;

void panel_background_free (PanelBackground *background);

void panel_background_set (PanelBackground *background,

PanelBackgroundType type,

const GdkRGBA *color,

const char *image,

gboolean fit_image,

gboolean stretch_image,

gboolean rotate_image);

void panel_background_set_type (PanelBackground *background,

PanelBackgroundType type);

void panel_background_set_opacity (PanelBackground *background,

guint16 opacity);

void panel_background_set_color (PanelBackground *background,

const GdkRGBA *color);

void panel_background_set_image (PanelBackground *background,

const char *image);

void panel_background_set_fit (PanelBackground *background,

void panel_background_set_rotate (PanelBackground *background,

gboolean rotate_image);

void panel_background_set_default_style (PanelBackground *background,

GdkRGBA *color,

cairo_pattern_t *pattern);

void panel_background_realized (PanelBackground *background,

GdkWindow *window);

void panel_background_unrealized (PanelBackground *background);

int y);

PanelBackgroundType panel_background_get_type (PanelBackground *background);

const GdkRGBA *panel_background_get_color (PanelBackground *background);

PanelBackgroundType

panel_background_effective_type (PanelBackground *background);

void panel_background_apply_css(PanelBackground *background, GtkWidget *widget);

#endif /* __PANEL_BACKGROUND_H__ */

times++;

if (times == 3) {

times = 0;

/* FIXME re-add once GTK3 support is fixed */

start_screen_check ();

#endif

g_object_set_data (G_OBJECT (retval), "menu_panel", panel);

/* Set up theme and transparency support */

GtkWidget *toplevel = gtk_widget_get_toplevel (retval);

/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */

GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));

context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));

gtk_style_context_add_class(context,"gnome-panel-menu-bar");

gtk_style_context_add_class(context,"mate-panel-menu-bar");

return retval;

}

PanelDitemSaveUri save_uri;

gpointer save_uri_data;

GtkWidget *grid;

GtkWidget *type_label;

GtkWidget *type_combo;

GtkWidget *name_label;

}

static inline void

grid_attach_label (GtkGrid *grid, GtkWidget *label, int left, int top, int width, int height)

{

gtk_grid_attach (grid, label, left, top, width, height);

gtk_widget_set_hexpand (entry, TRUE);

gtk_grid_attach (grid, entry, left, top, width, height);

}

static void

setup_combo (GtkWidget *combo_box,

dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));

gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);

priv->grid = gtk_grid_new ();

gtk_container_set_border_width (GTK_CONTAINER (priv->grid), 5);

gtk_grid_set_row_spacing (GTK_GRID (priv->grid), 6);

gtk_grid_set_column_spacing (GTK_GRID (priv->grid), 12);

gtk_box_pack_start (GTK_BOX (dialog_vbox), priv->grid, TRUE, TRUE, 0);

gtk_widget_show (priv->grid);

/* Type */

priv->type_label = label_new_with_mnemonic (_("_Type:"));

priv->icon_chooser = panel_icon_chooser_new (NULL);

panel_icon_chooser_set_fallback_icon_name (PANEL_ICON_CHOOSER (priv->icon_chooser),

PANEL_ICON_LAUNCHER);

gtk_grid_attach (GTK_GRID (priv->grid), priv->icon_chooser, 0, 0, 1, 2);

gtk_widget_show (priv->icon_chooser);

/* Command */

priv->command_label = label_new_with_mnemonic ("");

priv->command_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

gtk_widget_show (priv->command_hbox);

priv->command_entry = gtk_entry_new ();

GtkTreeModel *model;

PanelDItemEditorType buf_type;

grid_attach_label (GTK_GRID (priv->grid), priv->type_label, 1, 0, 1, 1);

grid_attach_entry (GTK_GRID (priv->grid), priv->type_combo, 2, 0, 1, 1);

grid_attach_label (GTK_GRID (priv->grid), priv->comment_label, 1, 3, 1, 1);

grid_attach_entry (GTK_GRID (priv->grid), priv->comment_entry, 2, 3, 1, 1);

/* FIXME: hack hack hack */

model = gtk_combo_box_get_model (GTK_COMBO_BOX (priv->type_combo));

}

} while (gtk_tree_model_iter_next (model, &iter));

} else if (type == PANEL_DITEM_EDITOR_TYPE_DIRECTORY) {

grid_attach_label (GTK_GRID (priv->grid), priv->name_label, 1, 0, 1, 1);

grid_attach_entry (GTK_GRID (priv->grid), priv->name_entry, 2, 0, 1, 1);

grid_attach_label (GTK_GRID (priv->grid), priv->comment_label, 1, 2, 1, 1);

grid_attach_entry (GTK_GRID (priv->grid), priv->comment_entry, 2, 2, 1, 1);

}

type_combo_changed (dialog);

focus_chain = g_list_prepend (focus_chain, priv->command_hbox);

focus_chain = g_list_prepend (focus_chain, priv->comment_entry);

focus_chain = g_list_reverse (focus_chain);

gtk_container_set_focus_chain (GTK_CONTAINER (priv->grid), focus_chain);

g_list_free (focus_chain);

gtk_widget_grab_focus (priv->name_entry);

gtk_container_add (GTK_CONTAINER (retval), frame);

gtk_widget_show (frame);

vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);

gtk_container_add (GTK_CONTAINER (frame), vbox);

gtk_widget_show (vbox);

image = gtk_image_new_from_icon_name (PANEL_ICON_FORCE_QUIT,

GTK_ICON_SIZE_DIALOG);

gtk_widget_set_halign (image, GTK_ALIGN_CENTER);

gtk_widget_set_valign (image, GTK_ALIGN_CENTER);

gtk_box_pack_start (GTK_BOX (vbox), image, TRUE, TRUE, 4);

gtk_widget_show (image);

remove_popup (GtkWidget *popup)

{

GdkWindow *root;

GdkDisplay *display;

#if GTK_CHECK_VERSION (3, 20, 0)

GdkSeat *seat;

GdkDevice *keyboard;

GdkDeviceManager *device_manager;

#endif

root = gdk_screen_get_root_window (

gtk_window_get_screen (GTK_WINDOW (popup)));

gdk_window_remove_filter (root, (GdkFilterFunc) popup_filter, popup);

gtk_widget_destroy (popup);

display = gdk_window_get_display (root);

#if GTK_CHECK_VERSION (3, 20, 0)

seat = gdk_display_get_default_seat (display);

gdk_device_ungrab (pointer, GDK_CURRENT_TIME);

gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);

#endif

}

static gboolean

gdk_error_trap_push ();

XKillClient (display, window);

gdk_flush ();

gdk_error_trap_pop_ignored ();

}

gtk_widget_destroy (GTK_WIDGET (dialog));

GdkCursor *cross;

GtkWidget *popup;

GdkWindow *root;

GdkDisplay *display;

GdkDevice *pointer;

GdkDevice *keyboard;

#else

GdkDeviceManager *device_manager;

#endif

popup = display_popup_window (screen);

gdk_window_add_filter (root, (GdkFilterFunc) popup_filter, popup);

cross = gdk_cursor_new_for_display (gdk_display_get_default (),

GDK_CROSS);

display = gdk_window_get_display (root);

#if GTK_CHECK_VERSION (3, 20, 0)

seat = gdk_display_get_default_seat (display);

remove_popup (popup);

return;

}

gdk_flush ();

}

PROP_EDGES

};

static void

panel_frame_get_preferred_width (GtkWidget *widget,

gint *minimal_width,

}

}

static void

panel_frame_size_allocate (GtkWidget *widget,

GtkAllocation *allocation)

{

PanelFrame *frame = (PanelFrame *) widget;

GtkBin *bin = (GtkBin *) widget;

GtkStyleContext *context;

GtkBorder padding;

GtkAllocation child_allocation;

GtkAllocation child_allocation_current;

GtkWidget *child;

gtk_widget_set_allocation (widget, allocation);

context = gtk_widget_get_style_context (widget);

gtk_style_context_get_padding (context, gtk_widget_get_state_flags (widget), &padding);

border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

child_allocation.x = allocation->x + border_width;

child_allocation.height = allocation->height - 2 * border_width;

if (frame->edges & PANEL_EDGE_LEFT) {

child_allocation.x += padding.left;

child_allocation.width -= padding.left;

}

if (frame->edges & PANEL_EDGE_TOP) {

child_allocation.y += padding.top;

child_allocation.height -= padding.top;

}

if (frame->edges & PANEL_EDGE_RIGHT)

child_allocation.width -= padding.left;

if (frame->edges & PANEL_EDGE_BOTTOM)

child_allocation.height -= padding.top;

child = gtk_bin_get_child (bin);

gtk_widget_get_allocation (child, &child_allocation_current);

void

panel_frame_draw (GtkWidget *widget,

cairo_t *cr,

PanelFrameEdge edges)

{

PanelFrame *frame = (PanelFrame *) widget;

GtkStyleContext *context;

GtkStateFlags state;

GdkRGBA *bg;

GdkRGBA dark, light;

GtkBorder padding;

int x, y, width, height;

if (edges == PANEL_EDGE_NONE)

return;

context = gtk_widget_get_style_context (widget);

state = gtk_widget_get_state_flags (widget);

gtk_style_shade (bg, &light, 1.3);

gtk_style_context_get_padding (context, state, &padding);

/* Copied from gtk_default_draw_shadow() */

x = y = 0;

cairo_set_line_width (cr, 1);

if (frame->edges & PANEL_EDGE_BOTTOM && padding.bottom > 0) {

cairo_stroke (cr);

}

}

}

static gboolean panel_frame_expose(GtkWidget* widget, cairo_t* cr)

{

PanelFrame *frame = (PanelFrame *) widget;

gboolean retval = FALSE;

if (!gtk_widget_is_drawable (widget))

return retval;

if (GTK_WIDGET_CLASS (panel_frame_parent_class)->draw)

retval = GTK_WIDGET_CLASS (panel_frame_parent_class)->draw (widget, cr);

panel_frame_draw (widget, cr, frame->edges);

return retval;

}

gobject_class->get_property = panel_frame_get_property;

widget_class->size_allocate = panel_frame_size_allocate;

widget_class->get_preferred_width = panel_frame_get_preferred_width;

widget_class->get_preferred_height = panel_frame_get_preferred_height;

widget_class->draw = panel_frame_expose;

#if GTK_CHECK_VERSION (3, 20, 0)

gtk_widget_class_set_css_name (widget_class, "PanelFrame");

#endif

PanelFrameEdge panel_frame_get_edges (PanelFrame *toplevel);

void panel_frame_draw (GtkWidget *widget,

cairo_t *cr,

PanelFrameEdge edges);

#ifdef __cplusplus

static void panel_menu_bar_init(PanelMenuBar* menubar)

{

GtkCssProvider *provider;

menubar->priv = PANEL_MENU_BAR_GET_PRIVATE(menubar);

provider = gtk_css_provider_new ();

gtk_css_provider_load_from_data (provider,

"PanelMenuBar {\n"

GTK_STYLE_PROVIDER (provider),

GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);

g_object_unref (provider);

menubar->priv->info = NULL;

g_type_class_add_private(klass, sizeof(PanelMenuBarPrivate));

g_object_class_install_property(gobject_class, PROP_ORIENTATION, g_param_spec_enum("orientation", "Orientation", "The PanelMenuBar orientation", PANEL_TYPE_ORIENTATION, PANEL_ORIENTATION_TOP, G_PARAM_READWRITE));

}

static gboolean panel_menu_bar_on_draw (GtkWidget* widget, cairo_t* cr, gpointer data)

{

PanelMenuBar* menubar = data;

return FALSE;

}

static void panel_menu_bar_load(PanelWidget* panel, gboolean locked, int position, gboolean exactpos, const char* id)

{

PanelMenuBar* menubar;

g_signal_connect_after(menubar, "focus-in-event", G_CALLBACK(gtk_widget_queue_draw), menubar);

g_signal_connect_after(menubar, "focus-out-event", G_CALLBACK(gtk_widget_queue_draw), menubar);

g_signal_connect_after(menubar, "draw", G_CALLBACK(panel_menu_bar_on_draw), menubar);

gtk_widget_set_can_focus(GTK_WIDGET(menubar), TRUE);

*/

menu_shell = GTK_MENU_SHELL(menubar);

gtk_menu_shell_select_item(menu_shell, gtk_menu_get_attach_widget(menu));

}

{

#if GTK_CHECK_VERSION (3, 18, 0)

panel_background_apply_css(&menubar->priv->panel->toplevel->background, GTK_WIDGET(menubar));

#else

#endif

}

{

panel_toplevel_pop_autohide_disabler (button->priv->toplevel);

gtk_widget_unset_state_flags (GTK_WIDGET (button),

GTK_STATE_FLAG_PRELIGHT);

button_widget_set_ignore_leave (BUTTON_WIDGET (button), FALSE);

}

#ifndef __PANEL_MENU_BUTTON_H__

#define __PANEL_MENU_BUTTON_H__

#include "button-widget.h"

#include "panel-widget.h"

panel_recent_append_documents_menu (places_menu,

place_item->priv->recent_manager);

/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */

GtkWidget *toplevel = gtk_widget_get_toplevel (places_menu);

GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));

GdkVisual *visual = gdk_screen_get_rgba_visual(screen);

gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);

return places_menu;

}

return;

display = gdk_display_get_default ();

screens = 1;

panel_multiscreen_init_randr (display);

void

panel_multiscreen_reinit (void)

{

GdkScreen *screen;

GList *toplevels, *l;

if (monitors)

g_free (monitors);

g_free (geometries);

}

screen = gdk_screen_get_default ();

g_signal_handlers_disconnect_by_func (screen, panel_multiscreen_queue_reinit, NULL);

initialized = FALSE;

panel_multiscreen_init ();

return background_type;

}

void

panel_profile_set_background_color (PanelToplevel *toplevel,

GdkRGBA *color)

panel_profile_get_background_color (toplevel, &color);

return (guint16) round (color.alpha * 65535);

}

void

panel_profile_set_background_image (PanelToplevel *toplevel,

return is_writable;

}

static void

get_background_color (PanelToplevel *toplevel,

GdkRGBA *color)

g_free (color_str);

}

static char *

get_background_image (PanelToplevel *toplevel,

PanelWidget *panel_widget;

PanelBackground *background;

PanelBackgroundType background_type;

GdkRGBA color;

char *image;

gboolean fit;

gboolean stretch;

panel_background_set_type (background, background_type);

panel_toplevel_update_edges (toplevel);

} else if (!strcmp (key, "color")) {

GdkRGBA color;

gchar *str;

str = g_settings_get_string (settings, key);

if (gdk_rgba_parse (&color, str))

panel_background_set_color (background, &color);

g_free (str);

} else if (!strcmp (key, "image")) {

gchar *value = g_settings_get_string (settings, key);

panel_background_set_image (background, value);

panel_profile_remove_from_list (PANEL_GSETTINGS_TOPLEVELS, toplevel_id);

}

PanelToplevel *

panel_profile_load_toplevel (const char *toplevel_id)

{

toplevel_path = g_strdup_printf ("%s%s/", PANEL_TOPLEVEL_PATH, toplevel_id);

screen = gdk_display_get_default_screen (gdk_display_get_default ());

if (screen == NULL) {

g_free (toplevel_path);

GSList *l;

GdkDisplay *display;

GdkScreen *screen;

toplevels = panel_toplevel_list_toplevels ();

display = gdk_display_get_default ();

screen = gdk_display_get_default_screen (display);

for (l = toplevels; l; l = l->next)

if (!l)

empty_screens = g_slist_prepend (empty_screens, screen);

for (l = empty_screens; l; l = l->next)

panel_layout_apply_default_from_gkeyfile (l->data);

panel_profile_get_background_type (PanelToplevel *toplevel);

void panel_profile_set_background_color (PanelToplevel *toplevel,

GdkRGBA *color);

void panel_profile_get_background_color (PanelToplevel *toplevel,

GdkRGBA *color);

void panel_profile_set_background_gdk_rgba (PanelToplevel *toplevel,

GdkRGBA *color);

void panel_profile_get_background_gdk_rgba (PanelToplevel *toplevel,

GdkRGBA *color);

void panel_profile_set_background_opacity (PanelToplevel *toplevel,

guint16 opacity);

#include <libpanel-util/panel-icon-chooser.h>

#include <libpanel-util/panel-show.h>

#include "nothing.h"

#include "panel-profile.h"

#include "panel-schemas.h"

static void

panel_properties_dialog_color_changed (PanelPropertiesDialog *dialog,

GtkColorChooser *color_button)

{

GdkRGBA color;

g_assert (dialog->color_button == GTK_WIDGET (color_button));

gtk_color_chooser_get_rgba (color_button, &color);

panel_profile_set_background_gdk_rgba (dialog->toplevel, &color);

panel_properties_dialog_opacity_changed (dialog);

}

static void

panel_properties_dialog_setup_color_button (PanelPropertiesDialog *dialog,

GtkBuilder *gui)

{

GdkRGBA color;

dialog->color_button = PANEL_GTK_BUILDER_GET (gui, "color_button");

g_return_if_fail (dialog->color_button != NULL);

panel_profile_get_background_color (dialog->toplevel, &color);

gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (dialog->color_button),

&color);

g_signal_connect_swapped (dialog->color_button, "color_set",

G_CALLBACK (panel_properties_dialog_color_changed),

panel_properties_dialog_update_background_color (PanelPropertiesDialog *dialog,

gchar *str_color)

{

GdkRGBA new_color;

GdkRGBA old_color;

if (!gdk_rgba_equal (&old_color, &new_color))

gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (dialog->color_button),

&new_color);

}

static void

panel_properties_dialog_update_background_image (PanelPropertiesDialog *dialog,

gchar *text)

panel_properties_dialog_update_background_color (dialog, color);

g_free (color);

}

else if (!strcmp (key, "image"))

{

char *image = g_settings_get_string (settings, key);

panel_properties_dialog_remove_orientation_combo (PanelPropertiesDialog *dialog)

{

GtkContainer *container = GTK_CONTAINER (dialog->general_table);

GtkGrid *grid = GTK_GRID (dialog->general_table);

g_object_ref (dialog->size_label);

g_object_ref (dialog->size_widgets);

gtk_container_remove (container, dialog->icon_label);

gtk_container_remove (container, dialog->icon_align);

gtk_grid_attach (grid, dialog->size_label, 0, 1, 1, 1);

gtk_grid_attach (grid, dialog->size_widgets, 1, 1, 1, 1);

gtk_grid_attach (grid, dialog->icon_label, 0, 2, 1, 1);

gtk_grid_attach (grid, dialog->icon_align, 1, 2, 1, 1);

dialog->orientation_label = NULL;

dialog->orientation_combo = NULL;

g_object_unref (dialog->size_widgets);

g_object_unref (dialog->icon_label);

g_object_unref (dialog->icon_align);

}

static void

dialog->icon_label = NULL;

dialog->icon_align = NULL;

dialog->icon_chooser = NULL;

}

static void

panel_widget_register_open_dialog (panel_toplevel_get_panel_widget (dialog->toplevel),

dialog->properties_dialog);

/* FIXME re-add once GTK3 support is fixed */

g_signal_connect (dialog->properties_dialog, "event",

G_CALLBACK (config_event),

gtk_builder_set_translation_domain (gui, GETTEXT_PACKAGE);

error = NULL;

gtk_builder_add_from_file (gui,

BUILDERDIR "/panel-properties-dialog-gtk3.ui",

&error);

if (error) {

char *secondary;

secondary = g_strdup_printf (_("Unable to load file '%s': %s."),

BUILDERDIR"/panel-properties-dialog-gtk3.ui",

error->message);

panel_error_dialog (GTK_WINDOW (toplevel),

gtk_window_get_screen (GTK_WINDOW (toplevel)),

#define __PANEL_RESET_C__

#include <stdlib.h>

#include "panel-reset.h"

#include "panel-schemas.h"

#ifndef __PANEL_RESET_H__

#define __PANEL_RESET_H__

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */

GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();

GtkIconInfo *icon_info = gtk_icon_theme_lookup_by_gicon (icon_theme, icon, size, 0);

pixbuf = gtk_icon_info_load_icon (icon_info, NULL);

g_object_unref (icon_info);

}

if (pixbuf) {

//(ditto for the drag icon?)

gtk_window_set_icon (GTK_WINDOW (dialog->run_dialog), pixbuf);

gtk_drag_source_set_icon_gicon (dialog->run_dialog, dialog->icon);

g_object_unref (pixbuf);

} else {

panel_run_dialog_set_default_icon (dialog, TRUE);

}

/* evil eggies, do not translate! */

/* FIXME re-add once GTK3 support is fixed */

if (!strcmp (command, "free the fish")) {

start_screen_check ();

}

static void

panel_run_dialog_style_updated (GtkWidget *widget,

PanelRunDialog *dialog)

{

if (dialog->icon) {

GIcon *icon;

{

dialog->pixmap = PANEL_GTK_BUILDER_GET (gui, "icon_pixmap");

g_signal_connect (dialog->pixmap, "style-updated",

G_CALLBACK (panel_run_dialog_style_updated),

dialog);

g_signal_connect (dialog->pixmap, "screen-changed",

G_CALLBACK (panel_run_dialog_screen_changed),

dialog);

static void

panel_run_dialog_disconnect_pixmap (PanelRunDialog *dialog)

{

g_signal_handlers_disconnect_by_func (dialog->pixmap,

G_CALLBACK (panel_run_dialog_style_updated),

dialog);

g_signal_handlers_disconnect_by_func (dialog->pixmap,

G_CALLBACK (panel_run_dialog_screen_changed),

dialog);

#ifndef __PANEL_RUN_DIALOG_H__

#define __PANEL_RUN_DIALOG_H__

G_BEGIN_DECLS

G_DEFINE_TYPE (PanelSeparator, panel_separator, GTK_TYPE_EVENT_BOX)

static gboolean

panel_separator_draw (GtkWidget *widget, cairo_t *cr)

{

return FALSE;

}

static void

panel_separator_get_preferred_width (GtkWidget *widget,

gint *minimal_width,

else

*minimal_height = *natural_height = size;

}

static void

panel_separator_size_allocate (GtkWidget *widget,

{

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

widget_class->draw = panel_separator_draw;

widget_class->get_preferred_width = panel_separator_get_preferred_width;

widget_class->get_preferred_height = panel_separator_get_preferred_height;

widget_class->size_allocate = panel_separator_size_allocate;

widget_class->parent_set = panel_separator_parent_set;

{

#if GTK_CHECK_VERSION (3, 18, 0)

panel_background_apply_css(&separator->priv->panel->toplevel->background, GTK_WIDGET(separator));

#else

#endif

}

*/

#include <config.h>

#include <stdlib.h>

#include <gdk/gdkx.h>

#include <libegg/eggsmclient.h>

#include "panel-shell.h"

#include "panel-session.h"

static gboolean do_not_restart = FALSE;

PanelWidget *panel_widget;

PanelFrame *inner_frame;

GtkWidget *grid;

GtkWidget *hide_button_top;

GtkWidget *hide_button_bottom;

GtkWidget *hide_button_left;

GdkWindow *window;

GdkCursorType cursor_type;

GdkCursor *cursor;

GdkDisplay *display;

#if GTK_CHECK_VERSION (3, 20, 0)

GdkSeat *seat;

GdkDevice *keyboard;

GdkDeviceManager *device_manager;

#endif

if (toplevel->priv->state != PANEL_STATE_NORMAL ||

toplevel->priv->grab_op != PANEL_GRAB_OP_NONE)

cursor = gdk_cursor_new_for_display (gdk_display_get_default (),

cursor_type);

display = gdk_window_get_display (window);

#if GTK_CHECK_VERSION(3, 20, 0)

seat = gdk_display_get_default_seat (display);

NULL, NULL, NULL);

g_object_unref (cursor);

#else

device_manager = gdk_display_get_device_manager (display);

pointer = gdk_device_manager_get_client_pointer (device_manager);

GDK_OWNERSHIP_NONE, FALSE,

GDK_KEY_PRESS | GDK_KEY_RELEASE,

NULL, time_);

#endif

}

static void panel_toplevel_end_grab_op (PanelToplevel* toplevel, guint32 time_)

{

GtkWidget *widget;

GdkDisplay *display;

#if GTK_CHECK_VERSION (3, 20, 0)

GdkSeat *seat;

GdkDevice *keyboard;

GdkDeviceManager *device_manager;

#endif

g_return_if_fail (toplevel->priv->grab_op != PANEL_GRAB_OP_NONE);

widget = GTK_WIDGET (toplevel);

gtk_grab_remove (widget);

display = gtk_widget_get_display (widget);

#if GTK_CHECK_VERSION(3, 20, 0)

seat = gdk_display_get_default_seat (display);

gdk_device_ungrab (pointer, time_);

gdk_device_ungrab (keyboard, time_);

#endif

}

static void panel_toplevel_cancel_grab_op(PanelToplevel* toplevel, guint32 time_)

{

GdkScreen *screen;

GdkWindow *root_window;

GdkDevice *device;

int new_x, new_y;

screen = gtk_window_get_screen (GTK_WINDOW (toplevel));

#if GTK_CHECK_VERSION(3, 20, 0)

device = gdk_seat_get_pointer (gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET(root_window))));

gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET (root_window)), device, &new_x, &new_y, NULL);

device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gtk_widget_get_display (GTK_WIDGET(root_window))));

gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET (root_window)), device, &new_x, &new_y, NULL);

#endif

switch (keyval) {

panel_toplevel_unhide (toplevel);

}

static void

set_arrow_type (GtkImage *image,

GtkArrowType arrow_type)

break;

}

}

static GtkWidget *

panel_toplevel_add_hide_button (PanelToplevel *toplevel,

GtkArrowType arrow_type,

int left,

int top)

{

GtkWidget *button;

AtkObject *obj;

break;

}

arrow = gtk_image_new ();

set_arrow_type (GTK_IMAGE (arrow), arrow_type);

gtk_widget_set_margin_start(GTK_WIDGET(arrow), 0);

gtk_widget_set_margin_end(GTK_WIDGET(arrow), 0);

gtk_container_add (GTK_CONTAINER (button), arrow);

gtk_widget_show (arrow);

g_signal_connect_swapped (button, "button_release_event",

G_CALLBACK (panel_toplevel_hide_button_event), toplevel);

gtk_grid_attach (GTK_GRID (toplevel->priv->grid), button, left, top, 1, 1);

return button;

}

#if GTK_CHECK_VERSION(3, 20, 0)

GdkSeat *seat;

GdkDevice *pointer;

GdkDeviceManager *device_manager;

GdkDevice *pointer;

#endif

#if GTK_CHECK_VERSION(3, 20, 0)

seat = gdk_display_get_default_seat (display);

pointer = gdk_seat_get_pointer (seat);

device_manager = gdk_display_get_device_manager (display);

pointer = gdk_device_manager_get_client_pointer (device_manager);

#endif

screen = NULL;

x = y = -1;

gdk_device_get_position (pointer, &screen, &x, &y);

if (screen != gtk_window_get_screen (GTK_WINDOW (toplevel)))

return FALSE;

PanelFrameEdge edges;

PanelFrameEdge inner_edges;

PanelFrameEdge outer_edges;

int monitor_width, monitor_height;

int width, height;

gboolean inner_frame = FALSE;

height = toplevel->priv->geometry.height;

edges = PANEL_EDGE_NONE;

/* We don't want any bevels with a color/image background */

}

if (!inner_frame) {

inner_edges = PANEL_EDGE_NONE;

#endif

/* There's no bevels with a color/image background */

if (panel_background_effective_type (background) == PANEL_BACK_NONE) {

GtkStyleContext *context;

GtkStateFlags state;

GdkRectangle *geometry;

if (y + padding.top >= max_size && y < max_size &&

!toplevel->priv->y_centered)

y = max_size;

}

x += panel_multiscreen_x (screen, toplevel->priv->monitor);

y += panel_multiscreen_y (screen, toplevel->priv->monitor);

calculate_minimum_height (GtkWidget *widget,

PanelOrientation orientation)

{

GtkStateFlags state;

GtkStyleContext *style_context;

const PangoFontDescription *font_desc;

GtkBorder padding;

PangoContext *pango_context;

PangoFontMetrics *metrics;

#if !GTK_CHECK_VERSION (3, 20, 0)

int descent;

int thickness;

state = gtk_widget_get_state_flags (widget);

style_context = gtk_widget_get_style_context (widget);

gtk_style_context_get(style_context, state, GTK_STYLE_PROPERTY_FONT, &font_desc, NULL);

font_desc,

pango_context_get_language (pango_context));

gtk_style_context_get_padding (style_context, state, &padding);

ascent = pango_font_metrics_get_ascent (metrics);

descent = pango_font_metrics_get_descent (metrics);

NULL);

#endif

thickness = orientation & PANEL_HORIZONTAL_MASK ?

padding.top + padding.bottom :

padding.left + padding.right;

return PANGO_PIXELS (ascent + descent) + 2 * (focus_width + focus_pad) + thickness;

#endif

}

static int

panel_toplevel_update_size_from_hints (PanelToplevel *toplevel,

GtkRequisition *requisition)

{

GtkWidget *widget;

GtkStyleContext *context;

GtkStateFlags state;

GtkBorder padding;

int monitor_width, monitor_height;

int width, height;

int minimum_height;

return;

widget = GTK_WIDGET (toplevel);

context = gtk_widget_get_style_context (widget);

state = gtk_widget_get_state_flags (widget);

gtk_style_context_get_padding (context, state, &padding);

panel_toplevel_get_monitor_geometry (

toplevel, NULL, NULL, &monitor_width, &monitor_height);

height = MAX (MINIMUM_WIDTH, height);

}

if (toplevel->priv->edges & PANEL_EDGE_TOP)

height += padding.top;

if (toplevel->priv->edges & PANEL_EDGE_BOTTOM)

width += padding.left;

if (toplevel->priv->edges & PANEL_EDGE_RIGHT)

width += padding.right;

toplevel->priv->geometry.width = CLAMP (width, 0, monitor_width);

toplevel->priv->geometry.height = CLAMP (height, 0, monitor_height);

g_object_set_data (G_OBJECT (button), "arrow-type", GINT_TO_POINTER (arrow_type));

set_arrow_type (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), arrow_type);

}

static void

requisition.width = -1;

requisition.height = -1;

gtk_widget_get_preferred_size (widget, &requisition, NULL);

gtk_widget_get_allocation (widget, &allocation);

allocation.width = requisition.width;

child = gtk_bin_get_child (bin);

if (child && gtk_widget_get_visible (child))

gtk_widget_get_preferred_size (child, requisition, NULL);

old_geometry = toplevel->priv->geometry;

panel_toplevel_move_resize_window (toplevel, position_changed, size_changed);

}

static void

panel_toplevel_get_preferred_width (GtkWidget *widget,

gint *minimum_width,

panel_toplevel_size_request (widget, &req);

*minimum_height = *natural_height = req.height;

}

#if GTK_CHECK_VERSION (3, 18, 0)

static void

{

PanelToplevel *toplevel = (PanelToplevel *) widget;

GtkBin *bin = (GtkBin *) widget;

GtkStyleContext *context;

GtkStateFlags state;

GtkBorder padding;

GtkWidget *child;

GtkAllocation challoc;

GtkAllocation child_allocation;

}

}

state = gtk_widget_get_state_flags (widget);

context = gtk_widget_get_style_context (widget);

gtk_style_context_get_padding (context, state, &padding);

if (toplevel->priv->edges & PANEL_EDGE_RIGHT)

challoc.width -= padding.right;

challoc.width = MAX (1, challoc.width);

challoc.height = MAX (1, challoc.height);

#endif

}

static gboolean panel_toplevel_draw(GtkWidget* widget, cairo_t* cr)

{

PanelToplevel* toplevel = (PanelToplevel*) widget;

PanelFrameEdge edges;

gboolean retval = FALSE;

int awidth;

int aheight;

GtkStyleContext *context;

GtkStateFlags state;

GtkBorder padding;

if (!gtk_widget_is_drawable (widget))

return retval;

if (GTK_WIDGET_CLASS (panel_toplevel_parent_class)->draw)

retval = GTK_WIDGET_CLASS (panel_toplevel_parent_class)->draw (widget, cr);

edges = toplevel->priv->edges;

panel_frame_draw (widget, cr, edges);

if (toplevel->priv->expand ||

toplevel->priv->buttons_enabled ||

toplevel->priv->attached)

return retval;

state = gtk_widget_get_state_flags (widget);

awidth = gtk_widget_get_allocated_width (widget);

aheight = gtk_widget_get_allocated_height (widget);

gtk_style_context_save (context);

gtk_style_context_set_state (context, state);

if (toplevel->priv->orientation & PANEL_HORIZONTAL_MASK) {

int x, y, width, height;

x = 0;

y = 0;

height = aheight;

width = HANDLE_SIZE;

if (edges & PANEL_EDGE_TOP) {

y += padding.top;

height -= padding.top;

}

if (edges & PANEL_EDGE_BOTTOM)

height -= padding.bottom;

if (edges & PANEL_EDGE_LEFT)

x += padding.left;

cairo_save (cr);

gtk_render_handle (context, cr, x, y, width, height);

cairo_restore (cr);

x = awidth - HANDLE_SIZE;

if (edges & PANEL_EDGE_RIGHT)

x -= padding.right;

cairo_save (cr);

gtk_render_handle (context, cr, x, y, width, height);

cairo_restore (cr);

} else {

int x, y, width, height;

x = 0;

y = 0;

width = awidth;

height = HANDLE_SIZE;

if (edges & PANEL_EDGE_LEFT) {

x += padding.left;

width -= padding.left;

}

if (edges & PANEL_EDGE_RIGHT)

width -= padding.right;

if (edges & PANEL_EDGE_TOP)

y += padding.top;

cairo_save (cr);

gtk_render_handle (context, cr, x, y, width, height);

cairo_restore (cr);

y = aheight - HANDLE_SIZE;

if (edges & PANEL_EDGE_BOTTOM)

y -= padding.bottom;

cairo_save (cr);

gtk_render_handle (context, cr, x, y, width, height);

cairo_restore (cr);

}

gtk_style_context_restore (context);

return retval;

}

deltax = toplevel->priv->animation_end_x - cur_x;

deltay = toplevel->priv->animation_end_y - cur_y;

gtk_widget_get_preferred_size (GTK_WIDGET (toplevel), &requisition, NULL);

if (toplevel->priv->animation_end_width != -1)

deltaw = toplevel->priv->animation_end_width - requisition.width;

}

static void

panel_toplevel_style_updated (GtkWidget *widget)

{

panel_toplevel_update_hide_buttons (PANEL_TOPLEVEL (widget));

set_background_default_style (widget);

#endif

}

static void

panel_toplevel_drag_threshold_changed (PanelToplevel *toplevel)

object = G_OBJECT_CLASS (panel_toplevel_parent_class)->constructor (type,

n_construct_properties,

construct_properties);

PanelToplevel *toplevel = PANEL_TOPLEVEL(object);

GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));

GdkVisual *visual = gdk_screen_get_rgba_visual(screen);

gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);

return object;

}

#if GTK_CHECK_VERSION (3, 18, 0)

widget_class->state_flags_changed = panel_toplevel_state_flags_changed;

#endif

widget_class->draw = panel_toplevel_draw;

widget_class->get_preferred_width = panel_toplevel_get_preferred_width;

widget_class->get_preferred_height = panel_toplevel_get_preferred_height;

widget_class->style_updated = panel_toplevel_style_updated;

widget_class->size_allocate = panel_toplevel_size_allocate;

widget_class->button_press_event = panel_toplevel_button_press_event;

widget_class->button_release_event = panel_toplevel_button_release_event;

#if GTK_CHECK_VERSION (3, 18, 0)

widget_class->configure_event = panel_toplevel_configure_event;

#endif

widget_class->key_press_event = panel_toplevel_key_press_event;

widget_class->motion_notify_event = panel_toplevel_motion_notify_event;

widget_class->enter_notify_event = panel_toplevel_enter_notify_event;

{

GtkWidget* container;

toplevel->priv->grid = gtk_grid_new ();

toplevel->priv->hide_button_top = panel_toplevel_add_hide_button (toplevel, GTK_ARROW_UP, 1, 0);

toplevel->priv->hide_button_bottom = panel_toplevel_add_hide_button (toplevel, GTK_ARROW_DOWN, 1, 2);

toplevel->priv->hide_button_left = panel_toplevel_add_hide_button (toplevel, GTK_ARROW_LEFT, 0, 1);

toplevel->priv->hide_button_right = panel_toplevel_add_hide_button (toplevel, GTK_ARROW_RIGHT, 2, 1);

if (toplevel->priv->orientation & PANEL_HORIZONTAL_MASK)

{

toplevel->priv->inner_frame = g_object_new(PANEL_TYPE_FRAME, NULL);

gtk_widget_set_hexpand (GTK_WIDGET (toplevel->priv->inner_frame), TRUE);

gtk_widget_set_vexpand (GTK_WIDGET (toplevel->priv->inner_frame), TRUE);

gtk_grid_attach (GTK_GRID (toplevel->priv->grid), GTK_WIDGET (toplevel->priv->inner_frame), 1, 1, 1, 1);

gtk_widget_show (GTK_WIDGET (toplevel->priv->inner_frame));

container = panel_widget_new (toplevel,

gtk_container_add(GTK_CONTAINER(toplevel->priv->inner_frame), container);

gtk_widget_show(container);

gtk_container_add (GTK_CONTAINER (toplevel), toplevel->priv->grid);

gtk_widget_show (toplevel->priv->grid);

}

#if GTK_CHECK_VERSION (3, 18, 0)

panel_toplevel_update_edges (toplevel);

panel_widget_emit_background_changed (toplevel->priv->panel_widget);

}

#endif

static void

panel_toplevel_init (PanelToplevel *toplevel)

{

toplevel->priv->panel_widget = NULL;

toplevel->priv->inner_frame = NULL;

toplevel->priv->grid = NULL;

toplevel->priv->hide_button_top = NULL;

toplevel->priv->hide_button_bottom = NULL;

toplevel->priv->hide_button_left = NULL;

(PanelBackgroundChangedNotify) background_changed,

toplevel);

#endif

/*ensure the panel BG can always be themed*/

/*Without this gtk3.19/20 cannot set the BG color and resetting the bg to system is not immediately applied*/

GtkStyleContext *context;

context = gtk_widget_get_style_context (GTK_WIDGET (toplevel));

gtk_style_context_add_class(context,"gnome-panel-menu-bar");

gtk_style_context_add_class(context,"mate-panel-menu-bar");

}

PanelWidget *

toplevel->priv->orientation = orientation;

GtkStyleContext* context = gtk_widget_get_style_context (GTK_WIDGET (toplevel));

if (orientation & PANEL_HORIZONTAL_MASK) {

gtk_style_context_add_class (context, GTK_STYLE_CLASS_HORIZONTAL);

gtk_style_context_remove_class (context, GTK_STYLE_CLASS_HORIZONTAL);

}

gtk_widget_reset_style (GTK_WIDGET (toplevel));

panel_toplevel_update_hide_buttons (toplevel);

#ifndef PANEL_TYPES_H

#define PANEL_TYPES_H

typedef enum {

PANEL_SPEED_SLOW,

PANEL_SPEED_MEDIUM,

PANEL_SPEED_FAST

} PanelSpeed;

#endif

GDK_WATCH);

gdk_window_set_cursor (win, cursor);

g_object_unref (cursor);

gdk_flush ();

}

}

if (info) {

retval = g_strdup (gtk_icon_info_get_filename (info));

g_object_unref (info);

} else

retval = NULL;

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include <gtk/gtkx.h> /* for GTK_IS_SOCKET */

#include <libpanel-util/panel-list.h>

static gboolean mate_panel_applet_in_drag = FALSE;

static GtkWidget *saved_focus_widget = NULL;

static void panel_widget_get_preferred_size (GtkWidget *widget,

GtkRequisition *minimum_size,

GtkRequisition *natural_size);

static void panel_widget_get_preferred_height (GtkWidget *widget,

gint *minimum_height,

gint *natural_height);

static void panel_widget_size_allocate (GtkWidget *widget,

GtkAllocation *allocation);

static void panel_widget_cadd (GtkContainer *container,

static void panel_widget_dispose (GObject *obj);

static void panel_widget_finalize (GObject *obj);

static void panel_widget_realize (GtkWidget *widget);

static void panel_widget_unrealize (GtkWidget *panel);

static void panel_widget_state_flags_changed (GtkWidget *widget,

GtkStateFlags previous_state);

static void panel_widget_style_updated (GtkWidget *widget);

static void panel_widget_background_changed (PanelBackground *background,

PanelWidget *panel);

#endif

emit_applet_moved (PanelWidget *panel_widget,

AppletData *applet)

{

/* we always want to queue a draw after moving, so do it here instead

* of after the signal emission in all callers */

gtk_widget_queue_draw (applet->applet);

g_signal_emit (panel_widget,

panel_widget_signals [APPLET_MOVE_SIGNAL], 0,

applet->applet);

object_class->dispose = panel_widget_dispose;

object_class->finalize = panel_widget_finalize;

widget_class->get_preferred_width = panel_widget_get_preferred_width;

widget_class->get_preferred_height = panel_widget_get_preferred_height;

widget_class->size_allocate = panel_widget_size_allocate;

#if GTK_CHECK_VERSION (3, 20, 0)

gtk_widget_class_set_css_name (widget_class, "PanelWidget");

#endif

widget_class->realize = panel_widget_realize;

widget_class->unrealize = panel_widget_unrealize;

widget_class->state_flags_changed = panel_widget_state_flags_changed;

widget_class->style_updated = panel_widget_style_updated;

#endif

widget_class->focus = panel_widget_real_focus;

}

static void

panel_widget_get_preferred_size(GtkWidget *widget,

GtkRequisition *minimum_size,

GtkRequisition *natural_size)

{

PanelWidget *panel;

GList *list;

minimum_size->height = 0;

minimum_size->width = panel->sz;

}

natural_size->width = minimum_size->width;

natural_size->height = minimum_size->height;

ad_with_hints = NULL;

for (list = panel->applet_list; list!=NULL; list = g_list_next(list)) {

AppletData *ad = list->data;

GtkRequisition child_min_size;

GtkRequisition child_natural_size;

gtk_widget_get_preferred_size(ad->applet,

&child_min_size,

&child_natural_size);

if (panel->orient == GTK_ORIENTATION_HORIZONTAL) {

if (minimum_size->height < child_min_size.height &&

!ad->size_constrained)

minimum_size->height = child_min_size.height;

if (natural_size->height < child_natural_size.height &&

!ad->size_constrained)

natural_size->height = child_natural_size.height;

if (panel->packed && ad->expand_major && ad->size_hints)

ad_with_hints = g_list_prepend (ad_with_hints,

else if (panel->packed)

{

minimum_size->width += child_min_size.width;

natural_size->width += child_natural_size.width;

}

} else {

if (minimum_size->width < child_min_size.width &&

!ad->size_constrained)

minimum_size->width = child_min_size.width;

if (natural_size->width < child_min_size.width &&

!ad->size_constrained)

natural_size->width = child_min_size.width;

if (panel->packed && ad->expand_major && ad->size_hints)

ad_with_hints = g_list_prepend (ad_with_hints,

else if (panel->packed)

{

minimum_size->height += child_min_size.height;

natural_size->height += child_natural_size.height;

}

}

}

if (!panel->packed) {

if (panel->orient == GTK_ORIENTATION_HORIZONTAL) {

minimum_size->width = panel->size;

natural_size->width = panel->size;

} else {

minimum_size->height = panel->size;

natural_size->height = panel->size;

}

} else {

/* put the list in the correct order: this is important

minimum_size->width = 12;

if (minimum_size->height < 12)

minimum_size->height = 12;

if (natural_size->width < 12 && !dont_fill)

natural_size->width = 12;

if (natural_size->height < 12)

natural_size->height = 12;

} else {

if (minimum_size->width < 12)

minimum_size->width = 12;

if (minimum_size->height < 12 && !dont_fill)

minimum_size->height = 12;

if (natural_size->width < 12)

natural_size->width = 12;

if (natural_size->height < 12 && !dont_fill)

natural_size->height = 12;

}

}

static void

panel_widget_get_preferred_width(GtkWidget *widget,

gint *minimum_width,

*minimum_height = req_min.height;

*natural_height = req_natural.height;

}

static void

queue_resize_on_all_applets(PanelWidget *panel)

AppletData *ad = list->data;

GtkAllocation challoc;

GtkRequisition chreq;

gtk_widget_get_preferred_size (ad->applet, &chreq, NULL);

ad->constrained = i;

AppletData *ad = list->data;

GtkRequisition chreq;

gtk_widget_get_preferred_size (ad->applet, &chreq, NULL);

if (!ad->expand_major || !ad->size_hints) {

if(panel->orient == GTK_ORIENTATION_HORIZONTAL)

AppletData *ad = list->data;

GtkAllocation challoc;

GtkRequisition chreq;

gtk_widget_get_preferred_size (ad->applet, &chreq, NULL);

challoc.width = chreq.width;

challoc.height = chreq.height;

if(panel->orient == GTK_ORIENTATION_HORIZONTAL) {

{

GtkWidget *widget;

GtkAllocation allocation;

GdkDevice *device;

int x,y;

int w,h;

#if GTK_CHECK_VERSION(3, 20, 0)

device = gdk_seat_get_pointer (gdk_display_get_default_seat (gtk_widget_get_display (widget)));

gdk_window_get_device_position(gtk_widget_get_window (widget), device, &x, &y, NULL);

device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gtk_widget_get_display (widget)));

gdk_window_get_device_position(gtk_widget_get_window (widget), device, &x, &y, NULL);

#endif

gtk_widget_get_allocation (widget, &allocation);

return FALSE;

}

static void

panel_widget_set_background_default_style (GtkWidget *widget)

{

GTK_WIDGET_CLASS (panel_widget_parent_class)->style_updated (widget);

panel_widget_set_background_default_style (widget);

}

#endif

static gboolean

{

PanelWidget *panel = (PanelWidget *) widget;

GdkWindow *window;

g_signal_connect (panel->toplevel, "configure-event",

G_CALLBACK (toplevel_configure_event), panel);

GTK_WIDGET_CLASS (panel_widget_parent_class)->realize (widget);

window = gtk_widget_get_window (widget);

panel_widget_set_background_default_style (widget);

panel_background_realized (&panel->background, window);

}

panel->packed = FALSE;

panel->orient = GTK_ORIENTATION_HORIZONTAL;

panel->size = 0;

panel->applet_list = NULL;

panel->master_widget = NULL;

panel->drop_widget = widget;

(PanelBackgroundChangedNotify) panel_widget_background_changed,

panel);

#endif

panels = g_slist_append (panels, panel);

}

panel->sz = sz;

panel->packed = packed;

panel->size = 0;

panel->toplevel = toplevel;

panel->drop_widget = GTK_WIDGET (toplevel);

if (window) {

GdkGrabStatus status;

GdkCursor *fleur_cursor;

GdkDisplay *display;

#if GTK_CHECK_VERSION(3, 20, 0)

GdkSeat *seat;

GdkDevice *pointer;

GdkDeviceManager *device_manager;

#endif

fleur_cursor = gdk_cursor_new_for_display (gdk_display_get_default (),

GDK_FLEUR);

display = gdk_window_get_display (window);

#if GTK_CHECK_VERSION(3, 20, 0)

seat = gdk_display_get_default_seat (display);

#endif

g_object_unref (fleur_cursor);

gdk_flush ();

if (status != GDK_GRAB_SUCCESS) {

#if GTK_CHECK_VERSION(3, 20, 0)

GdkDisplay *display;

GdkSeat *seat;

GdkDisplay *display;

GdkDevice *pointer;

GdkDeviceManager *device_manager;

seat = gdk_display_get_default_seat (display);

gdk_seat_ungrab (seat);

display = gtk_widget_get_display (GTK_WIDGET (panel));

device_manager = gdk_display_get_device_manager (display);

pointer = gdk_device_manager_get_client_pointer (device_manager);

gdk_device_ungrab (pointer, GDK_CURRENT_TIME);

#endif

gtk_grab_remove (panel->currently_dragged_applet->applet);

panel_widget_applet_drag_end_no_grab (panel);

int

panel_widget_get_cursorloc (PanelWidget *panel)

{

GdkDevice *device;

int x, y;

gboolean rtl;

#if GTK_CHECK_VERSION (3, 20, 0)

device = gdk_seat_get_pointer (gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET(panel))));

gdk_window_get_device_position(gtk_widget_get_window (GTK_WIDGET(panel)), device, &x, &y, NULL);

device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gtk_widget_get_display (GTK_WIDGET(panel))));

gdk_window_get_device_position(gtk_widget_get_window (GTK_WIDGET(panel)), device, &x, &y, NULL);

#endif

rtl = gtk_widget_get_direction (GTK_WIDGET (panel)) == GTK_TEXT_DIR_RTL;

int pos;

int movement;

GtkWidget *applet;

GdkDevice *device;

GSList *forb;

GdkModifierType mods;

AppletData *ad;

#if GTK_CHECK_VERSION (3, 20, 0)

device = gdk_seat_get_pointer (gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (panel))));

gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET(panel)), device, NULL, NULL, &mods);

device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gtk_widget_get_display (GTK_WIDGET (panel))));

gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET(panel)), device, NULL, NULL, &mods);

#endif

movement = PANEL_SWITCH_MOVE;

move_timeout_handler(gpointer data)

{

PanelWidget *panel = data;

GdkDevice *device;

g_return_val_if_fail(PANEL_IS_WIDGET(data),FALSE);

#if GTK_CHECK_VERSION (3, 20, 0)

device = gdk_seat_get_pointer (gdk_display_get_default_seat (gtk_widget_get_display (widget)));

gdk_window_get_device_position (gtk_widget_get_window (widget), device, &x, &y, NULL);

device = gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gtk_widget_get_display (widget)));

gdk_window_get_device_position(gtk_widget_get_window (widget), device, &x, &y, NULL);

#endif

gtk_widget_get_allocation (widget, &allocation);

if (!mate_panel_applet_in_drag)

return FALSE;

return gtk_bindings_activate (G_OBJECT (panel),

((GdkEventKey *)event)->keyval,

((GdkEventKey *)event)->state);

}

{

g_signal_emit (panel, panel_widget_signals [BACK_CHANGE_SIGNAL], 0);

}

#else

static void

panel_widget_background_changed (PanelBackground *background,

#include "panel-xutils.h"

#include <glib.h>

#include <gdk/gdk.h>

#include <gdk/gdkx.h>

#include <X11/Xlib.h>

XChangeProperty (display, window, net_wm_strut_partial,

XA_CARDINAL, 32, PropModeReplace,

(guchar *) &struts, 12);

gdk_error_trap_pop_ignored ();

}

void

gdk_error_trap_push ();

XWarpPointer (display, None, window, 0, 0, 0, 0, x, y);

gdk_error_trap_pop_ignored ();

}

guint

#include <gio/gio.h>

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include <gtk/gtkx.h> /* for GTK_IS_SOCKET */

#include <libpanel-util/panel-glib.h>

if (GTK_IS_SOCKET (gtk_window_get_focus (GTK_WINDOW (widget))) &&

event->keyval == GDK_KEY_F10 &&

(event->state & gtk_accelerator_get_default_mod_mask ()) == GDK_CONTROL_MASK)

return gtk_bindings_activate (G_OBJECT (widget),

event->keyval,

event->state);

set_background_color (PanelToplevel *toplevel,

guint16 *dropped)

{

GdkRGBA color;

if (!dropped)

return FALSE;

! panel_profile_background_key_is_writable (toplevel, "type"))

return FALSE;

color.red = dropped [0];

color.green = dropped [1];

color.blue = dropped [2];

color.alpha = 1.;

panel_profile_set_background_color (toplevel, &color);

panel_profile_set_background_type (toplevel, PANEL_BACK_COLOR);

gdk_window_move_resize (window, x, y, w, h);

gdk_flush ();

gdk_error_trap_pop_ignored ();

g_object_set_data (G_OBJECT (window), "xstuff-cached-x", GINT_TO_POINTER (x));

g_object_set_data (G_OBJECT (window), "xstuff-cached-y", GINT_TO_POINTER (y));

}

static gboolean

zoom_draw (GtkWidget *widget,

cairo_t *cr,

gpointer user_data)

{

CompositedZoomData *zoom;

GdkPixbuf *scaled;

int width, height;

int x = 0, y = 0;

gtk_window_get_size (GTK_WINDOW (widget), &width, &height);

break;

}

cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);

cairo_set_source_rgba (cr, 0, 0, 0, 0.0);

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

cairo_set_operator (cr, CAIRO_OPERATOR_OVER);

cairo_paint_with_alpha (cr, MAX (zoom->opacity, 0));

g_object_unref (scaled);

}

gtk_window_set_keep_above (GTK_WINDOW (win), TRUE);

gtk_window_set_decorated (GTK_WINDOW (win), FALSE);

gtk_widget_set_app_paintable(win, TRUE);

gtk_widget_set_visual (win, gdk_screen_get_rgba_visual (gscreen));

gtk_window_set_gravity (GTK_WINDOW (win), GDK_GRAVITY_STATIC);

gtk_window_set_default_size (GTK_WINDOW (win),

gtk_window_move (GTK_WINDOW (win), wx, wy);

g_signal_connect (G_OBJECT (win), "draw",

G_CALLBACK (zoom_draw), zoom);

/* see doc for gtk_widget_set_app_paintable() */

gtk_widget_realize (win);

gdk_window_set_background_pattern (gtk_widget_get_window (win), NULL);

gtk_widget_show (win);

zoom->timeout_id = g_timeout_add (ZOOM_DELAY,

dpy = gdk_x11_display_get_xdisplay (gdk_screen_get_display (gscreen));

root_win = GDK_WINDOW_XID (gdk_screen_get_root_window (gscreen));

screen = gdk_screen_get_number (gscreen);

depth = DefaultDepth(dpy,screen);

/* frame GC */

gcv.function = GXxor;

/* this will raise the probability of the XORed color being different

* of the original color in PseudoColor when not all color cells are

XUngrabServer(dpy);

XFreeGC (dpy, frame_gc);

}

#undef FRAMES

int i;

display = gdk_display_get_default ();

n_screens = 1; /* gdk-3.10, The number of screens is always 1 */

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

GdkWindow *root;