* libwnck or marco, since it's used in both of them

*/

* Copyright (C) 2002 Red Hat Inc.

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

{

double width_ratio, height_ratio;

int x, y, width, height;

width_ratio = (double) workspace_rect->width / (double) screen_width;

height_ratio = (double) workspace_rect->height / (double) screen_height;

x = win->x;

y = win->y;

width = win->width;

height = win->height;

x *= width_ratio;

y *= height_ratio;

width *= width_ratio;

height *= height_ratio;

x += workspace_rect->x;

y += workspace_rect->y;

if (width < 3)

width = 3;

if (height < 3)

#if GTK_CHECK_VERSION(3, 0, 0)

cairo_save(cr);

cr = gdk_cairo_create (drawable);

#endif

icon = win->icon;

icon_w = icon_h = 0;

if (icon)

icon_w = gdk_pixbuf_get_width (icon);

icon_h = gdk_pixbuf_get_height (icon);

{

icon_w = gdk_pixbuf_get_width (icon);

icon_h = gdk_pixbuf_get_height (icon);

/* Give up. */

if (icon_w > (winrect->width - 2) ||

icon_h > (winrect->height - 2))

{

icon_x = winrect->x + (winrect->width - icon_w) / 2;

icon_y = winrect->y + (winrect->height - icon_h) / 2;

cairo_save (cr);

gdk_cairo_set_source_pixbuf (cr, icon, icon_x, icon_y);

cairo_rectangle (cr, icon_x, icon_y, icon_w, icon_h);

cairo_paint (cr);

cairo_restore (cr);

}

if (is_active)

color = &style->fg[state];

else

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

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

cairo_stroke (cr);

#if GTK_CHECK_VERSION(3, 0, 0)

cairo_restore(cr);

#else

if (is_active)

state = GTK_STATE_SELECTED;

state = GTK_STATE_PRELIGHT;

else

state = GTK_STATE_NORMAL;

#else

cr = gdk_cairo_create (drawable);

#endif

if (workspace_background)

{

gdk_cairo_set_source_pixbuf (cr, workspace_background, x, y);

#if !GTK_CHECK_VERSION(3, 0, 0)

cairo_destroy (cr);

#endif

i = 0;

while (i < n_windows)

{

const WnckWindowDisplayInfo *win = &windows[i];

GdkRectangle winrect;

get_window_rect (win, screen_width,

screen_height, &workspace_rect, &winrect);

draw_window (widget,

#if GTK_CHECK_VERSION(3, 0, 0)

cr,

win,

&winrect,

state);

++i;

}

* libwnck or marco, since it's used in both of them

*/

* Copyright (C) 2002 Red Hat Inc.

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

int height;

guint is_active : 1;

} WnckWindowDisplayInfo;

void wnck_draw_workspace (GtkWidget *widget,

/* Marco fixed tooltip routine */

* Copyright (C) 2001 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

expose_handler (GtkTooltips *tooltips)

{

gtk_paint_flat_box (gtk_widget_get_style (tip), gtk_widget_get_window (tip),

NULL, tip, "tooltip",

0, 0, -1, -1);

const char *markup_text)

{

int w, h;

if (tip == NULL)

tip = gtk_window_new (GTK_WINDOW_POPUP);

gtk_window_set_type_hint (GTK_WINDOW(tip), GDK_WINDOW_TYPE_HINT_TOOLTIP);

screen_right_edge = monitor.x + monitor.width;

screen_bottom_edge = monitor.y + monitor.height;

}

gtk_widget_set_app_paintable (tip, TRUE);

gtk_window_set_resizable (GTK_WINDOW (tip), FALSE);

gtk_widget_set_name (tip, "gtk-tooltips");

#if GTK_CHECK_VERSION(3, 0, 0)

g_signal_connect (tip, "draw",

#else

g_signal_connect_swapped (tip, "expose_event",

G_CALLBACK (expose_handler), NULL);

gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);

gtk_widget_show (label);

gtk_container_add (GTK_CONTAINER (tip), label);

g_signal_connect (tip, "destroy",

}

gtk_label_set_markup (GTK_LABEL (label), markup_text);

gtk_window_get_size (GTK_WINDOW (tip), &w, &h);

if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)

if ((root_x + w) > screen_right_edge)

root_x -= (root_x + w) - screen_right_edge;

gtk_window_move (GTK_WINDOW (tip), root_x, root_y);

gtk_widget_show (tip);

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

* Copyright (C) 2001 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

/**

* \file fixedtip.h Marco fixed tooltip routine

* Sometimes we want to display a small floating rectangle with helpful

* text near the pointer. For example, if the user holds the mouse over

* the maximise button, we can display a tooltip saying "Maximize".

result = gdk_window_create_similar_surface (frame->window,

CAIRO_CONTENT_COLOR,

rect->width, rect->height);

cr = cairo_create (result);

cairo_translate (cr, -rect->x, -rect->y);

{

CachedFramePiece *piece;

piece = &pixels->piece[i];

if (piece->pixmap)

{

cairo_set_source_surface (cr, piece->pixmap,

piece->rect.x, piece->rect.y);

cairo_paint (cr);

region_piece = cairo_region_create_rectangle (&piece->rect);

cairo_region_subtract (region, region_piece);

cairo_region_destroy (region_piece);

MetaFrameType type;

cairo_region_t *tmp_region;

Display *display;

display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());

meta_core_get (display, frame->xwindow,

META_CORE_GET_CLIENT_HEIGHT, &area.height,

META_CORE_GET_END);

meta_theme_get_frame_borders (meta_theme_get_current (),

&area.x, NULL, &area.y, NULL);

tmp_region = cairo_region_create_rectangle (&area);

populate_cache (frames, frame);

region = cairo_region_create_rectangle (&clip);

pixels = get_cache (frames, frame);

cached_pixels_draw (pixels, cr, region);

clip_to_screen (region, frame);

subtract_client_area (region, frame);

}

cairo_region_destroy (region);

return TRUE;

}

/* Marco window frame manager widget */

* Copyright (C) 2001 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

char *title; /* NULL once we have a layout */

guint expose_delayed : 1;

guint shape_applied : 1;

/* FIXME get rid of this, it can just be in the MetaFrames struct */

MetaFrameControl prelit_control;

};

#else

GtkWindow parent_instance;

#endif

GHashTable *text_heights;

GHashTable *frames;

/* Marco gradient rendering */

* Copyright (C) 2001 Havoc Pennington, 99% copied from wrlib in

* WindowMaker, Copyright (C) 1997-2000 Dan Pascu and Alfredo Kojima

* Copyright (C) 2005 Elijah Newren

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

if (no_padding)

rowstride = width * 3;

else

rowstride = 4 * ((3 * width + 3) / 4);

buf = g_try_malloc (height * rowstride);

const GdkColor colors2[2],

int thickness2)

{

int i, j, k, l, ll;

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

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

unsigned char *ptr;

unsigned char *pixels;

int rowstride;

pixbuf = blank_pixbuf (width, height, FALSE);

if (pixbuf == NULL)

return NULL;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

r1 = colors1[0].red<<8;

g1 = colors1[0].green<<8;

b1 = colors1[0].blue<<8;

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

{

ptr = pixels + i * rowstride;

if (k == 0)

{

ptr[0] = (unsigned char) (r1>>16);

r1+=dr1;

g1+=dg1;

b1+=db1;

r2+=dr2;

g2+=dg2;

b2+=db2;

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

* meta_gradient_create_horizontal--

* Renders a horizontal linear gradient of the specified size in the

* Returns:

* A 24bit GdkPixbuf with the gradient (no alpha channel).

* Side effects:

* None

*/

static GdkPixbuf*

meta_gradient_create_horizontal (int width, int height,

const GdkColor *from,

const GdkColor *to)

int i;

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

GdkPixbuf *pixbuf;

pixbuf = blank_pixbuf (width, height, FALSE);

if (pixbuf == NULL)

return NULL;

pixels = gdk_pixbuf_get_pixels (pixbuf);

ptr = pixels;

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

r0 = (guchar) (from->red / 256.0);

g0 = (guchar) (from->green / 256.0);

b0 = (guchar) (from->blue / 256.0);

rf = (guchar) (to->red / 256.0);

gf = (guchar) (to->green / 256.0);

r = r0 << 16;

g = g0 << 16;

b = b0 << 16;

dr = ((rf-r0)<<16)/(int)width;

dg = ((gf-g0)<<16)/(int)width;

db = ((bf-b0)<<16)/(int)width;

int rf, gf, bf;

int rowstride;

unsigned char *pixels;

pixbuf = blank_pixbuf (width, height, FALSE);

if (pixbuf == NULL)

return NULL;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

r0 = (guchar) (from->red / 256.0);

g0 = (guchar) (from->green / 256.0);

b0 = (guchar) (from->blue / 256.0);

rf = (guchar) (to->red / 256.0);

gf = (guchar) (to->green / 256.0);

bf = (guchar) (to->blue / 256.0);

r = r0<<16;

g = g0<<16;

b = b0<<16;

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

{

ptr = pixels + i * rowstride;

ptr[0] = (unsigned char)(r>>16);

ptr[1] = (unsigned char)(g>>16);

ptr[2] = (unsigned char)(b>>16);

unsigned char *ptr;

unsigned char *pixels;

int rowstride;

if (width == 1)

return meta_gradient_create_vertical (width, height, from, to);

else if (height == 1)

pixbuf = blank_pixbuf (width, height, FALSE);

if (pixbuf == NULL)

return NULL;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

GdkPixbuf *pixbuf;

unsigned char *ptr;

unsigned char *pixels;

int rowstride;

g_return_val_if_fail (count > 2, NULL);

pixbuf = blank_pixbuf (width, height, FALSE);

if (pixbuf == NULL)

return NULL;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

ptr = pixels;

if (count > width)

count = width;

if (count > 1)

width2 = width/(count-1);

else

width2 = width;

k = 0;

r = colors[0].red << 8;

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

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

}

/* copy the first line to the other lines */

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

{

int height2;

int x;

int rowstride;

g_return_val_if_fail (count > 2, NULL);

pixbuf = blank_pixbuf (width, height, FALSE);

if (pixbuf == NULL)

return NULL;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

ptr = pixels;

if (count > height)

count = height;

if (count > 1)

height2 = height/(count-1);

else

height2 = height;

k = 0;

r = colors[0].red << 8;

memcpy (&(ptr[x*3]), ptr, (width - x)*3);

ptr += rowstride;

r += dr;

g += dg;

b += db;

memcpy (&(ptr[x*3]), ptr, (width - x)*3);

ptr += rowstride;

for (j=k+1; j<height; j++)

{

memcpy (ptr, tmp, rowstride);

ptr += rowstride;

}

}

return pixbuf;

}

unsigned char *ptr;

unsigned char *pixels;

int rowstride;

g_return_val_if_fail (count > 2, NULL);

if (width == 1)

width, height);

if (pixbuf == NULL)

return NULL;

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

if (count > width)

count = width;

if (count > height)

int row;

g_return_if_fail (GDK_IS_PIXBUF (pixbuf));

if (alpha == 255)

return;

g_assert (gdk_pixbuf_get_has_alpha (pixbuf));

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

height = gdk_pixbuf_get_height (pixbuf);

*/

/* ((*p / 255.0) * (alpha / 255.0)) * 255; */

*p = (guchar) (((int) *p * (int) alpha) / (int) 255);

++p; /* skip A */

}

long a, da;

unsigned char *p;

unsigned char *pixels;

int rowstride;

int width, height;

unsigned char *gradient;

unsigned char *gradient_p;

unsigned char *gradient_end;

g_return_if_fail (n_alphas > 0);

if (n_alphas == 1)

simple_multiply_alpha (pixbuf, alphas[0]);

return;

}

width = gdk_pixbuf_get_width (pixbuf);

height = gdk_pixbuf_get_height (pixbuf);

gradient = g_new (unsigned char, width);

gradient_end = gradient + width;

if (n_alphas > width)

n_alphas = width;

if (n_alphas > 1)

width2 = width / (n_alphas - 1);

else

width2 = width;

a = alphas[0] << 8;

gradient_p = gradient;

/* render the gradient into an array */

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

{

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

{

*gradient_p++ = (a >> 8);

a += da;

}

{

*gradient_p++ = a >> 8;

}

/* Now for each line of the pixbuf, fill in with the gradient */

pixels = gdk_pixbuf_get_pixels (pixbuf);

rowstride = gdk_pixbuf_get_rowstride (pixbuf);

p = pixels;

i = 0;

while (i < height)

p = row_end;

++i;

}

g_free (gradient);

}

g_return_if_fail (GDK_IS_PIXBUF (pixbuf));

g_return_if_fail (gdk_pixbuf_get_has_alpha (pixbuf));

g_return_if_fail (n_alphas > 0);

switch (type)

{

case META_GRADIENT_HORIZONTAL:

meta_gradient_add_alpha_horizontal (pixbuf, alphas, n_alphas);

break;

case META_GRADIENT_VERTICAL:

g_printerr ("marco: vertical alpha channel gradient not implemented yet\n");

break;

case META_GRADIENT_DIAGONAL:

g_printerr ("marco: diagonal alpha channel gradient not implemented yet\n");

break;

case META_GRADIENT_LAST:

g_assert_not_reached ();

break;

/* Marco gradient rendering */

* Copyright (C) 2001 Havoc Pennington, 99% copied from wrlib in

* WindowMaker, Copyright (C) 1997-2000 Dan Pascu and Alfredo Kojima

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

cairo_translate (cr, ac_width, 0);

if (gtk_label_get_ellipsize (label))

pango_layout_set_width (label_layout,

- ac_width * PANGO_SCALE);

allocation.width -= ac_width;

gtk_widget_set_allocation (widget, &allocation);

if (GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw)

gtk_widget_set_allocation (widget, &allocation);

if (gtk_label_get_ellipsize (label))

pango_layout_set_width (label_layout,

+ ac_width * PANGO_SCALE);

cairo_restore (cr);

if (GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw)

GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw (widget, cr);

}

return FALSE;

}

/* Marco theme preview widget */

* Copyright (C) 2002 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

meta_preview_init (MetaPreview *preview)

{

int i;

gtk_widget_set_has_window (GTK_WIDGET (preview), FALSE);

i = 0;

preview->button_layout.right_buttons[i] = META_BUTTON_FUNCTION_LAST;

++i;

}

preview->button_layout.left_buttons[0] = META_BUTTON_FUNCTION_MENU;

preview->button_layout.right_buttons[0] = META_BUTTON_FUNCTION_MINIMIZE;

preview->button_layout.right_buttons[1] = META_BUTTON_FUNCTION_MAXIMIZE;

preview->button_layout.right_buttons[2] = META_BUTTON_FUNCTION_CLOSE;

preview->type = META_FRAME_TYPE_NORMAL;

preview->flags =

META_FRAME_ALLOWS_DELETE |

META_FRAME_HAS_FOCUS |

META_FRAME_ALLOWS_SHADE |

META_FRAME_ALLOWS_MOVE;

preview->left_width = -1;

preview->right_width = -1;

preview->top_height = -1;

meta_preview_new (void)

{

MetaPreview *preview;

#if GTK_CHECK_VERSION(3, 0, 0)

preview = g_object_new (META_TYPE_PREVIEW, NULL);

#else

preview = gtk_type_new (META_TYPE_PREVIEW);

#endif

return GTK_WIDGET (preview);

}

g_free (preview->title);

preview->title = NULL;

G_OBJECT_CLASS (parent_class)->finalize (object);

}

GtkWidget *widget;

widget = GTK_WIDGET (preview);

if (preview->layout == NULL)

{

PangoFontDescription *font_desc;

PangoAttrList *attrs;

PangoAttribute *attr;

scale = meta_theme_get_title_scale (preview->theme,

preview->type,

preview->flags);

else

scale = 1.0;

preview->layout = gtk_widget_create_pango_layout (widget,

preview->title);

font_desc = meta_gtk_widget_get_font_desc (widget, scale, NULL);

preview->text_height =

meta_pango_font_desc_get_text_height (font_desc,

gtk_widget_get_pango_context (widget));

attrs = pango_attr_list_new ();

attr = pango_attr_size_new (pango_font_description_get_size (font_desc));

attr->start_index = 0;

attr->end_index = G_MAXINT;

pango_attr_list_insert (attrs, attr);

pango_layout_set_attributes (preview->layout, attrs);

pango_font_description_free (font_desc);

}

META_BUTTON_STATE_NORMAL,

META_BUTTON_STATE_NORMAL

};

g_return_val_if_fail (META_IS_PREVIEW (widget), FALSE);

preview = META_PREVIEW (widget);

cairo_save (cr);

border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

gtk_widget_get_allocation (widget, &allocation);

client_width = allocation.width - preview->left_width - preview->right_width - border_width * 2;

client_height = allocation.height - preview->top_height - preview->bottom_height - border_width * 2;

if (client_width < 0)

client_width = 1;

if (client_height < 0)

if (preview->theme)

{

border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

META_BUTTON_STATE_NORMAL,

META_BUTTON_STATE_NORMAL

};

g_return_val_if_fail (META_IS_PREVIEW (widget), FALSE);

g_return_val_if_fail (event != NULL, FALSE);

ensure_info (preview);

border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

gtk_widget_get_allocation (widget, &allocation);

client_width = allocation.width - preview->left_width - preview->right_width - border_width * 2;

client_height = allocation.height - preview->top_height - preview->bottom_height - border_width * 2;

if (client_width < 0)

client_width = 1;

if (client_height < 0)

if (preview->theme)

{

border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

meta_theme_draw_frame (preview->theme,

widget,

gtk_widget_get_window (widget),

req->width = preview->left_width + preview->right_width;

req->height = preview->top_height + preview->bottom_height;

child = gtk_bin_get_child (GTK_BIN (preview));

if (child &&

gtk_widget_get_visible (child))

GtkAllocation child_allocation;

#endif

GtkWidget *child;

preview = META_PREVIEW (widget);

ensure_info (preview);

#if GTK_CHECK_VERSION(3, 0, 0)

gtk_widget_set_allocation (widget, allocation);

#else

#endif

border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

child = gtk_bin_get_child (GTK_BIN (widget));

if (child &&

gtk_widget_get_visible (child))

gtk_widget_get_allocation (widget, &widget_allocation);

child_allocation.x = widget_allocation.x + border_width + preview->left_width;

child_allocation.y = widget_allocation.y + border_width + preview->top_height;

child_allocation.width = MAX (1, widget_allocation.width - border_width * 2 - preview->left_width - preview->right_width);

child_allocation.height = MAX (1, widget_allocation.height - border_width * 2 - preview->top_height - preview->bottom_height);

#else

child_allocation.x = allocation->x + border_width + preview->left_width;

child_allocation.y = allocation->y + border_width + preview->top_height;

child_allocation.width = MAX (1, allocation->width - border_width * 2 - preview->left_width - preview->right_width);

child_allocation.height = MAX (1, allocation->height - border_width * 2 - preview->top_height - preview->bottom_height);

#endif

g_return_if_fail (META_IS_PREVIEW (preview));

preview->theme = theme;

clear_cache (preview);

gtk_widget_queue_resize (GTK_WIDGET (preview));

g_free (preview->title);

preview->title = g_strdup (title);

clear_cache (preview);

gtk_widget_queue_resize (GTK_WIDGET (preview));

const MetaButtonLayout *button_layout)

{

g_return_if_fail (META_IS_PREVIEW (preview));

gtk_widget_queue_draw (GTK_WIDGET (preview));

}

g_assert (default_icon);

}

return default_icon;

}

g_assert (default_icon);

}

return default_icon;

}

/* Marco theme preview widget */

* Copyright (C) 2002 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

MetaTheme *theme;

char *title;

MetaFrameType type;

PangoLayout *layout;

int text_height;

/* Marco resizing-terminal-window feedback */

* Copyright (C) 2001 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

GtkWidget *size_window;

GtkWidget *size_label;

Display *display;

int vertical_size;

int horizontal_size;

gboolean showing;

MetaRectangle rect;

};

popup->display = display;

popup->screen_number = screen_number;

return popup;

}

meta_ui_resize_popup_free (MetaResizePopup *popup)

{

g_return_if_fail (popup != NULL);

if (popup->size_window)

gtk_widget_destroy (popup->size_window);

g_free (popup);

}

ensure_size_window (MetaResizePopup *popup)

{

GtkWidget *frame;

if (popup->size_window)

return;

popup->size_window = gtk_window_new (GTK_WINDOW_POPUP);

gtk_window_set_screen (GTK_WINDOW (popup->size_window),

gdk_display_get_screen (gdk_x11_lookup_xdisplay (popup->display),

popup->screen_number));

/* never shrink the size window */

gtk_window_set_resizable (GTK_WINDOW (popup->size_window),

TRUE);

frame = gtk_frame_new (NULL);

gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);

char *str;

int x, y;

int width, height;

g_return_if_fail (popup->size_window != NULL);

/* Translators: This represents the size of a window. The first number is

* the width of the window and the second is the height.

*/

x = popup->rect.x + (popup->rect.width - width) / 2;

y = popup->rect.y + (popup->rect.height - height) / 2;

if (GTK_WIDGET_REALIZED (popup->size_window))

{

/* using move_resize to avoid jumpiness */

{

if (popup->size_window)

gtk_widget_show (popup->size_window);

if (popup->size_window && GTK_WIDGET_REALIZED (popup->size_window))

#if GTK_CHECK_VERSION(3, 0, 0)

gdk_window_raise (gtk_widget_get_window(GTK_WIDGET(popup->size_window)));

{

gboolean need_update_size;

int display_w, display_h;

g_return_if_fail (popup != NULL);

need_update_size = FALSE;

display_w = rect.width - base_width;

if (width_inc > 0)

display_w /= width_inc;

display_w != popup->horizontal_size ||

display_h != popup->vertical_size)

need_update_size = TRUE;

popup->rect = rect;

popup->vertical_size = display_h;

popup->horizontal_size = display_w;

if (need_update_size)

{

ensure_size_window (popup);

update_size_window (popup);

}

sync_showing (popup);

}

gboolean showing)

{

g_return_if_fail (popup != NULL);

if (showing == popup->showing)

return;

ensure_size_window (popup);

update_size_window (popup);

}

sync_showing (popup);

}

/* Marco popup window thing showing windows you can tab to */

* Copyright (C) 2001 Havoc Pennington

* Copyright (C) 2002 Red Hat, Inc.

* Copyright (C) 2005 Elijah Newren

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

gpointer data)

{

MetaTabPopup *popup;

GtkStyle *style;

GdkWindow *window;

cairo_t *cr;

popup = data;

if (!popup->outline || popup->current_selected_entry == NULL)

window = gtk_widget_get_window (widget);

style = gtk_widget_get_style (widget);

cr = gdk_cairo_create (window);

cairo_set_line_width (cr, 1.0);

gdk_cairo_set_source_color (cr, &style->white);

}

w = gdk_pixbuf_get_width (dimmed_pixbuf);

pixel_stride = 4;

for (y = 0; y < h; y++)

{

{

pixels += pixel_stride;

row += row_stride;

}

return dimmed_pixbuf;

}

gint screen_width,

gboolean outline)

{

TabEntry *te;

te = g_new (TabEntry, 1);

te->key = entry->key;

te->title = NULL;

g_free (str);

str = tmp;

* copy it back into the original buffer.

*/

tmp = g_strdup_printf ("<b>%s</b>", str);

if (entry->hidden)

te->dimmed_icon = dimm_icon (entry->icon);

}

if (outline)

{

te->rect.x = entry->rect.x;

AtkObject *obj;

GdkScreen *screen;

int screen_width;

popup = g_new (MetaTabPopup, 1);

popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP);

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

G_CALLBACK (outline_window_expose), popup);

popup->window = gtk_window_new (GTK_WINDOW_POPUP);

gtk_window_set_screen (GTK_WINDOW (popup->window),

}

popup->entries = g_list_reverse (popup->entries);

g_assert (width > 0);

height = i / width;

if (i % width)

table = gtk_table_new (height, width, FALSE);

vbox = gtk_vbox_new (FALSE, 0);

frame = gtk_frame_new (NULL);

gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);

gtk_container_set_border_width (GTK_CONTAINER (table), 1);

tmp = popup->entries;

while (tmp && top < height)

left = 0;

right = 1;

{

image = selectable_image_new (te->dimmed_icon);

}

{

image = selectable_image_new (te->icon);

}

INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1,

INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1);

gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);

else

{

image = selectable_workspace_new ((MetaWorkspace *) te->key);

te->title);

gtk_widget_size_request (popup->label, &req);

max_label_width = MAX (max_label_width, req.width);

tmp = tmp->next;

++left;

++right;

}

++top;

++bottom;

}

gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END);

/* Limit the window size to no bigger than screen_width/4 */

{

max_label_width = screen_width/4;

}

max_label_width += 20; /* add random padding */

gtk_window_set_default_size (GTK_WINDOW (popup->window),

max_label_width,

-1);

return popup;

}

TabEntry *te;

te = data;

g_free (te->title);

if (te->icon)

g_object_unref (G_OBJECT (te->icon));

meta_ui_tab_popup_free (MetaTabPopup *popup)

{

meta_verbose ("Destroying tab popup window\n");

gtk_widget_destroy (popup->outline_window);

gtk_widget_destroy (popup->window);

g_list_foreach (popup->entries, free_tab_entry, NULL);

g_list_free (popup->entries);

g_free (popup);

}

GdkRegion *inner_region;

GdkWindow *window;

if (popup->current_selected_entry)

{

if (popup->outline)

else

unselect_workspace (popup->current_selected_entry->widget);

}

gtk_label_set_markup (GTK_LABEL (popup->label), te->title);

if (popup->outline)

/* Do stuff behind gtk's back */

gdk_window_hide (gtk_widget_get_window(popup->outline_window));

meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));

rect = te->rect;

rect.x = 0;

rect.y = 0;

gdk_window_move_resize (window,

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

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

#if GTK_CHECK_VERSION(3, 0, 0)

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

gdk_window_set_background_rgba (window, &black);

gdk_window_set_background (window,

&popup->outline_window->style->black);

#endif

region = gdk_region_rectangle (&rect);

inner_region = gdk_region_rectangle (&te->inner_rect);

gdk_region_subtract (region, inner_region);

gdk_region_destroy (inner_region);

gdk_window_shape_combine_region (window,

region,

0, 0);

gdk_region_destroy (region);

/* 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,

* we manually set the window as mapped and then manually map it

if (popup->current == NULL)

popup->current = popup->entries;

if (popup->current != NULL)

{

TabEntry *te;

if (popup->current == NULL)

popup->current = g_list_last (popup->entries);

if (popup->current != NULL)

{

TabEntry *te;

/* Note, "key" may not be in the list of entries; other code assumes

* it's OK to pass in a key that isn't.

*/

tmp = popup->entries;

while (tmp != NULL)

{

if (te->key == key)

{

popup->current = tmp;

display_entry (popup, te);

return;

}

tmp = tmp->next;

}

}

GtkWidget *w;

w = g_object_new (meta_select_image_get_type (), NULL);

return w;

}

meta_select_image_class_init (MetaSelectImageClass *klass)

{

GtkWidgetClass *widget_class;

parent_class = g_type_class_peek (gtk_image_get_type ());

widget_class = GTK_WIDGET_CLASS (klass);

#if GTK_CHECK_VERSION(3, 0, 0)

widget_class->draw = meta_select_image_draw;

widget_class->expose_event = meta_select_image_expose_event;

#endif

}

gtk_widget_get_requisition (widget, &requisition);

gtk_misc_get_alignment (misc, &xalign, &yalign);

gtk_misc_get_padding (misc, &xpad, &ypad);

x = (allocation.width - (requisition.width - xpad * 2)) * xalign + 0.5;

y = (allocation.height - (requisition.height - ypad * 2)) * yalign + 0.5;

x -= INSIDE_SELECT_RECT + 1;

w = requisition.width - OUTSIDE_SELECT_RECT * 2 - 1;

h = requisition.height - OUTSIDE_SELECT_RECT * 2 - 1;

gtk_widget_get_allocation(widget, &allocation);

misc = GTK_MISC (widget);

x = (allocation.x * (1.0 - misc->xalign) +

(allocation.x + allocation.width

- (widget->requisition.width - misc->xpad * 2)) *

misc->yalign) + 0.5;

x -= INSIDE_SELECT_RECT + 1;

w = widget->requisition.width - OUTSIDE_SELECT_RECT * 2 - 1;

h = widget->requisition.height - OUTSIDE_SELECT_RECT * 2 - 1;

cairo_fill (cr);

#endif

gtk_paint_focus (widget->style, widget->window,

&event->area, widget, "meta-tab-image",

x, y, w, h);

{

GtkWidget *widget;

double screen_aspect;

widget = g_object_new (meta_select_workspace_get_type (), NULL);

screen_aspect = (double) workspace->screen->rect.height /

(double) workspace->screen->rect.width;

gtk_widget_set_size_request (widget,

MINI_WORKSPACE_WIDTH + SELECT_OUTLINE_WIDTH * 2,

MINI_WORKSPACE_WIDTH * screen_aspect + SELECT_OUTLINE_WIDTH * 2);

(GInstanceInitFunc) NULL,

};

0);

}

meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass)

{

GtkWidgetClass *widget_class;

widget_class = GTK_WIDGET_CLASS (klass);

#if GTK_CHECK_VERSION(3, 0, 0)

widget_class->draw = meta_select_workspace_draw;

#else

WnckWindowDisplayInfo wnck_window;

wnck_window.icon = window->icon;

wnck_window.mini_icon = window->mini_icon;

wnck_window.is_active = FALSE;

if (window == window->display->expected_focus_window)

wnck_window.is_active = TRUE;

GList *tmp, *list;

workspace = META_SELECT_WORKSPACE (widget)->workspace;

list = meta_stack_list_windows (workspace->screen->stack, workspace);

n_windows = g_list_length (list);

windows = g_new (WnckWindowDisplayInfo, n_windows);

ignoreable_sticky = window->on_all_workspaces &&

workspace != workspace->screen->active_workspace;

!meta_window_showing_on_its_workspace (window) ||

window->unmaps_pending ||

ignoreable_sticky)

n_windows);

g_free (windows);

if (META_SELECT_WORKSPACE (widget)->selected)

{

GtkStyleContext *context;

int i, n_windows;

GList *tmp, *list;

GtkAllocation allocation;

gtk_widget_get_allocation(widget, &allocation);

workspace = META_SELECT_WORKSPACE (widget)->workspace;

list = meta_stack_list_windows (workspace->screen->stack, workspace);

n_windows = g_list_length (list);

windows = g_new (WnckWindowDisplayInfo, n_windows);

ignoreable_sticky = window->on_all_workspaces &&

workspace != workspace->screen->active_workspace;

!meta_window_showing_on_its_workspace (window) ||

window->unmaps_pending ||

ignoreable_sticky)

n_windows);

g_free (windows);

if (META_SELECT_WORKSPACE (widget)->selected)

{

style = gtk_widget_get_style (widget);

/* Marco gradient test program */

* Copyright (C) 2002 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

#if !GTK_CHECK_VERSION (3, 0, 0)

cairo_t *cr;

#endif

#define CHECK_SIZE 10

color1.red = 30000;

color1.green = 30000;

color1.blue = 30000;

{

GdkPixbuf *pixbuf;

GdkColor from, to;

gdk_color_parse ("blue", &from);

gdk_color_parse ("green", &to);

if (with_alpha)

{

const unsigned char alphas[] = { 0xff, 0xaa, 0x2f, 0x0, 0xcc, 0xff, 0xff };

if (!gdk_pixbuf_get_has_alpha (pixbuf))

{

GdkPixbuf *new_pixbuf;

new_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);

g_object_unref (G_OBJECT (pixbuf));

pixbuf = new_pixbuf;

}

meta_gradient_add_alpha (pixbuf,

alphas, G_N_ELEMENTS (alphas),

META_GRADIENT_HORIZONTAL);

draw_checkerboard (drawable, width, height);

#endif

}

gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);

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

cairo_fill (cr);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_window_set_title (GTK_WINDOW (window), title);

drawing_area = gtk_drawing_area_new ();

gtk_widget_set_size_request (drawing_area, 1, 1);

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

g_signal_connect (G_OBJECT (drawing_area),

#if GTK_CHECK_VERSION (3, 0, 0)

"draw",

gtk_container_add (GTK_CONTAINER (window), drawing_area);

gtk_widget_show_all (window);

return window;

}

window = create_gradient_window ("Simple vertical",

render_vertical_func);

window = create_gradient_window ("Simple horizontal",

render_horizontal_func);

window = create_gradient_window ("Multi vertical",

render_vertical_multi_func);

window = create_gradient_window ("Multi horizontal",

render_horizontal_multi_func);

/* Marco theme parsing */

* Copyright (C) 2001 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

GtkWidget *contents;

GtkWidget *sw;

GtkItemFactory *item_factory;

table = gtk_table_new (1, 4, FALSE);

/* Create the menubar

*/

item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", NULL);

gtk_item_factory_set_translate_func(item_factory,

handlebox = gtk_handle_box_new ();

gtk_container_add (GTK_CONTAINER (handlebox), toolbar);

gtk_table_attach (GTK_TABLE (table),

handlebox,

/* X direction */ /* Y direction */

gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),

GTK_SHADOW_IN);

gtk_table_attach (GTK_TABLE (table),

sw,

/* X direction */ /* Y direction */

0, 1, 2, 3,

GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,

0, 0);

contents = gtk_text_view_new ();

gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),

PANGO_WRAP_WORD);

gtk_container_add (GTK_CONTAINER (sw),

contents);

GtkWidget *label;

GtkWidget *image;

GtkWidget *button;

vbox = gtk_vbox_new (FALSE, 0);

action_area = gtk_hbutton_box_new ();

gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area),

button = gtk_button_new_from_stock (GTK_STOCK_OK);

gtk_box_pack_end (GTK_BOX (action_area),

button,

FALSE, TRUE, 0);

gtk_box_pack_end (GTK_BOX (vbox), action_area,

FALSE, TRUE, 0);

image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO,

GTK_ICON_SIZE_DIALOG);

gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);

gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

gtk_label_set_selectable (GTK_LABEL (label), TRUE);

hbox = gtk_hbox_new (FALSE, 6);

gtk_box_pack_start (GTK_BOX (hbox), image,

char *str;

str = g_strdup_printf ("_%c", (char) ('A' + 4*i + j));

button = gtk_button_new_with_mnemonic (str);

g_free (str);

gtk_table_attach (GTK_TABLE (table),

button,

/* X direction */ /* Y direction */

}

gtk_widget_show_all (table);

return table;

}

menu_contents (void)

{

GtkWidget *vbox;

int i;

GtkWidget *frame;

gtk_misc_set_alignment (GTK_MISC (mi), 0.0, 0.5);

g_free (str);

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

++i;

}

gtk_container_add (GTK_CONTAINER (frame), vbox);

gtk_widget_show_all (frame);

return frame;

}

color.green = 0;

color.blue = 40000;

gtk_widget_modify_bg (event_box, GTK_STATE_NORMAL, &color);

vbox = gtk_vbox_new (FALSE, 0);

gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);

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

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

w = gtk_button_new_with_label (_("Bar"));

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

gtk_container_add (GTK_CONTAINER (event_box), vbox);

gtk_widget_show_all (event_box);

return event_box;

}

case META_FRAME_TYPE_BORDER:

*title = _("Border");

return border_only_contents ();

case META_FRAME_TYPE_LAST:

g_assert_not_reached ();

break;

META_FRAME_HAS_FOCUS |

META_FRAME_ALLOWS_SHADE |

META_FRAME_ALLOWS_MOVE;

switch (type)

{

case META_FRAME_TYPE_NORMAL:

case META_FRAME_TYPE_BORDER:

break;

case META_FRAME_TYPE_LAST:

g_assert_not_reached ();

break;

return flags;

}

eventbox = gtk_event_box_new ();

gtk_container_add (GTK_CONTAINER (eventbox), box);

gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox);

desktop_color.red = 0x5144;

GtkWidget *preview;

PangoFontDescription *font_desc;

double scale;

eventbox2 = gtk_event_box_new ();

preview = meta_preview_new ();

gtk_container_add (GTK_CONTAINER (eventbox2), preview);

meta_preview_set_frame_type (META_PREVIEW (preview), i);

meta_preview_set_frame_flags (META_PREVIEW (preview),

get_window_flags (i));

meta_preview_set_theme (META_PREVIEW (preview), global_theme);

contents = get_window_contents (i, &title);

meta_preview_set_title (META_PREVIEW (preview), title);

gtk_container_add (GTK_CONTAINER (preview), contents);

if (i == META_FRAME_TYPE_MENU)

xalign = 0.5;

yalign = 0.5;

}

align = gtk_alignment_new (0.0, 0.0, xalign, yalign);

gtk_container_add (GTK_CONTAINER (align), eventbox2);

gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0);

switch (font_size)

if (scale != 1.0)

{

font_desc = pango_font_description_new ();

pango_font_description_set_size (font_desc,

MAX (pango_font_description_get_size (base_desc) * scale, 1));

gtk_widget_modify_font (preview, font_desc);

pango_font_description_free (font_desc);

}

previews[font_size*META_FRAME_TYPE_LAST + i] = preview;

++i;

}

}

++i;

}

#ifndef ALLOW_DUPLICATE_BUTTONS

i = 0;

while (i <= MAX_BUTTONS_PER_CORNER)

{

int j;

j = 0;

while (j < i)

{

different_layouts[i].left_buttons[j-i] = (MetaButtonFunction) j;

++j;

}

++i;

}

/* Special extra case for no buttons on either side */

different_layouts[i].left_buttons[0] = META_BUTTON_FUNCTION_LAST;

different_layouts[i].right_buttons[0] = META_BUTTON_FUNCTION_LAST;

#else

/* FIXME this code is if we allow duplicate buttons,

* which we currently do not

*/

int left;

int i;

left = 0;

i = 0;

while (left < MAX_BUTTONS_PER_CORNER)

{

int right;

right = 0;

while (right < MAX_BUTTONS_PER_CORNER)

{

int j;

static MetaButtonFunction left_functions[MAX_BUTTONS_PER_CORNER] = {

META_BUTTON_FUNCTION_MENU,

META_BUTTON_FUNCTION_MINIMIZE,

};

g_assert (i < BUTTON_LAYOUT_COMBINATIONS);

j = 0;

while (j <= left)

{

different_layouts[i].right_buttons[j] = right_functions[j];

++j;

}

++i;

++right;

}

++left;

}

#endif

GdkColor desktop_color;

int i;

GtkWidget *eventbox;

if (!initted)

{

init_layouts ();

initted = TRUE;

}

sw = gtk_scrolled_window_new (NULL, NULL);

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),

GTK_POLICY_AUTOMATIC,

eventbox = gtk_event_box_new ();

gtk_container_add (GTK_CONTAINER (eventbox), box);

gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox);

desktop_color.red = 0x5144;

char *title;

eventbox2 = gtk_event_box_new ();

preview = meta_preview_new ();

meta_preview_set_theme (META_PREVIEW (preview), global_theme);

title = g_strdup_printf (_("Button layout test %d"), i+1);

meta_preview_set_button_layout (META_PREVIEW (preview),

&different_layouts[i]);

xalign = 0.5;

yalign = 0.5;

align = gtk_alignment_new (0.0, 0.0, xalign, yalign);

gtk_container_add (GTK_CONTAINER (align), eventbox2);

gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0);

previews[META_FRAME_TYPE_LAST*FONT_SIZE_LAST + i] = preview;

++i;

}

return sw;

}

{

char *msg;

GtkWidget *label;

msg = g_strdup_printf (_("%g milliseconds to draw one window frame"),

milliseconds_to_draw_frame);

label = gtk_label_new (msg);

clock_t start, end;

GtkWidget *notebook;

int i;

bindtextdomain (GETTEXT_PACKAGE, MARCO_LOCALEDIR);

textdomain(GETTEXT_PACKAGE);

bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");

meta_set_debugging (TRUE);

meta_set_verbose (TRUE);

}

start = clock ();

err = NULL;

if (argc == 1)

(end - start) / (double) CLOCKS_PER_SEC);

run_theme_benchmark ();

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_window_set_default_size (GTK_WINDOW (window), 350, 350);

title);

g_free (title);

g_signal_connect (G_OBJECT (window), "destroy",

G_CALLBACK (gtk_main_quit), NULL);

gtk_widget_realize (window);

g_assert (window->style);

g_assert (window->style->font_desc);

notebook = gtk_notebook_new ();

gtk_container_add (GTK_CONTAINER (window), notebook);

gtk_notebook_append_page (GTK_NOTEBOOK (notebook),

collection,

gtk_label_new (_("Normal Title Font")));

collection = preview_collection (FONT_SIZE_SMALL,

window->style->font_desc);

gtk_notebook_append_page (GTK_NOTEBOOK (notebook),

collection,

gtk_label_new (_("Small Title Font")));

collection = preview_collection (FONT_SIZE_LARGE,

window->style->font_desc);

gtk_notebook_append_page (GTK_NOTEBOOK (notebook),

gtk_notebook_append_page (GTK_NOTEBOOK (notebook),

collection,

gtk_label_new (_("Benchmark")));

i = 0;

while (i < (int) G_N_ELEMENTS (previews))

{

++i;

}

gtk_widget_show_all (window);

gtk_main ();

int client_width;

int client_height;

int inc;

widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_widget_realize (widget);

meta_theme_get_frame_borders (global_theme,

META_FRAME_TYPE_NORMAL,

get_text_height (widget),

&bottom_height,

&left_width,

&right_width);

layout = create_title_layout (widget);

i = 0;

while (i < MAX_BUTTONS_PER_CORNER)

{

button_layout.right_buttons[i] = META_BUTTON_FUNCTION_LAST;

++i;

}

button_layout.left_buttons[0] = META_BUTTON_FUNCTION_MENU;

button_layout.right_buttons[0] = META_BUTTON_FUNCTION_MINIMIZE;

inc = 1000 / ITERATIONS; /* Increment to grow width/height,

* eliminates caching effects.

*/

i = 0;

while (i < ITERATIONS)

{

meta_preview_get_icon ());

g_object_unref (G_OBJECT (pixmap));

++i;

client_width += inc;

client_height += inc;

g_timer_stop (timer);

milliseconds_to_draw_frame = (g_timer_elapsed (timer, NULL) / (double) ITERATIONS) * 1000;

g_print (_("Drew %d frames in %g client-side seconds (%g milliseconds per frame) and %g seconds wall clock time including X server resources (%g milliseconds per frame)\n"),

ITERATIONS,

((double)end - (double)start) / CLOCKS_PER_SEC,

test->expr, test->expected_x, test->expected_y);

err = NULL;

env.rect = meta_rect (test->rect.x, test->rect.y,

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

env.object_width = -1;

cairo_clip (cr);

}

#endif

switch (op->type)

{

case META_DRAW_LINE:

/* tile offset should not include x/y */

tile_xoffset -= rect.x;

tile_yoffset -= rect.y;

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

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

tile.x = rx - tile_xoffset;

while (tile.x < (rx + rwidth))

{

tile.y = ry - tile_yoffset;

* evaluated), we make an array of those, and then fold

* adjacent items when possible.

*/

#if GTK_CHECK_VERSION(3, 0, 0)

cairo_save(cr);

#else

{

cairo_restore (cr);

parse_x_position_unchecked (op->data.clip.x, &env),

parse_y_position_unchecked (op->data.clip.y, &env),

parse_size_unchecked (op->data.clip.width, &env),

parse_size_unchecked (op->data.clip.height, &env));

cairo_clip (cr);

cairo_save (cr);

}

else if (gdk_cairo_get_clip_rectangle (cr, NULL))

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

op_list = get_button (style, j, button_states[j]);

if (op_list)

{

cairo_save (cr);

/* Marco Theme Rendering */

* Copyright (C) 2001 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

typedef struct _MetaDrawOp MetaDrawOp;

typedef struct _MetaDrawOpList MetaDrawOpList;

typedef struct _MetaGradientSpec MetaGradientSpec;

typedef struct _MetaColorSpec MetaColorSpec;

typedef struct _MetaFrameLayout MetaFrameLayout;

typedef struct _MetaButtonSpace MetaButtonSpace;

{

/** Reference count. */

int refcount;

/** Size of left side */

int left_width;

/** Size of right side */

int right_width;

/** Size of bottom side */

int bottom_height;

/** Border of blue title region

* \bug (blue?!)

**/

/** Extra height for inside of title region, above the font height */

int title_vertical_pad;

/** Right indent of buttons from edges of frame */

int right_titlebar_edge;

/** Left indent of buttons from edges of frame */

int left_titlebar_edge;

/**

* Sizing rule of buttons, either META_BUTTON_SIZING_ASPECT

* (in which case button_aspect will be honoured, and

* Otherwise we figure out the height from the button_border.

*/

double button_aspect;

/** Width of a button; set even when we are using aspect sizing */

int button_width;

/** scale factor for title text */

double title_scale;

/** Whether title text will be displayed */

guint has_title : 1;

int bottom_height;

int width;

GdkRectangle title_rect;

/* used for a memset hack */

#define ADDRESS_OF_BUTTON_RECTS(fgeom) (((char*)(fgeom)) + G_STRUCT_OFFSET (MetaFrameGeometry, close_rect))

#define LENGTH_OF_BUTTON_RECTS (G_STRUCT_OFFSET (MetaFrameGeometry, right_right_background) + sizeof (GdkRectangle) - G_STRUCT_OFFSET (MetaFrameGeometry, close_rect))

/* The button rects (if changed adjust memset hack) */

MetaButtonSpace close_rect;

MetaButtonSpace max_rect;

GdkRectangle right_middle_backgrounds[MAX_MIDDLE_BACKGROUNDS];

GdkRectangle right_right_background;

/* End of button rects (if changed adjust memset hack) */

/* Round corners */

guint top_left_corner_rounded_radius;

guint top_right_corner_rounded_radius;

/** Clip to a rectangle */

META_DRAW_CLIP,

/* Texture thingies */

/** Just a filled rectangle with alpha */

META_DRAW_TINT,

META_DRAW_GRADIENT,

META_DRAW_IMAGE,

/** GTK theme engine stuff */

META_DRAW_GTK_ARROW,

META_DRAW_GTK_BOX,

* otherwise it is zero.

*/

int value;

/** A list of tokens in the expression. */

PosToken *tokens;

MetaDrawSpec *width;

MetaDrawSpec *height;

} clip;

struct {

MetaColorSpec *color_spec;

MetaAlphaGradientSpec *alpha_spec;

unsigned int vertical_stripes : 1;

unsigned int horizontal_stripes : 1;

} image;

struct {

GtkStateType state;

GtkShadowType shadow;

GtkStateType state;

MetaDrawSpec *x;

MetaDrawSpec *y1;

} gtk_vline;

struct {

MetaDrawSpec *tile_width;

MetaDrawSpec *tile_height;

} tile;

} data;

};

* | rather than |

*

*/

/* entire frame */

META_FRAME_PIECE_ENTIRE_BACKGROUND,

/* entire titlebar background */

};

/* Kinds of frame...

* normal -> noresize / vert only / horz only / both

* focused / unfocused

* max -> focused / unfocused

*

* 14 window states times 7 or 8 window types. Except some

* window types never get a frame so that narrows it down a bit.

*/

typedef enum

{

int client_height,

const MetaButtonLayout *button_layout,

MetaFrameGeometry *fgeom);

MetaFrameLayout* meta_theme_lookup_layout (MetaTheme *theme,

const char *name);

void meta_theme_insert_layout (MetaTheme *theme,

/* Marco theme widget (displays themed draw operations) */

* Copyright (C) 2002 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

#if GTK_CHECK_VERSION(3, 0, 0)

area = g_object_new (META_TYPE_AREA, NULL);

area = gtk_type_new (META_TYPE_AREA);

#endif

return GTK_WIDGET (area);

}

MetaArea *area;

area = META_AREA (object);

if (area->dnotify)

(* area->dnotify) (area->user_data);

G_OBJECT_CLASS (parent_class)->finalize (object);

}

gtk_misc_get_padding(misc, &xpad, &ypad);

x = floor (allocation.x + xpad

+ ((allocation.width - req.width) * xalign)

+ 0.5);

+ ((allocation.height - req.height) * yalign)

+ 0.5);

if (area->draw_func)

{

(* area->draw_func) (area, cr,

area->user_data);

}

}

return FALSE;

}

xalign = misc->xalign;

else

xalign = 1.0 - misc->xalign;

x = floor (widget->allocation.x + misc->xpad

+ ((widget->allocation.width - widget->requisition.width) * xalign)

+ 0.5);

+ ((widget->allocation.height - widget->requisition.height) * misc->yalign)

+ 0.5);

if (area->expose_func)

{

(* area->expose_func) (area, event, x, y,

area->user_data);

}

}

return FALSE;

}

MetaArea *area;

area = META_AREA (widget);

req->width = 0;

req->height = 0;

if (area->size_func)

{

(* area->size_func) (area, &req->width, &req->height,

#if GTK_CHECK_VERSION(3, 0, 0)

meta_area_get_preferred_width (GtkWidget *widget,

gint *minimal,

gint *natural)

*minimal = *natural = requisition.width;

}

meta_area_get_preferred_height (GtkWidget *widget,

gint *minimal,

gint *natural)

{

if (area->dnotify)

(* area->dnotify) (area->user_data);

area->size_func = size_func;

#if GTK_CHECK_VERSION(3, 0, 0)

area->draw_func = draw_func;

/* Marco theme widget (displays themed draw operations) */

* Copyright (C) 2002 Havoc Pennington

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

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

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

* WITHOUT ANY WARRANTY; without even the implied warranty of

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

* General Public License for more details.

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

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

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA