#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <glib.h>

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

/* This is between GTK_PRIORITY_RESIZE (+10) and GDK_PRIORITY_REDRAW (+20) */

guint32 timestamp);

void meta_ui_window_menu_free (MetaWindowMenu *menu);

MetaImageWindow* meta_image_window_new (Display *xdisplay,

int screen_number,

int max_width,

GdkPixbuf *pixbuf,

int x,

int y);

GdkPixbuf* meta_gdk_pixbuf_get_from_pixmap (GdkPixbuf *dest,

Pixmap xpixmap,

MetaUIDirection meta_ui_get_direction (void);

GdkPixbuf *meta_ui_get_pixbuf_from_pixmap (Pixmap pmap);

#include "tabpopup.h"

/* Weirdly, gtk_style_attach() steals a reference count from the style passed in */

#if GTK_CHECK_VERSION(3, 0, 0)

#else

g_object_ref (GTK_WIDGET (frames)->style);

frame->style = gtk_style_attach (GTK_WIDGET (frames)->style, frame->window);

#if GTK_CHECK_VERSION(3, 0, 0)

static gboolean

meta_frames_draw (GtkWidget *widget,

cairo_t *cr)

#define UNUSED_VARIABLE

#endif

cairo_t *cr,

int width,

int height);

static void

draw_checkerboard (GdkDrawable *drawable,

int width,

int height)

{

gint i, j, xcount, ycount;

GdkColor color1, color2;

cairo_t *cr;

#define CHECK_SIZE 10

#define SPACING 2

color2.green = 50000;

color2.blue = 50000;

cr = gdk_cairo_create (drawable);

xcount = 0;

i = SPACING;

i += CHECK_SIZE + SPACING;

++xcount;

}

cairo_destroy (cr);

}

static void

cairo_t *cr,

int width, int height,

MetaGradientType type,

meta_gradient_add_alpha (pixbuf,

alphas, G_N_ELEMENTS (alphas),

META_GRADIENT_HORIZONTAL);

draw_checkerboard (drawable, width, height);

}

gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);

}

static void

cairo_t *cr,

int width, int height)

{

render_simple (drawable, cr, width, height, META_GRADIENT_VERTICAL, FALSE);

}

static void

cairo_t *cr,

int width, int height)

{

render_simple (drawable, cr, width, height, META_GRADIENT_HORIZONTAL, FALSE);

}

static void

cairo_t *cr,

int width, int height)

{

render_simple (drawable, cr, width, height, META_GRADIENT_DIAGONAL, FALSE);

}

static void

cairo_t *cr,

int width, int height)

{

render_simple (drawable, cr, width, height, META_GRADIENT_DIAGONAL, TRUE);

}

static void

cairo_t *cr,

int width, int height,

MetaGradientType type)

}

static void

cairo_t *cr,

int width, int height)

{

render_multi (drawable, cr, width, height, META_GRADIENT_VERTICAL);

}

static void

cairo_t *cr,

int width, int height)

{

render_multi (drawable, cr, width, height, META_GRADIENT_HORIZONTAL);

}

static void

cairo_t *cr,

int width, int height)

{

render_multi (drawable, cr, width, height, META_GRADIENT_DIAGONAL);

}

static void

cairo_t *cr,

int width, int height)

{

}

static gboolean

expose_callback (GtkWidget *widget,

GdkEventExpose *event,

gpointer data)

{

RenderGradientFunc func = data;

GdkWindow *window;

GtkAllocation allocation;

GtkStyle *style;

cairo_t *cr;

style = gtk_widget_get_style (widget);

gtk_widget_get_allocation (widget, &allocation);

window = gtk_widget_get_window (widget);

cr = gdk_cairo_create (window);

gdk_cairo_set_source_color (cr, &style->fg[gtk_widget_get_state (widget)]);

cr,

allocation.width,

allocation.height);

cairo_destroy (cr);

return TRUE;

}

static GtkWidget*

gtk_window_set_default_size (GTK_WINDOW (window), 175, 175);

g_signal_connect (G_OBJECT (drawing_area),

"expose_event",

G_CALLBACK (expose_callback),

func);

gtk_container_add (GTK_CONTAINER (window), drawing_area);

env->theme = meta_current_theme;

}

/* This code was originally rendering anti-aliased using X primitives, and

* now has been switched to draw anti-aliased using cairo. In general, the

* closest correspondence between X rendering and cairo rendering is given

j = 0;

while (j < META_BUTTON_TYPE_LAST)

{

button_rect (j, fgeom, middle_bg_offset, &rect);

if (op_list)

{

#include <string.h>

#include <stdlib.h>

static void meta_ui_accelerator_parse(const char* accel, guint* keysym, guint* keycode, GdkModifierType* keymask);

struct _MetaUI {

{

GdkDisplay *gdisplay;

MetaUI *ui;

GdkEvent gevent;

GdkWindow *gdk_window;

Window window;

if (!ui)

return FALSE;

gdk_window = gdk_window_lookup_for_display (gdisplay, window);

if (gdk_window == NULL)

return FALSE;

if (gdk_display_pointer_is_grabbed (gdisplay))

return FALSE;

memset (&gevent, 0, sizeof (gevent));

switch (xevent->type)

{

ABS (xevent->xbutton.x - ui->button_click_x) <= double_click_distance &&

ABS (xevent->xbutton.y - ui->button_click_y) <= double_click_distance)

{

gevent.button.type = GDK_2BUTTON_PRESS;

ui->button_click_number = 0;

}

else

{

gevent.button.type = GDK_BUTTON_PRESS;

ui->button_click_number = xevent->xbutton.button;

ui->button_click_window = xevent->xbutton.window;

ui->button_click_time = xevent->xbutton.time;

}

else

{

gevent.button.type = GDK_BUTTON_RELEASE;

}

gevent.button.window = gdk_window;

gevent.button.button = xevent->xbutton.button;

gevent.button.time = xevent->xbutton.time;

gevent.button.y = xevent->xbutton.y;

gevent.button.x_root = xevent->xbutton.x_root;

gevent.button.y_root = xevent->xbutton.y_root;

break;

case MotionNotify:

gevent.motion.type = GDK_MOTION_NOTIFY;

gevent.motion.window = gdk_window;

break;

case EnterNotify:

case LeaveNotify:

gevent.crossing.type = xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;

gevent.crossing.window = gdk_window;

gevent.crossing.x = xevent->xcrossing.x;

gevent.crossing.y = xevent->xcrossing.y;

break;

default:

g_assert_not_reached ();

}

/* If we've gotten here, we've filled in the gdk_event and should send it on */

gtk_main_do_event (&gevent);

return TRUE;

}

{

GdkWindow *window;

window = gdk_xid_table_lookup (xwindow);

if (window)

gdk_window_show_unraised (window);

{

GdkWindow *window;

window = gdk_xid_table_lookup (xwindow);

if (window)

gdk_window_hide (window);

meta_window_menu_free (menu);

}

struct _MetaImageWindow

{

GtkWidget *window;

gtk_window_set_screen (GTK_WINDOW (iw->window), gscreen);

gtk_widget_realize (iw->window);

max_width, max_height,

-1);

int x,

int y)

{

cairo_t *cr;

/* We use a back pixmap to avoid having to handle exposes, because

* it's really too slow for large clients being minimized, etc.

* and this way flicker is genuinely zero.

*/

gdk_draw_pixbuf (iw->pixmap,

0, 0,

0, 0,

gdk_pixbuf_get_width (pixbuf),

gdk_pixbuf_get_height (pixbuf),

GDK_RGB_DITHER_NORMAL,

0, 0);

cr = gdk_cairo_create (iw->pixmap);

gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);

cairo_paint (cr);

cairo_destroy (cr);

iw->pixmap,

FALSE);

x, y,

gdk_pixbuf_get_width (pixbuf),

gdk_pixbuf_get_height (pixbuf));

}

#if !GTK_CHECK_VERSION (3, 0, 0)

static GdkColormap*

}

#endif

GdkPixbuf*

int src_x,

int src_y,

int dest_x,

int width,

int height)

{

GdkPixbuf *retval;

else

return retval;

}

GdkPixbuf*

meta_gdk_pixbuf_get_from_pixmap (GdkPixbuf *dest,

Pixmap xpixmap,

cmap = NULL;

#endif

drawable = gdk_xid_table_lookup (xpixmap);

if (drawable)

g_object_ref (G_OBJECT (drawable));

return retval;

}

void

meta_ui_push_delay_exposes (MetaUI *ui)

{

GdkWindow *window;

window = gdk_xid_table_lookup (xwindow);

/* we shouldn't cause focus if we're an override redirect

* toplevel which is not foreign

meta_text_property_to_utf8 (Display *xdisplay,

const XTextProperty *prop)

{

char **list;

int count;

char *retval;

list = NULL;

count = gdk_text_property_to_utf8_list (gdk_x11_xatom_to_atom (prop->encoding),

prop->format,

prop->value,

prop->nitems,

&list);

if (count == 0)

retval = NULL;

*keycode = 0;

*mask = 0;

return TRUE;

meta_ui_accelerator_parse (accel, &gdk_sym, &gdk_code, &gdk_mask);

*mask = 0;

return TRUE;

meta_ui_accelerator_parse (accel, &gdk_sym, &gdk_code, &gdk_mask);

{

GdkWindow *window;

window = gdk_xid_table_lookup (xwindow);

if (window)

{

return META_UI_DIRECTION_LTR;

}

GdkPixbuf* meta_ui_get_pixbuf_from_pixmap(Pixmap pmap)

{

GdkPixmap* gpmap;

return pixbuf;

}