DISTCLEANFILES = intltool-extract intltool-merge intltool-update po/stamp-it po/.intltool-merge-cache

# Build ChangeLog from GIT history

ChangeLog:

$(AM_V_GEN) if test -d $(top_srcdir)/.git; then \

1.16.0

* Translations update

COMPILING MARCO

===

libstartup-notification at

http://www.freedesktop.org/software/startup-notification/.

- Boring window manager for the adult in you. Many window managers

are like Marshmallow Froot Loops; Marco is like Cheerios.

etc. come from GTK+ theme.

- Does not expose the concept of "window manager" to the user. Some

AC_PREREQ(2.50)

m4_define([marco_major_version], [1])

m4_define([marco_micro_version], [0])

m4_define([marco_version],

fi

changequote([,])dnl

GIO_MIN_VERSION=2.25.10

GLIB_GSETTINGS

AM_GLIB_GNU_GETTEXT

if $PKG_CONFIG --atleast-version 1.2.0 pangoxft; then

echo "pangoxft found"

dnl ==========================================================================

echo "

prefix: ${prefix}

source code location: ${srcdir}

ui/theme.c \

ui/theme.h

libmarco_private_la_LDFLAGS = -no-undefined -version-info 1:0:0

libmarco_private_la_LIBADD = @MARCO_LIBS@

libmarcoincludedir = $(includedir)/marco-1/marco-private

ui/theme-parser.h \

ui/theme.h

bin_PROGRAMS=marco

EFENCE=

marco_LDADD=@MARCO_LIBS@ $(EFENCE)

testboxes_SOURCES=include/util.h core/util.c include/boxes.h core/boxes.c core/testboxes.c

testgradient_SOURCES=ui/gradient.h ui/gradient.c ui/testgradient.c

void (*process_event) (MetaCompositor *compositor,

XEvent *event,

MetaWindow *window);

cairo_surface_t *(* get_window_surface) (MetaCompositor *compositor,

MetaWindow *window);

void (*set_active_window) (MetaCompositor *compositor,

MetaScreen *screen,

MetaWindow *window);

#include <gdk/gdk.h>

#include <gtk/gtk.h>

#include <cairo/cairo-xlib.h>

#include "display.h"

#include "screen.h"

#endif

}

static cairo_surface_t *

xrender_get_window_surface (MetaCompositor *compositor,

MetaWindow *window)

cw->attrs.width, cw->attrs.height);

#endif

}

static void

xrender_set_active_window (MetaCompositor *compositor,

xrender_remove_window,

xrender_set_updates,

xrender_process_event,

xrender_get_window_surface,

xrender_set_active_window,

xrender_free_window,

xrender_maximize_window,

#endif

}

cairo_surface_t *

meta_compositor_get_window_surface (MetaCompositor *compositor,

MetaWindow *window)

return NULL;

#endif

}

void

meta_compositor_set_active_window (MetaCompositor *compositor,

* (client-side) subwindow for individual menu items.

*/

GdkDeviceManager *device_manager = gdk_display_get_device_manager (gdk_display);

GdkDevice *device = gdk_device_manager_get_client_pointer (device_manager);

if (gdk_display_device_is_grabbed(gdk_display, device))

{

return FALSE;

}

if (gdk_display_device_is_grabbed(gdk_display, device))

{

return FALSE;

}

g_assert_not_reached();

break;

}

gdk_event_set_device (gdk_event, device);

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

gtk_main_do_event(gdk_event);

#include <gdk/gdk.h>

#include <gtk/gtk.h>

void

meta_error_trap_push (MetaDisplay *display)

{

return gdk_error_trap_pop ();

}

meta_ui_init (&argc, &argv);

/* Load prefs */

meta_prefs_init ();

meta_prefs_add_listener (prefs_changed_callback, NULL);

int *width,

int *height)

{

cairo_surface_t *surface;

GdkPixbuf *pixbuf, *scaled;

double ratio;

surface = meta_compositor_get_window_surface (window->display->compositor,

window);

if (surface == None)

return NULL;

meta_error_trap_push (NULL);

pixbuf = meta_ui_get_pixbuf_from_surface (surface);

if (meta_error_trap_pop_with_return (NULL, FALSE) != Success)

g_clear_object (&pixbuf);

if (pixbuf == NULL)

return NULL;

#include "iconcache.h"

#include <X11/Xutil.h>

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

typedef struct _MetaGroup MetaGroup;

typedef struct _MetaWindowQueue MetaWindowQueue;

#define META_COMPOSITOR_H

#include <glib.h>

#include <X11/Xlib.h>

#include "types.h"

#include "boxes.h"

void meta_compositor_process_event (MetaCompositor *compositor,

XEvent *event,

MetaWindow *window);

cairo_surface_t *meta_compositor_get_window_surface (MetaCompositor *compositor,

MetaWindow *window);

void meta_compositor_set_active_window (MetaCompositor *compositor,

MetaScreen *screen,

MetaWindow *window);

XErrorEvent *error,

gpointer data);

void meta_errors_register_foreign_display (Display *foreign_dpy,

ErrorHandler handler,

gpointer data);

#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) */

#define META_PRIORITY_RESIZE (G_PRIORITY_HIGH_IDLE + 15)

MetaUIDirection meta_ui_get_direction (void);

GdkPixbuf *meta_ui_get_pixbuf_from_surface (cairo_surface_t *surface);

#include "tabpopup.h"

#include "tile-preview.h"

Name: libmarco-private

Description: Marco internals shared

Version: @VERSION@

Libs: -L${libdir} -lmarco-private

Cflags: -I${includedir}/marco-1

#endif

screenshot = gdk_pixbuf_get_from_window(gdk_get_default_root_window(), last_grab_x, last_grab_y, last_grab_width, last_grab_height);

if (screenshot == NULL)

{

g_printerr ("Screenshot failed\n");

static void

shutdown_grab (void)

{

GdkDeviceManager *manager = gdk_display_get_device_manager (gdk_display_get_default ());

GdkDevice *device = gdk_device_manager_get_client_pointer (manager);

gdk_device_ungrab (device, gtk_get_current_event_time ());

gdk_device_ungrab (gdk_device_get_associated_device (device), gtk_get_current_event_time ());

gtk_grab_remove (grab_widget);

}

static void

begin_area_grab (void)

{

GdkWindow *window;

GdkDeviceManager *manager;

GdkDevice *device;

if (grab_widget == NULL)

{

gtk_widget_show (grab_widget);

}

window = gtk_widget_get_window (grab_widget);

manager = gdk_display_get_device_manager (gdk_display_get_default ());

device = gdk_device_manager_get_client_pointer (manager);

g_warning ("Failed to grab keyboard to do eyedropper");

return;

}

gtk_grab_add (grab_widget);

#include <X11/Xatom.h>

#include <unistd.h>

static void

do_appwindow (GSimpleAction *action,

GVariant *parameter,

gpointer user_data);

static gboolean aspect_on;

g_error_free (err);

}

do_appwindow (NULL, NULL, NULL);

gtk_main ();

}

}

static void

dialog_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

make_dialog (GTK_WIDGET (callback_data), 1);

}

static void

modal_dialog_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *dialog;

gtk_widget_destroy (dialog);

}

static void

no_parent_dialog_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

make_dialog (NULL, 1);

}

static void

utility_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *window;

GtkWidget *vbox;

gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));

gtk_container_add (GTK_CONTAINER (window), vbox);

gtk_widget_show_all (window);

}

static void

toolbar_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *window;

GtkWidget *vbox;

gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));

gtk_container_add (GTK_CONTAINER (window), vbox);

gtk_widget_show_all (window);

}

static void

menu_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *window;

GtkWidget *vbox;

gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));

gtk_container_add (GTK_CONTAINER (window), vbox);

gtk_widget_show_all (window);

}

static void

override_redirect_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *window;

GtkWidget *vbox;

window = gtk_window_new (GTK_WINDOW_POPUP);

gtk_window_set_title (GTK_WINDOW (window), "Override Redirect");

gtk_container_add (GTK_CONTAINER (window), vbox);

gtk_widget_show_all (window);

}

static void

border_only_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *window;

GtkWidget *vbox;

gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));

gtk_container_add (GTK_CONTAINER (window), vbox);

return label;

}

static void

splashscreen_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *window;

GtkWidget *image;

set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_SPLASHSCREEN");

gtk_window_set_title (GTK_WINDOW (window), "Splashscreen");

image = gtk_image_new_from_icon_name ("dialog-information", GTK_ICON_SIZE_DIALOG);

gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);

{

case DOCK_LEFT:

case DOCK_RIGHT:

break;

case DOCK_TOP:

case DOCK_BOTTOM:

break;

case DOCK_ALL:

break;

gtk_widget_show_all (window);

}

static void

dock_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

guint callback_action;

const gchar *name;

g_object_get (G_OBJECT (action), "name", &name, NULL);

if (!g_strcmp0 (name, "top-dock"))

callback_action = DOCK_ALL;

else

return;

if (callback_action == DOCK_ALL)

{

make_dock (DOCK_TOP);

}

#endif

static void

desktop_cb (GSimpleAction *action,

GVariant *parameter,

gpointer callback_data)

{

GtkWidget *window;

GtkWidget *label;

GdkRGBA desktop_color;

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_DESKTOP");

gdk_screen_width (), gdk_screen_height ());

gtk_window_move (GTK_WINDOW (window), 0, 0);

desktop_color.red = 0.32;

desktop_color.green = 0.46;

desktop_color.blue = 0.65;

#else

gtk_widget_override_background_color (window, 0, &desktop_color);

#endif

label = focus_label (window);

gtk_widget_show_all (window);

}

static void

sleep_cb (GSimpleAction *action,

GVariant *parameter,

gpointer data)

{

sleep (1000);

}

static void

toggle_aspect_ratio (GSimpleAction *action,

GVariant *parameter,

gpointer data)

{

GtkWidget *window;

GdkGeometry geom;

}

static void

toggle_decorated_cb (GSimpleAction *action,

GVariant *parameter,

gpointer data)

{

GtkWidget *window;

window = gtk_widget_get_ancestor (data, GTK_TYPE_WINDOW);

!gtk_window_get_decorated (GTK_WINDOW (window)));

}

static void

clicked_toolbar_cb (GSimpleAction *action,

GVariant *parameter,

gpointer data)

{

GtkWidget *dialog;

gtk_main_quit ();

}

static const gchar *xml =

"<interface>"

"<menu id='menubar'>"

return toolbar;

}

static void

do_appwindow (GSimpleAction *action,

GVariant *parameter,

gpointer user_data)

{

GtkWidget *window;

GtkWidget *grid;

GtkWidget *toolbar;

GSimpleActionGroup *action_group;

GtkBuilder *builder;

GtkWidget *statusbar;

GtkWidget *contents;

GtkWidget *sw;

g_signal_connect (G_OBJECT (window), "destroy",

G_CALLBACK (destroy_cb), NULL);

grid = gtk_grid_new ();

gtk_widget_set_vexpand (grid, TRUE);

gtk_widget_set_hexpand (grid, TRUE);

gtk_container_add (GTK_CONTAINER (window), grid);

action_group = g_simple_action_group_new ();

builder = gtk_builder_new_from_string (xml, -1);

toolbar = create_toolbar ();

gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 1, 1, 1);

gtk_widget_set_hexpand (toolbar, TRUE);

/* Create document

*/

gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),

GTK_SHADOW_IN);

gtk_grid_attach (GTK_GRID (grid), sw, 0, 2, 1, 1);

gtk_widget_set_hexpand (sw, TRUE);

gtk_widget_set_vexpand (sw, TRUE);

gtk_window_set_default_size (GTK_WINDOW (window),

200, 200);

gtk_container_add (GTK_CONTAINER (sw),

contents);

/* Create statusbar */

statusbar = gtk_statusbar_new ();

gtk_grid_attach (GTK_GRID (grid), statusbar, 0, 3, 1, 1);

gtk_widget_set_hexpand (statusbar, TRUE);

/* Show text widget info in the statusbar */

buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));

gtk_widget_show_all (window);

g_object_unref (action_group);

g_object_unref (builder);

}

static void

draw_window (GtkWidget *widget,

cairo_t *cr,

const WnckWindowDisplayInfo *win,

const GdkRectangle *winrect,

GtkStateType state)

{

GdkPixbuf *icon;

int icon_x, icon_y, icon_w, icon_h;

gboolean is_active;

GdkRGBA color;

GtkStyleContext *style;

is_active = win->is_active;

cairo_save (cr);

cairo_rectangle (cr, winrect->x, winrect->y, winrect->width, winrect->height);

cairo_clip (cr);

style = gtk_widget_get_style_context (widget);

if (is_active)

meta_gtk_style_get_light_color (style, state, &color);

gtk_style_context_get_background_color (style, state, &color);

#endif

gdk_cairo_set_source_rgba (cr, &color);

cairo_rectangle (cr,

winrect->x + 1, winrect->y + 1,

cairo_restore (cr);

}

gtk_style_context_get_color (style, state, &color);

gdk_cairo_set_source_rgba (cr, &color);

cairo_set_line_width (cr, 1.0);

cairo_rectangle (cr,

winrect->x + 0.5, winrect->y + 0.5,

MAX (0, winrect->width - 1), MAX (0, winrect->height - 1));

cairo_stroke (cr);

cairo_restore(cr);

}

void

wnck_draw_workspace (GtkWidget *widget,

cairo_t *cr,

int x,

int y,

int width,

{

int i;

GdkRectangle workspace_rect;

GtkStateFlags state;

GtkStyleContext *style;

workspace_rect.x = x;

workspace_rect.y = y;

workspace_rect.height = height;

if (is_active)

state = GTK_STATE_FLAG_SELECTED;

else if (workspace_background)

state = GTK_STATE_FLAG_PRELIGHT;

else

state = GTK_STATE_FLAG_NORMAL;

style = gtk_widget_get_style_context (widget);

cairo_save (cr);

if (workspace_background)

{

}

else

{

GdkRGBA color;

meta_gtk_style_get_dark_color (style,state, &color);

gdk_cairo_set_source_rgba (cr, &color);

cairo_rectangle (cr, x, y, width, height);

cairo_fill (cr);

}

i = 0;

while (i < n_windows)

{

screen_height, &workspace_rect, &winrect);

draw_window (widget,

cr,

win,

&winrect,

state);

++i;

}

cairo_restore(cr);

}

} WnckWindowDisplayInfo;

void wnck_draw_workspace (GtkWidget *widget,

cairo_t *cr,

int x,

int y,

int width,

*/

#include <config.h>

#include "fixedtip.h"

#include "ui.h"

*/

static GtkWidget *label = NULL;

static GdkScreen *screen = NULL;

static gboolean

return FALSE;

}

void

meta_fixed_tip_show (int screen_number,

int root_x, int root_y,

const char *markup_text)

{

gint w;

gint h;

gint mon_num;

GdkRectangle monitor;

gint screen_right_edge;

if (tip == NULL)

{

GdkVisual *visual;

tip = gtk_window_new (GTK_WINDOW_POPUP);

if (visual != NULL)

gtk_widget_set_visual (tip, visual);

gtk_widget_set_app_paintable (tip, TRUE);

gtk_window_set_resizable (GTK_WINDOW (tip), FALSE);

g_signal_connect (tip, "draw", G_CALLBACK (draw_handler), NULL);

label = gtk_label_new (NULL);

gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

#endif

gtk_widget_show (label);

gtk_container_set_border_width (GTK_CONTAINER (tip), 4);

gtk_container_add (GTK_CONTAINER (tip), label);

g_signal_connect (tip, "destroy",

G_CALLBACK (gtk_widget_destroyed), &tip);

}

mon_num = gdk_screen_get_monitor_at_point (screen, root_x, root_y);

gdk_screen_get_monitor_geometry (screen, mon_num, &monitor);

screen_right_edge = monitor.x + monitor.width;

gtk_label_set_markup (GTK_LABEL (label), markup_text);

#ifndef META_FIXED_TIP_H

#define META_FIXED_TIP_H

/**

* Displays a tooltip. There can be only one across the entire system.

* This function behaves identically whether or not a tooltip is already

#include <X11/extensions/shape.h>

#endif

#define DEFAULT_INNER_BUTTON_BORDER 3

static void meta_frames_class_init (MetaFramesClass *klass);

static void meta_frames_init (MetaFrames *frames);

static void meta_frames_destroy (GtkWidget *object);

static void meta_frames_finalize (GObject *object);

static void meta_frames_style_set (GtkWidget *widget,

GtkStyle *prev_style);

GdkEventMotion *event);

static gboolean meta_frames_destroy_event (GtkWidget *widget,

GdkEventAny *event);

static gboolean meta_frames_draw (GtkWidget *widget,

cairo_t *cr);

static gboolean meta_frames_enter_notify_event (GtkWidget *widget,

GdkEventCrossing *event);

static gboolean meta_frames_leave_notify_event (GtkWidget *widget,

static void meta_frames_paint_to_drawable (MetaFrames *frames,

MetaUIFrame *frame,

cairo_t *cr);

static void meta_frames_set_window_background (MetaFrames *frames,

MetaUIFrame *frame);

static void invalidate_whole_window (MetaFrames *frames,

MetaUIFrame *frame);

static GObject *

meta_frames_constructor (GType gtype,

guint n_properties,

GObject *object;

GObjectClass *gobject_class;

object = gobject_class->constructor (gtype, n_properties, properties);

g_object_set (object,

meta_frames_class_init (MetaFramesClass *class)

{

GObjectClass *gobject_class;

GtkWidgetClass *widget_class;

gobject_class = G_OBJECT_CLASS (class);

widget_class = (GtkWidgetClass*) class;

gobject_class->constructor = meta_frames_constructor;

gobject_class->finalize = meta_frames_finalize;

widget_class->destroy = meta_frames_destroy;

widget_class->style_set = meta_frames_style_set;

widget_class->realize = meta_frames_realize;

widget_class->unrealize = meta_frames_unrealize;

widget_class->draw = meta_frames_draw;

widget_class->destroy_event = meta_frames_destroy_event;

widget_class->button_press_event = meta_frames_button_press_event;

widget_class->button_release_event = meta_frames_button_release_event;

*listp = g_slist_prepend (*listp, value);

}

static void

meta_frames_destroy (GtkWidget *object)

{

GSList *winlist;

GSList *tmp;

}

g_slist_free (winlist);

}

static void

g_hash_table_destroy (frames->frames);

g_hash_table_destroy (frames->cache);

}

typedef struct

{

cairo_rectangle_int_t rect;

cairo_surface_t *pixmap;

} CachedFramePiece;

typedef struct

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

if (pixels->piece[i].pixmap)

cairo_surface_destroy (pixels->piece[i].pixmap);

g_free (pixels);

g_hash_table_remove (frames->cache, frame);

g_hash_table_foreach (frames->frames,

reattach_style_func, frames);

}

static void

MetaUIFrame *frame)

{

if (frame->style != NULL)

g_object_unref (frame->style);

frame->style = g_object_ref (gtk_widget_get_style_context (GTK_WIDGET (frames)));

}

void

g_hash_table_remove (frames->frames, &frame->xwindow);

g_object_unref (frame->style);

gdk_window_destroy (frame->window);

static void

meta_frames_realize (GtkWidget *widget)

{

}

static void

meta_frames_unrealize (GtkWidget *widget)

{

}

static MetaUIFrame*

MetaUIFrame *frame = meta_frames_lookup_window (frames, xwindow);

int old_width, old_height;

old_width = gdk_window_get_width (frame->window);

old_height = gdk_window_get_height (frame->window);

gdk_window_move_resize (frame->window, x, y, width, height);

MetaFrameControl control;

int x, y;

gdk_window_get_device_position (frame->window, event->device,

&x, &y, NULL);

/* Control is set to none unless it matches

* the current grab

MetaFrameControl control;

int x, y;

gdk_window_get_device_position (frame->window, event->device,

&x, &y, NULL);

control = get_control (frames, frame, x, y);

}

}

/* Returns a pixmap with a piece of the windows frame painted on it.

*/

static cairo_surface_t *

generate_pixmap (MetaFrames *frames,

MetaUIFrame *frame,

return result;

}

static void

populate_cache (MetaFrames *frames,

MetaUIFrame *frame)

}

static void

{

GdkRectangle frame_area;

GdkRectangle screen_area = { 0, 0, 0, 0 };

/* Chop off stuff outside the screen; this optimization

* is crucial to handle huge client windows,

META_CORE_GET_SCREEN_HEIGHT, &screen_area.height,

META_CORE_GET_END);

}

static void

cached_pixels_draw (CachedPixels *pixels,

cairo_t *cr,

}

}

static void

subtract_client_area (cairo_region_t *region, MetaUIFrame *frame)

{

return TRUE;

}

/* How far off the screen edge the window decorations should

* be drawn. Used only in meta_frames_paint_to_drawable, below.

*/

static void

meta_frames_paint_to_drawable (MetaFrames *frames,

MetaUIFrame *frame,

cairo_t *cr)

{

MetaFrameFlags flags;

MetaFrameType type;

meta_prefs_get_button_layout (&button_layout);

meta_theme_draw_frame_with_style (meta_theme_get_current (),

frame->style,

cr,

&button_layout,

button_states,

mini_icon, icon);

}

static void

if (frame_exists && style->window_background_color != NULL)

{

GdkRGBA color;

GdkVisual *visual;

meta_color_spec_render (style->window_background_color,

visual = gtk_widget_get_visual (GTK_WIDGET (frames));

if (gdk_visual_get_depth (visual) == 32) /* we have ARGB */

{

color.alpha = style->window_background_alpha / 255.0;

}

gdk_window_set_background_rgba (frame->window, &color);

}

else

{

gtk_style_context_set_background (frame->style, frame->window);

}

}

{

Window xwindow;

GdkWindow *window;

GtkStyleContext *style;

MetaFrameStyle *cache_style;

PangoLayout *layout;

int text_height;

struct _MetaFrames

{

GtkInvisible parent_instance;

GHashTable *text_heights;

struct _MetaFramesClass

{

GtkInvisibleClass parent_class;

};

GType meta_frames_get_type (void) G_GNUC_CONST;

#include "util.h"

#include <string.h>

/* This is all Alfredo's and Dan's usual very nice WindowMaker code,

* slightly GTK-ized

*/

static GdkPixbuf* meta_gradient_create_horizontal (int width,

int height,

const GdkRGBA *from,

int height,

const GdkRGBA *colors,

int count);

/* Used as the destroy notification function for gdk_pixbuf_new() */

free_buffer, NULL);

}

GdkPixbuf*

meta_gradient_create_simple (int width,

int height,

const GdkRGBA *from,

const GdkRGBA *to,

MetaGradientType style)

{

switch (style)

{

return NULL;

}

GdkPixbuf*

meta_gradient_create_multi (int width,

int height,

const GdkRGBA *colors,

int n_colors,

MetaGradientType style)

{

if (n_colors > 2)

{

switch (style)

* are alternated. I'm not sure what it's good for, just copied since

* WindowMaker had it.

*/

GdkPixbuf*

meta_gradient_create_interwoven (int width,

int height,

int thickness1,

const GdkRGBA colors2[2],

int thickness2)

{

int i, j, k, l, ll;

long r1, g1, b1, dr1, dg1, db1;

long r2, g2, b2, dr2, dg2, db2;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

r1 = (long)(colors1[0].red*0xffffff);

g1 = (long)(colors1[0].green*0xffffff);

b1 = (long)(colors1[0].blue*0xffffff);

dr2 = ((colors2[1].red-colors2[0].red)*0xffffff)/(int)height;

dg2 = ((colors2[1].green-colors2[0].green)*0xffffff)/(int)height;

db2 = ((colors2[1].blue-colors2[0].blue)*0xffffff)/(int)height;

for (i=0,k=0,l=0,ll=thickness1; i<height; i++)

{

* None

*----------------------------------------------------------------------

*/

static GdkPixbuf*

meta_gradient_create_horizontal (int width, int height,

const GdkRGBA *from,

const GdkRGBA *to)

{

int i;

long r, g, b, dr, dg, db;

ptr = pixels;

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

r0 = (guchar) (from->red * 0xff);

g0 = (guchar) (from->green * 0xff);

b0 = (guchar) (from->blue * 0xff);

rf = (guchar) (to->red * 0xff);

gf = (guchar) (to->green * 0xff);

bf = (guchar) (to->blue * 0xff);

r = r0 << 16;

g = g0 << 16;

* None

*----------------------------------------------------------------------

*/

static GdkPixbuf*

meta_gradient_create_vertical (int width, int height,

const GdkRGBA *from,

const GdkRGBA *to)

{

int i, j;

long r, g, b, dr, dg, db;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

r0 = (guchar) (from->red * 0xff);

g0 = (guchar) (from->green * 0xff);

b0 = (guchar) (from->blue * 0xff);

rf = (guchar) (to->red * 0xff);

gf = (guchar) (to->green * 0xff);

bf = (guchar) (to->blue * 0xff);

r = r0<<16;

g = g0<<16;

*----------------------------------------------------------------------

*/

static GdkPixbuf*

meta_gradient_create_diagonal (int width, int height,

const GdkRGBA *from,

const GdkRGBA *to)

{

GdkPixbuf *pixbuf, *tmp;

int j;

return pixbuf;

}

static GdkPixbuf*

meta_gradient_create_multi_horizontal (int width, int height,

const GdkRGBA *colors,

int count)

{

int i, j, k;

long r, g, b, dr, dg, db;

k = 0;

r = (long)(colors[0].red * 0xffffff);

g = (long)(colors[0].green * 0xffffff);

b = (long)(colors[0].blue * 0xffffff);

/* render the first line */

for (i=1; i<count; i++)

{

dr = (int)((colors[i].red - colors[i-1].red) *0xffffff)/(int)width2;

dg = (int)((colors[i].green - colors[i-1].green)*0xffffff)/(int)width2;

db = (int)((colors[i].blue - colors[i-1].blue) *0xffffff)/(int)width2;

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

{

*ptr++ = (unsigned char)(r>>16);

b += db;

k++;

}

r = (long)(colors[i].red * 0xffffff);

g = (long)(colors[i].green * 0xffffff);

b = (long)(colors[i].blue * 0xffffff);

}

for (j=k; j<width; j++)

{

*ptr++ = (unsigned char)(r>>16);

return pixbuf;

}

static GdkPixbuf*

meta_gradient_create_multi_vertical (int width, int height,

const GdkRGBA *colors,

int count)

{

int i, j, k;

long r, g, b, dr, dg, db;

k = 0;

r = (long)(colors[0].red * 0xffffff);

g = (long)(colors[0].green * 0xffffff);

b = (long)(colors[0].blue * 0xffffff);

for (i=1; i<count; i++)

{

dr = (int)((colors[i].red - colors[i-1].red) *0xffffff)/(int)height2;

dg = (int)((colors[i].green - colors[i-1].green)*0xffffff)/(int)height2;

db = (int)((colors[i].blue - colors[i-1].blue) *0xffffff)/(int)height2;

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

{

b += db;

k++;

}

r = (long)(colors[i].red * 0xffffff);

g = (long)(colors[i].green * 0xffffff);

b = (long)(colors[i].blue * 0xffffff);

}

if (k<height)

return pixbuf;

}

static GdkPixbuf*

meta_gradient_create_multi_diagonal (int width, int height,

const GdkRGBA *colors,

int count)

{

GdkPixbuf *pixbuf, *tmp;

float a, offset;

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

#include <gdk/gdk.h>

typedef enum

{

META_GRADIENT_LAST

} MetaGradientType;

GdkPixbuf* meta_gradient_create_simple (int width,

int height,

const GdkRGBA *from,

int thickness1,

const GdkRGBA colors2[2],

int thickness2);

/* Generate an alpha gradient and multiply it with the existing alpha

* channel of the given pixbuf

pos = user_data;

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

*x = pos->x;

*y = pos->y;

meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods);

accel_label = meta_accel_label_new_with_mnemonic (i18n_label);

gtk_widget_set_halign (accel_label, GTK_ALIGN_START);

gtk_container_add (GTK_CONTAINER (mi), accel_label);

gtk_widget_show (accel_label);

#include <string.h>

#include "util.h"

static void meta_accel_label_class_init (MetaAccelLabelClass *klass);

static void meta_accel_label_init (MetaAccelLabel *accel_label);

static void meta_accel_label_finalize (GObject *object);

static void meta_accel_label_update (MetaAccelLabel *accel_label);

static int meta_accel_label_get_accel_width (MetaAccelLabel *accel_label);

static void meta_accel_label_get_preferred_width (GtkWidget *widget,

gint *minimum,

gint *natural);

gint *natural);

static gboolean meta_accel_label_draw (GtkWidget *widget,

cairo_t *cr);

G_DEFINE_TYPE (MetaAccelLabel, meta_accel_label, GTK_TYPE_LABEL);

static void

meta_accel_label_class_init (MetaAccelLabelClass *class)

{

GObjectClass *gobject_class = G_OBJECT_CLASS (class);

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);

widget_class->get_preferred_width = meta_accel_label_get_preferred_width;

widget_class->get_preferred_height = meta_accel_label_get_preferred_height;

widget_class->draw = meta_accel_label_draw;

class->signal_quote1 = g_strdup ("<:");

class->signal_quote2 = g_strdup (":>");

}

static void

{

MetaAccelLabel *accel_label = META_ACCEL_LABEL (object);

accel_label->accel_mods = 0;

accel_label->accel_key = 0;

}

static void

g_free (accel_label->accel_string);

}

void

(accel_label->accel_string_width ? accel_label->accel_padding : 0));

}

static void

meta_accel_label_get_preferred_width (GtkWidget *widget,

gint *minimum,

{

GTK_WIDGET_CLASS (meta_accel_label_parent_class)->get_preferred_height (widget, minimum, natural);

}

static gboolean

meta_accel_label_draw (GtkWidget *widget,

return FALSE;

}

static void

meta_accel_label_update (MetaAccelLabel *accel_label)

{

static void meta_preview_class_init (MetaPreviewClass *klass);

static void meta_preview_init (MetaPreview *preview);

static void meta_preview_get_preferred_width(GtkWidget *widget,

gint *minimal, gint *natural);

static void meta_preview_get_preferred_height(GtkWidget *widget,

gint *minimal, gint *natural);

static void meta_preview_size_allocate (GtkWidget *widget,

GtkAllocation *allocation);

static gboolean meta_preview_draw (GtkWidget *widget,

cairo_t *cr);

static void meta_preview_finalize (GObject *object);

#define NO_CHILD_WIDTH 80

#define NO_CHILD_HEIGHT 20

G_DEFINE_TYPE (MetaPreview, meta_preview, GTK_TYPE_BIN);

static void

meta_preview_class_init (MetaPreviewClass *class)

GtkWidgetClass *widget_class;

widget_class = (GtkWidgetClass*) class;

gobject_class->finalize = meta_preview_finalize;

widget_class->draw = meta_preview_draw;

widget_class->get_preferred_width = meta_preview_get_preferred_width;

widget_class->get_preferred_height = meta_preview_get_preferred_height;

gtk_container_class_handle_border_width (GTK_CONTAINER_CLASS (class));

widget_class->size_allocate = meta_preview_size_allocate;

}

g_free (preview->title);

preview->title = NULL;

}

static void

}

}

}

static gboolean

meta_preview_draw (GtkWidget *widget,

*natural += border_width * 2;

}

static void

meta_preview_size_allocate (GtkWidget *widget,

GtkAllocation *allocation)

return default_icon;

}

meta_preview_get_clip_region (MetaPreview *preview, gint new_window_width, gint new_window_height)

{

GdkRectangle xrect;

gint flags;

MetaFrameLayout *fgeom;

MetaFrameStyle *frame_style;

flags = (META_PREVIEW (preview)->flags);

xrect.x = 0;

xrect.y = 0;

xrect.width = new_window_width;

xrect.height = new_window_height;

if (preview->theme == NULL)

return window_xregion;

fgeom = frame_style->layout;

if (fgeom->top_left_corner_rounded_radius != 0)

{

xrect.width = width;

xrect.height = 1;

}

}

xrect.width = width;

xrect.height = 1;

}

}

xrect.width = width;

xrect.height = 1;

}

}

xrect.width = width;

xrect.height = 1;

}

}

return window_xregion;

}

#include "theme.h"

#include <gtk/gtk.h>

#ifndef META_PREVIEW_WIDGET_H

#define META_PREVIEW_WIDGET_H

void meta_preview_set_button_layout (MetaPreview *preview,

const MetaButtonLayout *button_layout);

gint new_window_width,

gint new_window_height);

gtk_container_add (GTK_CONTAINER (popup->size_window), frame);

popup->size_label = gtk_label_new ("");

gtk_widget_set_margin_start (popup->size_label, 3);

gtk_widget_set_margin_end (popup->size_label, 3);

gtk_widget_set_margin_top (popup->size_label, 3);

gtk_widget_set_margin_bottom (popup->size_label, 3);

gtk_container_add (GTK_CONTAINER (frame), popup->size_label);

#include <gtk/gtk.h>

#include <math.h>

#define OUTSIDE_SELECT_RECT 2

#define INSIDE_SELECT_RECT 2

static void unselect_workspace (GtkWidget *widget);

static gboolean

outline_window_draw (GtkWidget *widget,

cairo_t *cr,

gpointer data)

{

MetaTabPopup *popup;

TabEntry *te;

popup = data;

return FALSE;

te = popup->current_selected_entry;

cairo_set_line_width (cr, 1.0);

cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);

cairo_rectangle (cr,

0.5, 0.5,

te->inner_rect.height + 1);

cairo_stroke (cr);

return FALSE;

}

MetaTabPopup *popup;

int i, left, right, top, bottom;

int height;

GtkWidget *grid;

GtkWidget *vbox;

GList *tmp;

GtkWidget *frame;

int max_label_width; /* the actual max width of the labels we create */

gtk_widget_set_app_paintable (popup->outline_window, TRUE);

gtk_widget_realize (popup->outline_window);

g_signal_connect (G_OBJECT (popup->outline_window), "draw",

G_CALLBACK (outline_window_draw), popup);

popup->window = gtk_window_new (GTK_WINDOW_POPUP);

if (i % width)

height += 1;

grid = gtk_grid_new ();

frame = gtk_frame_new (NULL);

gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);

gtk_container_set_border_width (GTK_CONTAINER (grid), 1);

gtk_container_add (GTK_CONTAINER (popup->window),

frame);

gtk_container_add (GTK_CONTAINER (frame),

vbox);

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

popup->label = gtk_label_new ("");

obj = gtk_widget_get_accessible (popup->label);

atk_object_set_role (obj, ATK_ROLE_STATUSBAR);

gtk_widget_set_margin_start (popup->label, 3);

gtk_widget_set_margin_end (popup->label, 3);

gtk_widget_set_margin_top (popup->label, 3);

gtk_widget_set_margin_bottom (popup->label, 3);

gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0);

if (te->blank)

{

/* just stick a widget here to avoid special cases */

image = gtk_label_new ("");

}

else if (outline)

{

gtk_misc_set_padding (GTK_MISC (image),

INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1,

INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1);

gtk_widget_set_halign (image, GTK_ALIGN_CENTER);

gtk_widget_set_valign (image, GTK_ALIGN_CENTER);

}

else

{

te->widget = image;

gtk_grid_attach (GTK_GRID (grid), te->widget, left, top, 1, 1);

/* Efficiency rules! */

gtk_label_set_markup (GTK_LABEL (popup->label),

te->title);

gtk_widget_get_preferred_size (popup->label, &req, NULL);

max_label_width = MAX (max_label_width, req.width);

tmp = tmp->next;

TabEntry *te)

{

GdkRectangle rect;

GdkWindow *window;

te->rect.x, te->rect.y,

te->rect.width, te->rect.height);

GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };

gdk_window_set_background_rgba (window, &black);

gdk_window_shape_combine_region (window,

region,

0, 0);

/* This should piss off gtk a bit, but we don't want to raise

* above the tab popup. So, instead of calling gtk_widget_show,

}

static void meta_select_image_class_init (MetaSelectImageClass *klass);

static gboolean meta_select_image_draw (GtkWidget *widget,

cairo_t *cr);

static GtkImageClass *parent_class;

widget_class = GTK_WIDGET_CLASS (klass);

widget_class->draw = meta_select_image_draw;

}

static gboolean

meta_select_image_draw (GtkWidget *widget,

cairo_t *cr)

misc = GTK_MISC (widget);

gtk_widget_get_preferred_size (widget, &requisition, NULL);

gtk_misc_get_alignment (misc, &xalign, &yalign);

gtk_misc_get_padding (misc, &xpad, &ypad);

return GTK_WIDGET_CLASS (parent_class)->draw (widget, cr);

}

#define META_TYPE_SELECT_WORKSPACE (meta_select_workspace_get_type ())

#define META_SELECT_WORKSPACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SELECT_WORKSPACE, MetaSelectWorkspace))

static void meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass);

static gboolean meta_select_workspace_draw (GtkWidget *widget,

cairo_t *cr);

GType

meta_select_workspace_get_type (void)

widget_class = GTK_WIDGET_CLASS (klass);

widget_class->draw = meta_select_workspace_draw;

}

/**

return wnck_window;

}

static gboolean

meta_select_workspace_draw (GtkWidget *widget,

cairo_t *cr)

return TRUE;

}

#include <gtk/gtk.h>

typedef void (* RenderGradientFunc) (

cairo_t *cr,

int width,

int height);

static void

draw_checkerboard (cairo_t *cr,

int width,

int height)

{

gint i, j, xcount, ycount;

GdkRGBA color1, color2;

#define CHECK_SIZE 10

#define SPACING 2

color1.red = 30000. / 65535.;

color1.green = 30000. / 65535.;

color1.blue = 30000. / 65535.;

color2.green = 50000. / 65535.;

color2.blue = 50000. / 65535.;

color2.alpha = 1.0;

xcount = 0;

i = SPACING;

while (j < height)

{

if (ycount % 2)

gdk_cairo_set_source_rgba (cr, &color1);

else

gdk_cairo_set_source_rgba (cr, &color2);

/* If we're outside event->area, this will do nothing.

* It might be mildly more efficient if we handled

i += CHECK_SIZE + SPACING;

++xcount;

}

}

static void

render_simple (

cairo_t *cr,

int width, int height,

MetaGradientType type,

gboolean with_alpha)

{

GdkPixbuf *pixbuf;

GdkRGBA from, to;

gdk_rgba_parse (&from, "blue");

gdk_rgba_parse (&to, "green");

pixbuf = meta_gradient_create_simple (width, height,

&from, &to,

alphas, G_N_ELEMENTS (alphas),

META_GRADIENT_HORIZONTAL);

draw_checkerboard (cr, width, height);

}

gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);

static void

render_vertical_func (

cairo_t *cr,

int width, int height)

{

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

}

static void

render_horizontal_func (

cairo_t *cr,

int width, int height)

{

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

}

static void

render_diagonal_func (

cairo_t *cr,

int width, int height)

{

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

}

static void

render_diagonal_alpha_func (

cairo_t *cr,

int width, int height)

{

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

}

static void

render_multi (

cairo_t *cr,

int width, int height,

MetaGradientType type)

GdkPixbuf *pixbuf;

#define N_COLORS 5

GdkRGBA colors[N_COLORS];

gdk_rgba_parse (&colors[0], "red");

gdk_rgba_parse (&colors[2], "orange");

gdk_rgba_parse (&colors[3], "pink");

gdk_rgba_parse (&colors[4], "green");

pixbuf = meta_gradient_create_multi (width, height,

colors, N_COLORS,

static void

render_vertical_multi_func (

cairo_t *cr,

int width, int height)

{

render_multi (cr, width, height, META_GRADIENT_VERTICAL);

}

static void

render_horizontal_multi_func (

cairo_t *cr,

int width, int height)

{

render_multi (cr, width, height, META_GRADIENT_HORIZONTAL);

}

static void

render_diagonal_multi_func (

cairo_t *cr,

int width, int height)

{

render_multi (cr, width, height, META_GRADIENT_DIAGONAL);

}

static void

render_interwoven_func (

cairo_t *cr,

int width, int height)

{

GdkPixbuf *pixbuf;

#define N_COLORS 4

GdkRGBA colors[N_COLORS];

gdk_rgba_parse (&colors[0], "red");

gdk_rgba_parse (&colors[1], "blue");

gdk_rgba_parse (&colors[2], "pink");

gdk_rgba_parse (&colors[3], "green");

pixbuf = meta_gradient_create_interwoven (width, height,

colors, height / 10,

}

static gboolean

draw_callback (GtkWidget *widget,

cairo_t *cr,

gpointer data)

{

RenderGradientFunc func = data;

GtkAllocation allocation;

GtkStyleContext *style;

GdkRGBA color;

gtk_style_context_set_state (style, gtk_widget_get_state_flags (widget));

gtk_style_context_lookup_color (style, "foreground-color", &color);

gtk_style_context_restore (style);

gtk_widget_get_allocation (widget, &allocation);

cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha);

(* func) (

cr,

allocation.width,

allocation.height);

return FALSE;

}

static GtkWidget*

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

g_signal_connect (G_OBJECT (drawing_area),

"draw",

G_CALLBACK (draw_callback),

func);

gtk_container_add (GTK_CONTAINER (window), drawing_area);

#define _(x) dgettext (GETTEXT_PACKAGE, x)

#define N_(x) x

/* We need to compute all different button arrangements

* in terms of button location. We don't care about

* different arrangements in terms of button function.

GtkWidget *image;

GtkWidget *button;

action_area = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);

gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area),

GTK_BUTTONBOX_END);

label = gtk_label_new (_("This is a sample message in a sample dialog"));

image = gtk_image_new_from_icon_name ("dialog-information",

GTK_ICON_SIZE_DIALOG);

gtk_widget_set_halign (image, GTK_ALIGN_CENTER);

gtk_widget_set_valign (image, GTK_ALIGN_START);

gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

gtk_label_set_selectable (GTK_LABEL (label), TRUE);

gtk_box_pack_start (GTK_BOX (hbox), image,

FALSE, FALSE, 0);

gtk_frame_set_shadow_type (GTK_FRAME (frame),

GTK_SHADOW_OUT);

i = 0;

while (i < 10)

{

char *str = g_strdup_printf (_("Fake menu item %d\n"), i + 1);

mi = gtk_label_new (str);

gtk_widget_set_halign (mi, GTK_ALIGN_START);

gtk_widget_set_valign (mi, GTK_ALIGN_CENTER);

g_free (str);

gtk_box_pack_start (GTK_BOX (vbox), mi, FALSE, FALSE, 0);

color.blue = 40000;

gtk_widget_modify_bg (event_box, GTK_STATE_NORMAL, &color);

gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);

w = gtk_label_new (_("Border-only window"));

GTK_POLICY_AUTOMATIC,

GTK_POLICY_AUTOMATIC);

gtk_box_set_spacing (GTK_BOX (box), 20);

gtk_container_set_border_width (GTK_CONTAINER (box), 20);

GTK_POLICY_AUTOMATIC,

GTK_POLICY_AUTOMATIC);

gtk_box_set_spacing (GTK_BOX (box), 20);

gtk_container_set_border_width (GTK_CONTAINER (box), 20);

#define __USE_XOPEN

#include <math.h>

#define GDK_COLOR_RGBA(color) \

((guint32) (0xff | \

((int)((color).red * 255) << 24) | \

((guint32) (((int)((color).red * 255) << 16) | \

((int)((color).green * 255) << 8) | \

((int)((color).blue * 255))))

#define ALPHA_TO_UCHAR(d) ((unsigned char) ((d) * 255))

#define CLAMP_UCHAR(v) ((guchar) (CLAMP (((int)v), (int)0, (int)255)))

#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)

static void gtk_style_shade (GdkRGBA *a,

GdkRGBA *b,

gdouble k);

static void rgb_to_hls (gdouble *r,

gdouble *g,

gdouble *b);

*/

static MetaTheme *meta_current_theme = NULL;

static GdkPixbuf *

colorize_pixbuf (GdkPixbuf *orig,

GdkRGBA *new_color)

{

GdkPixbuf *pixbuf;

double intensity;

if (intensity <= 0.5)

{

/* Go from black at intensity = 0.0 to new_color at intensity = 0.5 */

dr = new_color->red * intensity * 2.0;

dg = new_color->green * intensity * 2.0;

db = new_color->blue * intensity * 2.0;

}

else

{

/* Go from new_color at intensity = 0.5 to white at intensity = 1.0 */

dr = new_color->red + (1.0 - new_color->red) * (intensity - 0.5) * 2.0;

dg = new_color->green + (1.0 - new_color->green) * (intensity - 0.5) * 2.0;

db = new_color->blue + (1.0 - new_color->blue) * (intensity - 0.5) * 2.0;

}

dest[0] = CLAMP_UCHAR (255 * dr);

return pixbuf;

}

static void

color_composite (const GdkRGBA *bg,

const GdkRGBA *fg,

color->green = color->green + (fg->green - color->green) * alpha;

color->blue = color->blue + (fg->blue - color->blue) * alpha;

}

/**

* Sets all the fields of a border to dummy values.

{

int buttons_height, title_height;

g_return_if_fail (layout != NULL);

if (!layout->has_title)

text_height = 0;

g_free (spec);

}

GdkPixbuf*

meta_gradient_spec_render (const MetaGradientSpec *spec,

GtkStyleContext *style,

int width,

int height)

{

int n_colors;

GdkRGBA *colors;

GSList *tmp;

int i;

GdkPixbuf *pixbuf;

if (n_colors == 0)

return NULL;

colors = g_new (GdkRGBA, n_colors);

i = 0;

tmp = spec->color_specs;

const char *bracket;

const char *end_bracket;

char *tmp;

GtkStateFlags state;

MetaGtkColorComponent component;

bracket = str;

{

spec = meta_color_spec_new (META_COLOR_SPEC_BASIC);

if (!gdk_rgba_parse (&spec->data.basic.color, str))

{

g_set_error (err, META_THEME_ERROR,

META_THEME_ERROR_FAILED,

return spec;

}

MetaColorSpec*

meta_color_spec_new_gtk (MetaGtkColorComponent component,

GtkStateFlags state)

{

MetaColorSpec *spec;

return spec;

}

static void

get_background_color_real (GtkStyleContext *context,

GtkStateFlags state,

break;

}

}

void

meta_color_spec_render (MetaColorSpec *spec,

GtkStyleContext *style,

GdkRGBA *color)

{

g_return_if_fail (spec != NULL);

g_return_if_fail (GTK_IS_STYLE_CONTEXT (style));

switch (spec->type)

{

case META_COLOR_SPEC_BLEND:

{

GdkRGBA bg, fg;

meta_color_spec_render (spec->data.blend.background, style, &bg);

meta_color_spec_render (spec->data.blend.foreground, style, &fg);

static GdkPixbuf*

draw_op_as_pixbuf (const MetaDrawOp *op,

GtkStyleContext *style,

const MetaDrawInfo *info,

int width,

int height)

case META_DRAW_RECTANGLE:

if (op->data.rectangle.filled)

{

GdkRGBA color;

meta_color_spec_render (op->data.rectangle.color_spec,

style,

case META_DRAW_TINT:

{

GdkRGBA color;

guint32 rgba;

gboolean has_alpha;

{

if (op->data.image.colorize_spec)

{

GdkRGBA color;

meta_color_spec_render (op->data.image.colorize_spec,

style, &color);

*/

static void

meta_draw_op_draw_with_env (const MetaDrawOp *op,

GtkStyleContext *style_gtk,

cairo_t *cr,

const MetaDrawInfo *info,

MetaRectangle rect,

MetaPositionExprEnv *env)

{

GdkRGBA color;

cairo_save (cr);

gtk_style_context_save (style_gtk);

cairo_set_line_width (cr, 1.0);

switch (op->type)

{

case META_DRAW_LINE:

int x1, x2, y1, y2;

meta_color_spec_render (op->data.line.color_spec, style_gtk, &color);

gdk_cairo_set_source_rgba (cr, &color);

if (op->data.line.width > 0)

cairo_set_line_width (cr, op->data.line.width);

int rx, ry, rwidth, rheight;

meta_color_spec_render (op->data.rectangle.color_spec, style_gtk, &color);

gdk_cairo_set_source_rgba (cr, &color);

rx = parse_x_position_unchecked (op->data.rectangle.x, env);

ry = parse_y_position_unchecked (op->data.rectangle.y, env);

double center_x, center_y;

meta_color_spec_render (op->data.arc.color_spec, style_gtk, &color);

gdk_cairo_set_source_rgba (cr, &color);

rx = parse_x_position_unchecked (op->data.arc.x, env);

ry = parse_y_position_unchecked (op->data.arc.y, env);

if (!needs_alpha)

{

meta_color_spec_render (op->data.tint.color_spec, style_gtk, &color);

gdk_cairo_set_source_rgba (cr, &color);

cairo_rectangle (cr, rx, ry, rwidth, rheight);

cairo_fill (cr);

rwidth = parse_size_unchecked (op->data.gtk_arrow.width, env);

rheight = parse_size_unchecked (op->data.gtk_arrow.height, env);

double size = MAX(rwidth, rheight), angle = 0;

switch (op->data.gtk_arrow.arrow)

gtk_style_context_set_state (style_gtk, op->data.gtk_arrow.state);

gtk_render_arrow (style_gtk, cr, angle, rx, ry, size);

}

break;

rwidth = parse_size_unchecked (op->data.gtk_box.width, env);

rheight = parse_size_unchecked (op->data.gtk_box.height, env);

gtk_style_context_set_state (style_gtk, op->data.gtk_box.state);

gtk_render_background (style_gtk, cr, rx, ry, rwidth, rheight);

gtk_render_frame (style_gtk, cr, rx, ry, rwidth, rheight);

}

break;

ry1 = parse_y_position_unchecked (op->data.gtk_vline.y1, env);

ry2 = parse_y_position_unchecked (op->data.gtk_vline.y2, env);

gtk_style_context_set_state (style_gtk, op->data.gtk_vline.state);

gtk_render_line (style_gtk, cr, rx, ry1, rx, ry2);

}

break;

int rx, ry;

meta_color_spec_render (op->data.title.color_spec, style_gtk, &color);

gdk_cairo_set_source_rgba (cr, &color);

rx = parse_x_position_unchecked (op->data.title.x, env);

ry = parse_y_position_unchecked (op->data.title.y, env);

cairo_pattern_t *linpat;

linpat = cairo_pattern_create_linear (rx, ry, text_space,

env->title_height);

cairo_pattern_add_color_stop_rgba (linpat, 0, color.red,

color.green,

color.blue,

cairo_pattern_add_color_stop_rgba (linpat, 1, color.red,

color.green,

color.blue, 0);

cairo_set_source(cr, linpat);

cairo_pattern_destroy(linpat);

} else {

gdk_cairo_set_source_rgba (cr, &color);

}

cairo_move_to (cr, rx, ry);

d_rect.height = parse_size_unchecked (op->data.op_list.height, env);

meta_draw_op_list_draw_with_style (op->data.op_list.op_list,

style_gtk,

cr,

info, d_rect);

}

break;

{

int rx, ry, rwidth, rheight;

int tile_xoffset, tile_yoffset;

MetaRectangle tile;

rx = parse_x_position_unchecked (op->data.tile.x, env);

rwidth = parse_size_unchecked (op->data.tile.width, env);

rheight = parse_size_unchecked (op->data.tile.height, env);

cairo_save (cr);

cairo_rectangle (cr, rx, ry, rwidth, rheight);

tile.x += tile.width;

}

cairo_restore (cr);

}

break;

}

cairo_restore (cr);

gtk_style_context_restore (style_gtk);

}

void

meta_draw_op_draw_with_style (const MetaDrawOp *op,

GtkStyleContext *style_gtk,

cairo_t *cr,

const MetaDrawInfo *info,

MetaRectangle logical_region)

{

fill_env (&env, info, logical_region);

meta_draw_op_draw_with_env (op,

style_gtk,

cr,

info, logical_region,

&env);

void

meta_draw_op_draw (const MetaDrawOp *op,

GtkWidget *widget,

cairo_t *cr,

const MetaDrawInfo *info,

MetaRectangle logical_region)

{

meta_draw_op_draw_with_style (op,

gtk_widget_get_style_context (widget),

cr,

info, logical_region);

}

void

meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list,

GtkStyleContext *style_gtk,

cairo_t *cr,

const MetaDrawInfo *info,

MetaRectangle rect)

{

/* BOOKMARK */

int i;

MetaPositionExprEnv env;

if (op_list->n_ops == 0)

* adjacent items when possible.

*/

cairo_save (cr);

for (i = 0; i < op_list->n_ops; i++)

{

MetaDrawOp *op = op_list->ops[i];

if (op->type == META_DRAW_CLIP)

{

cairo_restore (cr);

{

meta_draw_op_draw_with_env (op, style_gtk, cr, info, rect, &env);

}

}

cairo_restore (cr);

}

void

meta_draw_op_list_draw (const MetaDrawOpList *op_list,

GtkWidget *widget,

cairo_t *cr,

const MetaDrawInfo *info,

MetaRectangle rect)

{

meta_draw_op_list_draw_with_style (op_list,

gtk_widget_get_style_context (widget),

cr,

info, rect);

}

void

meta_frame_style_draw_with_style (MetaFrameStyle *style,

GtkStyleContext *style_gtk,

cairo_t *cr,

const MetaFrameGeometry *fgeom,

int client_width,

int client_height,

while (i < META_FRAME_PIECE_LAST)

{

GdkRectangle rect;

switch ((MetaFramePiece) i)

{

break;

}

cairo_save (cr);

gdk_cairo_rectangle (cr, &rect);

cairo_restore (cr);

/* Draw buttons just before overlay */

if ((i + 1) == META_FRAME_PIECE_OVERLAY)

{

MetaDrawOpList *op_list;

}

}

++i;

}

}

void

meta_frame_style_draw (MetaFrameStyle *style,

GtkWidget *widget,

cairo_t *cr,

const MetaFrameGeometry *fgeom,

int client_width,

int client_height,

GdkPixbuf *icon)

{

meta_frame_style_draw_with_style (style,

gtk_widget_get_style_context (widget),

cr,

fgeom, client_width, client_height,

title_layout, text_height,

button_states, mini_icon, icon);

void

meta_theme_draw_frame_with_style (MetaTheme *theme,

GtkStyleContext *style_gtk,

cairo_t *cr,

MetaFrameType type,

MetaFrameFlags flags,

int client_width,

theme);

meta_frame_style_draw_with_style (style,

style_gtk,

cr,

&fgeom,

client_width, client_height,

title_layout,

void

meta_theme_draw_frame (MetaTheme *theme,

GtkWidget *widget,

cairo_t *cr,

MetaFrameType type,

MetaFrameFlags flags,

int client_width,

GdkPixbuf *icon)

{

meta_theme_draw_frame_with_style (theme,

gtk_widget_get_style_context (widget),

cr,

type, flags, client_width, client_height,

title_layout, text_height,

button_layout, button_states,

void

meta_theme_draw_frame_by_name (MetaTheme *theme,

GtkWidget *widget,

cairo_t *cr,

const gchar *style_name,

MetaFrameFlags flags,

int client_width,

meta_frame_style_draw (style,

widget,

cr,

&fgeom,

client_width, client_height,

title_layout,

{

PangoFontDescription *font_desc;

GtkStyleContext *style = gtk_widget_get_style_context (widget);

GtkStateFlags state = gtk_widget_get_state_flags (widget);

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

font_desc = pango_font_description_copy (font_desc);

if (override)

pango_font_description_merge (font_desc, override, TRUE);

return "<unknown>";

}

GtkStateFlags

meta_gtk_state_from_string (const char *str)

{

else

return -1; /* hack */

}

GtkShadowType

meta_gtk_shadow_from_string (const char *str)

* \param b [out] the resulting colour

* \param k amount to scale lightness and saturation by

*/

static void

gtk_style_shade (GdkRGBA *a,

GdkRGBA *b,

gdouble k)

{

gdouble red;

gdouble green;

gdouble blue;

red = a->red;

green = a->green;

blue = a->blue;

rgb_to_hls (&red, &green, &blue);

hls_to_rgb (&red, &green, &blue);

b->red = red;

b->green = green;

b->blue = blue;

}

/**

union

{

struct {

GdkRGBA color;

} basic;

struct {

MetaGtkColorComponent component;

GtkStateFlags state;

} gtk;

struct {

MetaColorSpec *foreground;

MetaColorSpec *background;

double alpha;

GdkRGBA color;

} blend;

struct {

MetaColorSpec *base;

double factor;

GdkRGBA color;

} shade;

} data;

};

} image;

struct {

GtkStateFlags state;

GtkShadowType shadow;

GtkArrowType arrow;

gboolean filled;

} gtk_arrow;

struct {

GtkStateFlags state;

GtkShadowType shadow;

MetaDrawSpec *x;

MetaDrawSpec *y;

} gtk_box;

struct {

GtkStateFlags state;

MetaDrawSpec *x;

MetaDrawSpec *y1;

MetaDrawSpec *y2;

MetaColorSpec* meta_color_spec_new (MetaColorSpecType type);

MetaColorSpec* meta_color_spec_new_from_string (const char *str,

GError **err);

MetaColorSpec* meta_color_spec_new_gtk (MetaGtkColorComponent component,

GtkStateFlags state);

void meta_color_spec_free (MetaColorSpec *spec);

void meta_color_spec_render (MetaColorSpec *spec,

GtkStyleContext *style_gtk,

GdkRGBA *color);

MetaDrawOp* meta_draw_op_new (MetaDrawType type);

void meta_draw_op_free (MetaDrawOp *op);

void meta_draw_op_draw (const MetaDrawOp *op,

GtkWidget *widget,

cairo_t *cr,

const MetaDrawInfo *info,

/* logical region being drawn */

MetaRectangle logical_region);

void meta_draw_op_draw_with_style (const MetaDrawOp *op,

GtkStyleContext *style_gtk,

cairo_t *cr,

const MetaDrawInfo *info,

/* logical region being drawn */

MetaRectangle logical_region);

void meta_draw_op_list_unref (MetaDrawOpList *op_list);

void meta_draw_op_list_draw (const MetaDrawOpList *op_list,

GtkWidget *widget,

cairo_t *cr,

const MetaDrawInfo *info,

MetaRectangle rect);

void meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list,

GtkStyleContext *style_gtk,

cairo_t *cr,

const MetaDrawInfo *info,

MetaRectangle rect);

void meta_draw_op_list_append (MetaDrawOpList *op_list,

MetaGradientSpec* meta_gradient_spec_new (MetaGradientType type);

void meta_gradient_spec_free (MetaGradientSpec *desc);

GdkPixbuf* meta_gradient_spec_render (const MetaGradientSpec *desc,

GtkStyleContext *style_gtk,

int width,

int height);

gboolean meta_gradient_spec_validate (MetaGradientSpec *spec,

GError **error);

void meta_frame_style_draw (MetaFrameStyle *style,

GtkWidget *widget,

cairo_t *cr,

const MetaFrameGeometry *fgeom,

int client_width,

int client_height,

void meta_frame_style_draw_with_style (MetaFrameStyle *style,

GtkStyleContext *style_gtk,

cairo_t *cr,

const MetaFrameGeometry *fgeom,

int client_width,

int client_height,

void meta_theme_draw_frame (MetaTheme *theme,

GtkWidget *widget,

cairo_t *cr,

MetaFrameType type,

MetaFrameFlags flags,

int client_width,

void meta_theme_draw_frame_by_name (MetaTheme *theme,

GtkWidget *widget,

cairo_t *cr,

const gchar *style_name,

MetaFrameFlags flags,

int client_width,

GdkPixbuf *icon);

void meta_theme_draw_frame_with_style (MetaTheme *theme,

GtkStyleContext *style_gtk,

cairo_t *cr,

MetaFrameType type,

MetaFrameFlags flags,

int client_width,

const char* meta_frame_type_to_string (MetaFrameType type);

MetaGradientType meta_gradient_type_from_string (const char *str);

const char* meta_gradient_type_to_string (MetaGradientType type);

GtkStateFlags meta_gtk_state_from_string (const char *str);

GtkShadowType meta_gtk_shadow_from_string (const char *str);

const char* meta_gtk_shadow_to_string (GtkShadowType shadow);

GtkArrowType meta_gtk_arrow_from_string (const char *str);

const char* meta_gtk_arrow_to_string (GtkArrowType arrow);

MetaImageFillType meta_image_fill_type_from_string (const char *str);

const char* meta_image_fill_type_to_string (MetaImageFillType fill_type);

void meta_gtk_style_get_light_color (GtkStyleContext *style,

GtkStateFlags state,

GdkRGBA *color);

void meta_gtk_style_get_dark_color (GtkStyleContext *style,

GtkStateFlags state,

GdkRGBA *color);

guint meta_theme_earliest_version_with_button (MetaButtonType type);

struct _MetaTilePreview {

GtkWidget *preview_window;

GdkRGBA *preview_color;

MetaRectangle tile_rect;

};

static gboolean

meta_tile_preview_draw (GtkWidget *widget,

cairo_t *cr,

gpointer user_data)

{

MetaTilePreview *preview = user_data;

cairo_set_line_width (cr, 1.0);

if (preview->has_alpha)

{

/* Fill the preview area with a transparent color */

gdk_cairo_set_source_rgba (cr, preview->preview_color);

cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);

cairo_paint (cr);

/* Use the opaque color for the border */

gdk_cairo_set_source_rgba (cr, preview->preview_color);

}

else

{

GdkRGBA white = {1.0, 1.0, 1.0, 1.0};

gdk_cairo_set_source_rgba (cr, &white);

cairo_rectangle (cr,

OUTLINE_WIDTH - 0.5, OUTLINE_WIDTH - 0.5,

preview->tile_rect.width - 1,

preview->tile_rect.height - 1);

if (preview->has_alpha) {

cairo_fill_preserve (cr);

cairo_set_source_rgba (cr, preview->preview_color->red, preview->preview_color->green, preview->preview_color->blue, 1.0);

}

return FALSE;

}

gpointer user_data)

{

MetaTilePreview *preview = user_data;

GtkStyleContext *context = gtk_style_context_new ();

GtkWidgetPath *path = gtk_widget_path_new ();

guchar alpha = 0xFF;

gtk_widget_path_free (path);

g_object_unref (context);

}

MetaTilePreview *

meta_tile_preview_new (int screen_number)

{

MetaTilePreview *preview;

GdkScreen *screen;

screen = gdk_display_get_screen (gdk_display_get_default (), screen_number);

preview = g_new (MetaTilePreview, 1);

gtk_widget_set_app_paintable (preview->preview_window, TRUE);

preview->preview_color = NULL;

preview->tile_rect.x = preview->tile_rect.y = 0;

preview->tile_rect.width = preview->tile_rect.height = 0;

gtk_widget_set_visual (preview->preview_window,

gdk_screen_get_rgba_visual (screen));

g_signal_connect (preview->preview_window, "style-set",

G_CALLBACK (on_preview_window_style_set), preview);

gtk_widget_realize (preview->preview_window);

g_signal_connect (preview->preview_window, "draw",

G_CALLBACK (meta_tile_preview_draw), preview);

return preview;

}

gtk_widget_destroy (preview->preview_window);

if (preview->preview_color)

gdk_rgba_free (preview->preview_color);

g_free (preview);

}

if (!preview->has_alpha)

{

cairo_rectangle_int_t outer_rect, inner_rect;

cairo_region_t *outer_region, *inner_region;

GdkRGBA black = {.0, .0, .0, 1.0};

gdk_window_set_background_rgba (window, &black);

outer_rect.x = outer_rect.y = 0;

outer_rect.width = preview->tile_rect.width;

inner_rect.width = outer_rect.width - 2 * OUTLINE_WIDTH;

inner_rect.height = outer_rect.height - 2 * OUTLINE_WIDTH;

outer_region = cairo_region_create_rectangle (&outer_rect);

inner_region = cairo_region_create_rectangle (&inner_rect);

gtk_widget_shape_combine_region (preview->preview_window, outer_region);

cairo_region_destroy (outer_region);

} else {

gdk_window_shape_combine_region (window, NULL, 0, 0);

}

#include <string.h>

#include <stdlib.h>

#include <cairo-xlib.h>

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

* GDK will no longer generate the core XEvents we process.

* So at least for now, enforce the previous behavior.

*/

gdk_disable_multidevice ();

if (!gtk_init_check (argc, argv))

{

{

GdkDisplay *gdisplay;

MetaUI *ui;

GdkDeviceManager *gmanager;

GdkDevice *gdevice;

GdkEvent *gevent;

GdkWindow *gdk_window;

Window window;

if (gdk_window == NULL)

return FALSE;

gmanager = gdk_display_get_device_manager (gdisplay);

gdevice = gdk_device_manager_get_client_pointer (gmanager);

/* If GDK already thinks it has a grab, we better let it see events; this

* is the menu-navigation case and events need to get sent to the appropriate

* (client-side) subwindow for individual menu items.

*/

if (gdk_display_device_is_grabbed (gdisplay, gdevice))

return FALSE;

switch (xevent->type)

{

case ButtonPress:

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

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

{

gevent = gdk_event_new (GDK_2BUTTON_PRESS);

ui->button_click_number = 0;

}

else

{

gevent = gdk_event_new (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 = gdk_event_new (GDK_BUTTON_RELEASE);

}

gevent->button.window = g_object_ref (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 = gdk_event_new (GDK_MOTION_NOTIFY);

gevent->motion.type = GDK_MOTION_NOTIFY;

gevent->motion.window = g_object_ref (gdk_window);

break;

case EnterNotify:

case LeaveNotify:

gevent = gdk_event_new (xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);

gevent->crossing.window = g_object_ref (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 */

gdk_event_set_device (gevent, gdevice);

gtk_main_do_event (gevent);

gdk_event_free (gevent);

return TRUE;

}

g_assert (xdisplay == GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));

ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));

/* This does not actually show any widget. MetaFrames has been hacked so

* that showing it doesn't actually do anything. But we need the flags

* set for GTK to deliver events properly. */

gtk_widget_show (GTK_WIDGET (ui->frames));

g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);

gint attributes_mask;

GdkWindow *window;

GdkVisual *visual;

/* Default depth/visual handles clients with weird visuals; they can

* always be children of the root depth/visual obviously, but

{

visual = gdk_x11_screen_lookup_visual (screen,

XVisualIDFromVisual (xvisual));

}

attrs.title = NULL;

attrs.y = y;

attrs.wclass = GDK_INPUT_OUTPUT;

attrs.visual = visual;

attrs.window_type = GDK_WINDOW_CHILD;

attrs.cursor = NULL;

attrs.wmclass_name = NULL;

attrs.width = width;

attrs.height = height;

attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;

window =

gdk_window_new (gdk_screen_get_root_window(screen),

meta_window_menu_free (menu);

}

GdkPixbuf*

meta_gdk_pixbuf_get_from_pixmap (GdkPixbuf *dest,

Pixmap xpixmap,

return retval;

}

void

meta_ui_push_delay_exposes (MetaUI *ui)

int *right_width)

{

int text_height;

GtkStyleContext *style = NULL;

PangoFontDescription *free_font_desc = NULL;

PangoContext *context;

const PangoFontDescription *font_desc;

if (!font_desc)

{

GdkDisplay *display = gdk_x11_lookup_xdisplay (ui->xdisplay);

GdkScreen *screen = gdk_display_get_screen (display, XScreenNumberOfScreen (ui->xscreen));

GtkWidgetPath *widget_path;

NULL);

gtk_style_context_restore (style);

font_desc = (const PangoFontDescription *) free_font_desc;

}

text_height = meta_pango_font_desc_get_text_height (font_desc, context);

top_height, bottom_height,

left_width, right_width);

if (free_font_desc)

pango_font_description_free (free_font_desc);

}

else

{

*top_height = *bottom_height = *left_width = *right_width = 0;

}

if (style != NULL)

g_object_unref (style);

}

void

return META_UI_DIRECTION_LTR;

}

GdkPixbuf *meta_ui_get_pixbuf_from_surface (cairo_surface_t *surface)

{

gint width;

return gdk_pixbuf_get_from_surface (surface, 0, 0, width, height);

}

GtkWidget *c;

GList *icons;

GdkPixbuf *pix;

int size = 0;

w = gtk_window_new (GTK_WINDOW_TOPLEVEL);

c = gtk_button_new_with_label ("Icon window");

icons = NULL;

gtk_icon_size_lookup (GTK_ICON_SIZE_LARGE_TOOLBAR, NULL, &size);

pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "gtk-save", size, 0, NULL);

icons = g_list_append (icons, pix);

if (i % 2)

{

gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, NULL, &size);

pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "gtk-save", size, 0, NULL);

icons = g_list_append (icons, pix);

}

if (i % 3)

{

gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, NULL, &size);

pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "gtk-save", size, 0, NULL);

icons = g_list_append (icons, pix);

}