static void
update_shape (GtkWidget* window,
gint radius,
gint shadow_size)
{
if (g_composited)
{
/* remove any current shape-mask */
gtk_widget_input_shape_combine_region (window, NULL);
return;
}
int width;
int height;
gtk_widget_get_size_request (window, &width, &height);
const cairo_rectangle_int_t rects[] = {{2, 0, width - 4, height},
{1, 1, width - 2, height - 2},
{0, 2, width, height - 4}};
cairo_region_t* region = NULL;
region = cairo_region_create_rectangles (rects, 3);
if (cairo_region_status (region) == CAIRO_STATUS_SUCCESS)
{
gtk_widget_shape_combine_region (window, NULL);
gtk_widget_shape_combine_region (window, region);
}
}
void
ekiga_ext_window_set_size (EkigaExtWindow *ew, int width, int height)
{
int pw, ph;
g_return_if_fail (width > 0 && height > 0);
gtk_widget_get_size_request (ew->priv->event_box, &pw, &ph);
/* No size requisition yet
* It's our first call so we silently set the new requisition and exit...
*/
if (pw == -1) {
gtk_widget_set_size_request (ew->priv->event_box, width, height);
return;
}
/* Do some kind of filtering here. We often get duplicate "size-changed" events...
* Note that we currently only bother about the width of the event_box.
*/
if (pw == width)
return;
gtk_widget_set_size_request (ew->priv->event_box, width, height);
gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (ew)), NULL, TRUE);
}
static gboolean _lib_filmstrip_size_handle_motion_notify_callback(GtkWidget *w, GdkEventButton *e,
gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *d = (dt_lib_filmstrip_t *)self->data;
if(d->size_handle_is_dragging)
{
gint x, y, sx, sy;
#if GTK_CHECK_VERSION(3, 20, 0)
gdk_window_get_device_position(e->window,
gdk_seat_get_pointer(gdk_display_get_default_seat(
gdk_window_get_display(gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&x, &y, 0);
#else
gdk_window_get_device_position(
gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui)),
gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(
gdk_window_get_display(gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&x, &y, NULL);
#endif
gtk_widget_get_size_request(d->filmstrip, &sx, &sy);
sy = CLAMP(d->size_handle_height + (d->size_handle_y - y), DT_PIXEL_APPLY_DPI(64),
DT_PIXEL_APPLY_DPI(400));
dt_conf_set_int("plugins/lighttable/filmstrip/height", sy);
gtk_widget_set_size_request(d->filmstrip, -1, sy);
return TRUE;
}
return FALSE;
}
/*
Note this method is not gtk_widget_size_request()
*/
static VALUE
rg_get_size_request(VALUE self)
{
gint width, height;
gtk_widget_get_size_request(_SELF(self), &width, &height);
return rb_ary_new3(2, INT2NUM(width), INT2NUM(height));
}
static void pizza_get_preferred_height(GtkWidget* widget, int* minimum, int* natural)
{
*minimum = 0;
gtk_widget_get_size_request(widget, NULL, natural);
if (*natural < 0)
*natural = 0;
}
// Calculate the zoom ratio required to fit the whole image on the screen.
float UI_calcZoomToFitScreen(GtkWindow* window, GtkWidget* drawingArea, uint32_t imageWidth, uint32_t imageHeight)
{
int windowWidth, windowHeight;
int drawingWidth, drawingHeight;
uint32_t screenWidth, screenHeight;
gtk_window_get_size(window, &windowWidth, &windowHeight);
gtk_widget_get_size_request(drawingArea, &drawingWidth, &drawingHeight);
UI_getPhysicalScreenSize(window, &screenWidth, &screenHeight);
// Take drawing area out of the equation, how much extra do we need for additional controls?
windowWidth -= drawingWidth;
windowHeight -= drawingHeight;
// Take borders and captions into consideration (GTK doesn't seem to support this so we'll have to guess)
windowWidth += 10;
windowHeight += 40;
// This is the true amount of screen real estate we can work with
screenWidth -= windowWidth;
screenHeight -= windowHeight;
// Calculate zoom ratio
if (imageWidth > screenWidth || imageHeight > screenHeight)
{
if ((int)(imageWidth - screenWidth) > (int)(imageHeight - screenHeight))
return (float)screenWidth / (float)imageWidth;
else
return (float)screenHeight / (float)imageHeight;
}
else
return 1;
}
gboolean
grow (GtkWidget* window)
{
gint width = 0;
gint height = 0;
if (!GTK_IS_WINDOW (window))
return TRUE;
gtk_widget_get_size_request (window, &width, &height);
if (g_step <= 2.0f)
{
g_step = 5.0f;
g_timeout_add (1000/40,
(GSourceFunc) shrink,
(gpointer) window);
return FALSE;
}
height += (gint) g_step;
g_step /= 1.125f;
gtk_widget_set_size_request (window, width, height);
gtk_widget_queue_draw (window);
return TRUE;
}
gboolean library_view_set_coverart(GtkImage* img, GdkEvent* evt, GObject* lview)
{
library_view_t* view = (library_view_t*) g_object_get_data(lview, "library_view_t");
GdkEventButton *button_evt = (GdkEventButton*) evt;
if (button_evt->button == RIGHT_BUTTON) {
GtkMenu* mnu = GTK_MENU(gtk_builder_get_object(view->builder, "mnu_coverart"));
gtk_menu_popup (mnu, NULL, NULL, NULL, NULL,
button_evt->button, button_evt->time);
return TRUE;
} else {
GtkImage* img = GTK_IMAGE(gtk_builder_get_object(view->builder, "img_art"));
gint w,h;
gtk_widget_get_size_request(GTK_WIDGET(img), &w, &h);
if (w == 200) {
gtk_widget_set_size_request(GTK_WIDGET(img), 100, 100);
view->img_w = 100;
view->img_h = 100;
view->track_index = -1;
} else {
gtk_widget_set_size_request(GTK_WIDGET(img), 200, 200);
view->img_w = 200;
view->img_h = 200;
view->track_index = -1;
}
el_config_set_int(btb_config(view->btb), "image_art.width", view->img_w);
el_config_set_int(btb_config(view->btb), "image_art.height", view->img_h);
return TRUE;
}
}
static gboolean _lib_filmstrip_size_handle_button_callback(GtkWidget *w, GdkEventButton *e, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *d = (dt_lib_filmstrip_t *)self->data;
if(e->button == 1)
{
if(e->type == GDK_BUTTON_PRESS)
{
/* store current mousepointer position */
#if GTK_CHECK_VERSION(3, 20, 0)
gdk_window_get_device_position(e->window,
gdk_seat_get_pointer(gdk_display_get_default_seat(gdk_window_get_display(
gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&d->size_handle_x, &d->size_handle_y, 0);
#else
gdk_window_get_device_position(
gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui)),
gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(
gdk_window_get_display(gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&d->size_handle_x, &d->size_handle_y, NULL);
#endif
gtk_widget_get_size_request(d->filmstrip, NULL, &d->size_handle_height);
d->size_handle_is_dragging = TRUE;
}
else if(e->type == GDK_BUTTON_RELEASE)
d->size_handle_is_dragging = FALSE;
}
return TRUE;
}
static void
gtk_color_swatch_measure (GtkCssGadget *gadget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline,
gpointer unused)
{
GtkWidget *widget;
GtkColorSwatch *swatch;
gint w, h, min;
widget = gtk_css_gadget_get_owner (gadget);
swatch = GTK_COLOR_SWATCH (widget);
gtk_css_gadget_get_preferred_size (swatch->priv->overlay_gadget,
orientation,
-1,
minimum, natural,
NULL, NULL);
gtk_widget_get_size_request (widget, &w, &h);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
min = w < 0 ? 48 : w;
else
min = h < 0 ? 32 : h;
*minimum = MAX (*minimum, min);
*natural = MAX (*natural, min);
}
static void
gimp_color_button_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpColorButton *button = GIMP_COLOR_BUTTON (object);
gint other;
switch (property_id)
{
case PROP_TITLE:
g_free (button->title);
button->title = g_value_dup_string (value);
break;
case PROP_COLOR:
g_object_set_property (G_OBJECT (button->color_area), "color", value);
break;
case PROP_TYPE:
g_object_set_property (G_OBJECT (button->color_area), "type", value);
break;
case PROP_UPDATE:
gimp_color_button_set_update (button, g_value_get_boolean (value));
break;
case PROP_AREA_WIDTH:
gtk_widget_get_size_request (button->color_area, NULL, &other);
gtk_widget_set_size_request (button->color_area,
g_value_get_int (value), other);
break;
case PROP_AREA_HEIGHT:
gtk_widget_get_size_request (button->color_area, &other, NULL);
gtk_widget_set_size_request (button->color_area,
other, g_value_get_int (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void ZJ_TabView_set_offset(TABVIEW* tabview,int offset1,int offset2)
{
int pageeventbox_w,pageeventbox_h;
gtk_widget_get_size_request(tabview->TabViewFixed,&pageeventbox_w,&pageeventbox_h);
tabview->offset1 = offset1;
tabview->offset2 = offset2;
gtk_widget_set_usize((GtkWidget *)(tabview->PageFixed),pageeventbox_w,pageeventbox_h-tabview->offset1-tabview->offset2);
}
static void* thread_queue_draw_framebuffer(GtkWidget *widget)
{
int width, height;
while (running) {
gtk_widget_get_size_request(widget, &width, &height);
gtk_widget_queue_draw_area(widget, 0, 0, width, height);
g_usleep(62500);
}
return NULL;
}
int af_window_get_height()
{
int width, height;
GtkWidget *window = global_get("window");
if (gtk_window_get_resizable(GTK_WINDOW(window))) {
gtk_window_get_size(GTK_WINDOW(window), &width, &height);
} else {
gtk_widget_get_size_request(window, &width, &height);
}
return height;
}
static void
swatch_get_preferred_height (GtkWidget *widget,
gint *min,
gint *nat)
{
gint w, h;
gtk_widget_get_size_request (widget, &w, &h);
if (h < 0)
h = 32;
*min = *nat = h;
}
static void
swatch_get_preferred_width (GtkWidget *widget,
gint *min,
gint *nat)
{
gint w, h;
gtk_widget_get_size_request (widget, &w, &h);
if (w < 0)
w = 48;
*min = *nat = w;
}
static void
gs_screenshot_image_set_error (GsScreenshotImage *ssimg, const gchar *message)
{
gint width, height;
gtk_stack_set_visible_child_name (GTK_STACK (ssimg->stack), "error");
gtk_label_set_label (GTK_LABEL (ssimg->label_error), message);
gtk_widget_get_size_request (ssimg->stack, &width, &height);
if (width < 200)
gtk_widget_hide (ssimg->label_error);
else
gtk_widget_show (ssimg->label_error);
ssimg->showing_image = FALSE;
}
// This is not the same as GetBestSize() because that size may have
// been recalculated and cached by us. We want GTK+ information.
wxSize wxControl::GTKGetPreferredSize(GtkWidget* widget) const
{
GtkRequisition req;
#ifdef __WXGTK3__
int w, h;
gtk_widget_get_size_request(widget, &w, &h);
gtk_widget_set_size_request(widget, -1, -1);
gtk_widget_get_preferred_size(widget, NULL, &req);
gtk_widget_set_size_request(widget, w, h);
#else
GTK_WIDGET_GET_CLASS(widget)->size_request(widget, &req);
#endif
return wxSize(req.width, req.height);
}
// Calculate the zoom ratio required to fit the whole image on the screen.
float UI_calcZoomToFitScreen(GtkWindow* window, GtkWidget* drawingArea, uint32_t imageWidth, uint32_t imageHeight)
{
int windowWidth, windowHeight;
int drawingWidth, drawingHeight;
int reqWidth, reqHeight;
uint32_t screenWidth, screenHeight;
gtk_window_get_size(window, &windowWidth, &windowHeight);
GtkRequisition size_req;
gtk_widget_size_request (drawingArea, &size_req);
drawingWidth = size_req.width;
drawingHeight = size_req.height;
gtk_widget_get_size_request(drawingArea, &reqWidth, &reqHeight);
// Take borders and captions into consideration (GTK doesn't seem to
// support this so we'll have to guess)
windowWidth += 10;
windowHeight += 10;
// Take drawing area out of the equation, how much extra do we need for additional controls?
// and then how much does that leave us for the image?
uint32_t availableWidth = maxWindowWidth - (windowWidth - drawingWidth);
uint32_t availableHeight = maxWindowHeight - (windowHeight - drawingHeight);
float ratio;
// Calculate zoom ratio
if (imageWidth > availableWidth || imageHeight > availableHeight)
{
float wratio = (imageWidth <= availableWidth) ? 1
: (float (availableWidth) / float (imageWidth));
float hratio = (imageHeight <= availableHeight) ? 1
: (float (availableHeight) / float (imageHeight));
if (wratio < hratio)
ratio = wratio;
else
ratio = hratio;
}
else
ratio = 1;
printf ("UI_calcZoomToFitScreen(): max %dx%d, win %dx%d, drawarea %dx%d (%dx%d), "
"available %dx%d, image %dx%d, scale %.6f\n",
maxWindowWidth, maxWindowHeight, windowWidth, windowHeight,
drawingWidth, drawingHeight, reqWidth, reqHeight,
availableWidth, availableHeight, imageWidth, imageHeight, ratio);
return ratio;
}
void
ghb_preview_init(signal_user_data_t *ud)
{
GtkWidget *widget;
ud->preview = g_malloc0(sizeof(preview_t));
ud->preview->pause = TRUE;
ud->preview->encode_frame = -1;
ud->preview->live_id = -1;
widget = GHB_WIDGET(ud->builder, "preview_button_image");
gtk_widget_get_size_request(widget, &ud->preview->button_width,
&ud->preview->button_height);
#if defined(_ENABLE_GST)
GstBus *bus;
ud->preview->play = gst_element_factory_make("playbin", "play");
ud->preview->vsink = gst_element_factory_make("gdkpixbufsink", "pixsink");
if (ud->preview->play == NULL || ud->preview->vsink == NULL)
{
g_message("Couldn't initialize gstreamer. Disabling live preview.");
GtkWidget *widget = GHB_WIDGET(ud->builder, "live_preview_box");
gtk_widget_hide (widget);
widget = GHB_WIDGET(ud->builder, "live_preview_duration_box");
gtk_widget_hide (widget);
return;
}
else
{
g_object_set(ud->preview->vsink, "qos", FALSE,
"max-lateness", (gint64) - 1, NULL);
g_object_set(ud->preview->play, "video-sink", ud->preview->vsink, NULL);
g_object_set(ud->preview->play, "subtitle-font-desc",
"sans bold 20", NULL);
bus = gst_pipeline_get_bus(GST_PIPELINE(ud->preview->play));
gst_bus_add_watch(bus, live_preview_cb, ud);
gst_object_unref(bus);
ud->preview->live_enabled = 1;
}
#else
widget = GHB_WIDGET(ud->builder, "live_preview_box");
gtk_widget_hide (widget);
widget = GHB_WIDGET(ud->builder, "live_preview_duration_box");
gtk_widget_hide (widget);
#endif
}
GtkWidget* get_child_at_pos(GtkWidget* container, gfloat x, gfloat y)
{
GList *children = gtk_container_get_children(GTK_CONTAINER(container));
int len = g_list_length(children);
int i;
for(i =0; i < len; i++)
{
gint px, py, width, height;
GdkWindow *w = gtk_widget_get_window(g_list_nth_data(children, i));
gdk_window_get_position(w, &px, &py);
gtk_widget_get_size_request(w, &width, &height);
if(x >= px && x <= px + width && y >= py && y <= py + height)
return w;
}
return NULL;
}
/**
* gs_screenshot_image_set_error:
**/
static void
gs_screenshot_image_set_error (GsScreenshotImage *ssimg, const gchar *message)
{
GsScreenshotImagePrivate *priv;
gint width, height;
priv = gs_screenshot_image_get_instance_private (ssimg);
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "error");
gtk_label_set_label (GTK_LABEL (priv->label_error), message);
gtk_widget_get_size_request (priv->stack, &width, &height);
if (width < 200)
gtk_widget_hide (priv->label_error);
else
gtk_widget_show (priv->label_error);
}
void about_widget_constructor(AboutWidget * about_widget, int preselected)
{
char * files[][2] = {
{"Manual", DOC_PATH "doc_manual.srt"},
{"About", DOC_PATH "doc_about.srt"},
{"License", DOC_PATH "doc_gpl.srt"}
};
char * default_texts[] = {
"The manual file could not be found",
"Vexterm. Copyright (C) 2010 Sebastian Kürten\n\n"
"(More information is not available since the about-file could not be found)",
"Vexterm is distributed under the terms of the GNU General Public License (GPL) in version 3"
" or (at your choise) any later version."
};
GtkNotebook * nb = GTK_NOTEBOOK(gtk_notebook_new());
int p;
for (p = 0; p < sizeof(files) / sizeof(char*) / 2; p++){
GtkWidget * view = about_widget_create_view_from_file(files[p][1], default_texts[p]);
GtkWidget * scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(view));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
GtkWidget * label = gtk_label_new(files[p][0]);
gtk_widget_show_all(scrolled);
gtk_notebook_append_page(nb, scrolled, label);
}
GtkWidget * logo = about_logo_new();
int logo_height;
gtk_widget_get_size_request(logo, NULL, &logo_height);
if (logo_height == 1){
gtk_widget_set_size_request(logo, -1, LOGO_HEIGHT_DEFAULT);
}
gtk_box_pack_start(GTK_BOX(about_widget), GTK_WIDGET(logo), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(about_widget), GTK_WIDGET(nb), TRUE, TRUE, 0);
gtk_notebook_set_current_page(nb, preselected);
}
static void
table_size_allocate_cb (GtkWidget *view,
GtkAllocation *allocation,
GtkWidget *box)
{
gint width, height;
gtk_widget_get_size_request (box, NULL, &height);
width = allocation->width;
width -= \
gtk_text_view_get_right_margin (GTK_TEXT_VIEW (view)) - \
gtk_text_view_get_left_margin (GTK_TEXT_VIEW (view));
width -= 2 * MARGIN;
width -= 2 * HEADER_PADDING;
gtk_widget_set_size_request (box, width, height);
}
static void
_set_apps_to_page (OlPlayerChooser *window,
guint index,
GList *app_list)
{
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
OlAppChooserWidget *chooser = _get_chooser (window, index);
ol_app_chooser_widget_set_app_list (chooser, app_list, DEFAULT_APP_COLUMNS);
GtkRequisition chooser_req;
gint box_height;
gtk_widget_size_request (GTK_WIDGET (chooser), &chooser_req);
gtk_widget_get_size_request (GTK_WIDGET (priv->chooser_panel), NULL, &box_height);
gint height = MIN (MAX_CHOOSER_HEIGHT,
MAX (chooser_req.height, box_height));
if (height != box_height)
gtk_widget_set_size_request (GTK_WIDGET (priv->chooser_panel),
-1,
height);
}
static gboolean _lib_filmstrip_size_handle_button_callback(GtkWidget *w, GdkEventButton *e, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *d = (dt_lib_filmstrip_t *)self->data;
if (e->button == 1)
{
if (e->type == GDK_BUTTON_PRESS)
{
/* store current mousepointer position */
gdk_window_get_pointer(gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui)), &d->size_handle_x, &d->size_handle_y, NULL);
gtk_widget_get_size_request(d->filmstrip, NULL, &d->size_handle_height);
d->size_handle_is_dragging = TRUE;
}
else if (e->type == GDK_BUTTON_RELEASE)
d->size_handle_is_dragging = FALSE;
}
return TRUE;
}
void on_edge1_menu_activate (const gchar *handler_name,
GObject *object,
const gchar *signal_name,
const gchar *signal_data,
GObject *connect_object,
gboolean after,
gpointer user_data)
{
GtkWidget *view;
GtkWidget *draw;
int i;
gint width;
gint height;
START;
i = 0;
if(!vue_is_displayed[0])
{
vue_is_displayed[0] = 1;
uv_gtk_env->quasar_proj[0] = set_quasar_proj(uv_gtk_env, uv_gtk_env->quasar_pos,0);
view = deglade("uv_view.glade", "uv_view");
draw = get_child(view, "uv_draw");
if (draw != NULL)
{
gtk_widget_show(draw);
gtk_widget_get_size_request(draw, &width, &height);
width = width/2;
height = height/2;
for(i = 0; i < uv_gtk_env->data_lenght; i++)
{
gdk_draw_point(draw->window,
draw->style->black_gc,
(int) (uv_gtk_env->quasar_proj[0][i].x*width+width),
(int) (height-uv_gtk_env->quasar_proj[0][i].y*height)
);
}
gtk_widget_show(view);
}
else
printf("GTK de merde !\n");
}
}
// GTK doesn't centre the window correctly. Use this function to centre windows with a canvas that is yet to resized.
void UI_centreCanvasWindow(GtkWindow *window, GtkWidget *canvas, int newCanvasWidth, int newCanvasHeight)
{
int winWidth, winHeight, widgetWidth, widgetHeight;
GdkScreen *screen = gdk_screen_get_default();
int monitorNo = gdk_screen_get_monitor_at_window(screen, GTK_WIDGET(window->transient_parent)->window);
GdkRectangle rect;
gdk_screen_get_monitor_geometry(screen, monitorNo, &rect);
gtk_widget_get_size_request((GtkWidget*)canvas, &widgetWidth, &widgetHeight);
gtk_window_get_size(window, &winWidth, &winHeight);
winWidth = newCanvasWidth;
winHeight = (winHeight - widgetHeight) + newCanvasHeight;
// Take borders and captions into consideration (GTK doesn't seem to support this so we'll have to guess)
winWidth += 10;
winHeight += 40;
gtk_window_move(window, rect.x + (rect.width - winWidth) / 2, rect.y + (rect.height - winHeight) / 2);
}
static gboolean _lib_filmstrip_size_handle_motion_notify_callback(GtkWidget *w, GdkEventButton *e, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *d = (dt_lib_filmstrip_t *)self->data;
if (d->size_handle_is_dragging)
{
gint x,y,sx,sy;
gdk_window_get_pointer (gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui)), &x, &y, NULL);
gtk_widget_get_size_request (d->filmstrip,&sx,&sy);
sy = CLAMP(d->size_handle_height+(d->size_handle_y - y), 64,400);
dt_conf_set_int("plugins/lighttable/filmstrip/height", sy);
gtk_widget_set_size_request(d->filmstrip,-1,sy);
return TRUE;
}
return FALSE;
}
static void
launcher_grid_toggle (GtkWidget *widget,
struct desktop *desktop)
{
if (desktop->grid_visible)
{
shell_helper_slide_surface_back (desktop->helper,
desktop->launcher_grid->surface);
}
else
{
int width;
gtk_widget_get_size_request (desktop->launcher_grid->window,
&width, NULL);
shell_helper_slide_surface (desktop->helper,
desktop->launcher_grid->surface,
width + MAYNARD_PANEL_WIDTH, 0);
}
desktop->grid_visible = !desktop->grid_visible;
}
