/* logo_add */
static int _logo_add(Logo * logo, GdkWindow * window)
{
LogoWindow * p;
#if GTK_CHECK_VERSION(3, 4, 0)
GdkRGBA color = { 0.0, 0.0, 0.0, 0.0 };
#else
GdkColor color = { 0x0, 0x0, 0x0, 0x0 };
#endif
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() window=%p\n", __func__, (void *)window);
#endif
if((p = realloc(logo->windows, sizeof(*p) * (logo->windows_cnt + 1)))
== NULL)
return -1;
logo->windows = p;
/* set the default color */
#if GTK_CHECK_VERSION(3, 4, 0)
gdk_window_set_background_rgba(window, &color);
#else
gdk_window_set_background(window, &color);
gdk_window_clear(window);
#endif
logo->windows[logo->windows_cnt].window = window;
logo->windows[logo->windows_cnt].frame = NULL;
#if GTK_CHECK_VERSION(3, 0, 0)
logo->windows[logo->windows_cnt++].cairo = gdk_cairo_create(window);
#else
logo->windows[logo->windows_cnt++].pixmap = NULL;
#endif
return 0;
}
void
meta_tile_preview_show (MetaTilePreview *preview,
MetaRectangle *tile_rect)
{
GdkWindow *window;
GdkRectangle old_rect;
if (gtk_widget_get_visible (preview->preview_window)
&& preview->tile_rect.x == tile_rect->x
&& preview->tile_rect.y == tile_rect->y
&& preview->tile_rect.width == tile_rect->width
&& preview->tile_rect.height == tile_rect->height)
return; /* nothing to do */
gtk_widget_show (preview->preview_window);
window = gtk_widget_get_window (preview->preview_window);
meta_core_lower_beneath_grab_window (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
GDK_WINDOW_XID (window),
gtk_get_current_event_time ());
old_rect.x = old_rect.y = 0;
old_rect.width = preview->tile_rect.width;
old_rect.height = preview->tile_rect.height;
gdk_window_invalidate_rect (window, &old_rect, FALSE);
preview->tile_rect = *tile_rect;
gdk_window_move_resize (window,
preview->tile_rect.x, preview->tile_rect.y,
preview->tile_rect.width, preview->tile_rect.height);
if (!preview->has_alpha)
{
cairo_region_t *outer_region, *inner_region;
GdkRectangle outer_rect, inner_rect;
GdkRGBA black = { 0.0, 0.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;
outer_rect.height = preview->tile_rect.height;
inner_rect.x = OUTLINE_WIDTH;
inner_rect.y = OUTLINE_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);
cairo_region_subtract (outer_region, inner_region);
cairo_region_destroy (inner_region);
gdk_window_shape_combine_region (window, outer_region, 0, 0);
cairo_region_destroy (outer_region);
}
}
static void
map (GtkWidget *widget)
{
/* Chain up to realize our children */
GTK_WIDGET_CLASS (nemo_blank_desktop_window_parent_class)->map (widget);
gdk_window_lower (gtk_widget_get_window (widget));
GdkWindow *window;
GdkRGBA transparent = { 0, 0, 0, 0 };
window = gtk_widget_get_window (widget);
gdk_window_set_background_rgba (window, &transparent);
}
void
set_desktop_background(GdkWindow *window)
{
Pixmap xpm = get_pixmap_prop(GDK_WINDOW_XWINDOW(window), "_XROOTPMAP_ID");
#ifdef HAVE_GTK3
if (xpm != None)
{
GdkScreen *screen = gdk_window_get_screen(window);
Window root_return;
int x, y;
unsigned int width, height, bw, depth_ret;
cairo_surface_t *surface = NULL;
gdk_error_trap_push();
if (XGetGeometry(GDK_SCREEN_XDISPLAY(screen),
xpm,
&root_return,
&x, &y, &width, &height, &bw, &depth_ret))
{
surface = cairo_xlib_surface_create(GDK_SCREEN_XDISPLAY (screen),
xpm,
GDK_VISUAL_XVISUAL(gdk_screen_get_system_visual(screen)),
width, height);
}
gdk_error_trap_pop_ignored ();
cairo_pattern_t *pattern = cairo_pattern_create_for_surface(surface);
gdk_window_set_background_pattern(window, pattern);
cairo_surface_destroy(surface);
// cairo_pattern_destroy ???
}
else
{
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gdk_window_set_background_rgba(window, &black);
}
#else
if (xpm != None)
{
GDKPIXMAP *gpm = gdk_pixmap_foreign_new(xpm);
gdk_window_set_back_pixmap (window, gpm, FALSE);
g_object_unref (gpm);
}
#endif
}
BackgroundInfo* create_background_info(GtkWidget* container, GtkWidget* child)
{
g_message("[%s]\n", __func__);
BackgroundInfo* info = g_new0(BackgroundInfo, 1);
g_mutex_init(&info->m);
info->alpha = 1;
info->container = container;
if (child != NULL) {
gtk_widget_realize (child);
gdk_window_set_composited(gtk_widget_get_window(child), TRUE);
}
g_signal_connect(container, "draw",
G_CALLBACK(background_info_draw_callback), info);
gtk_widget_realize (container);
GdkRGBA color = {0,0,0,0};
gdk_window_set_background_rgba(gtk_widget_get_window(container), &color);
return info;
}
static void
xmr_label_realize(GtkWidget *widget)
{
GtkAllocation allocation;
GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
gtk_widget_set_realized(widget, TRUE);
if (!gtk_widget_get_has_window(widget))
{
window = gtk_widget_get_parent_window(widget);
gtk_widget_set_window(widget, window);
g_object_ref(window);
}
else
{
GdkRGBA rgba = { 0 };
gtk_widget_get_allocation(widget, &allocation);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual(widget);
attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
window = gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributes_mask);
gtk_widget_set_window(widget, window);
gdk_window_set_user_data(window, widget);
gdk_window_set_background_rgba(window, &rgba);
}
}
/**
* Creates the windows and other objects required to do calibration
* under GTK. When the window is closed (timed out, calibration finished
* or user cancellation), callback will be called, where you should call
* calib_area_finish().
*/
CalibArea *
calib_area_new (GdkScreen *screen,
int monitor,
int device_id,
FinishCallback callback,
gpointer user_data,
XYinfo *old_axis,
int threshold_doubleclick,
int threshold_misclick)
{
CalibArea *calib_area;
GdkRectangle rect;
GdkWindow *window;
GdkRGBA black;
GdkCursor *cursor;
g_return_val_if_fail (old_axis, NULL);
g_return_val_if_fail (callback, NULL);
g_debug ("Current calibration: %d, %d, %d, %d\n",
old_axis->x_min,
old_axis->y_min,
old_axis->x_max,
old_axis->y_max);
calib_area = g_new0 (CalibArea, 1);
calib_area->callback = callback;
calib_area->user_data = user_data;
calib_area->device_id = device_id;
calib_area->calibrator.old_axis.x_min = old_axis->x_min;
calib_area->calibrator.old_axis.x_max = old_axis->x_max;
calib_area->calibrator.old_axis.y_min = old_axis->y_min;
calib_area->calibrator.old_axis.y_max = old_axis->y_max;
calib_area->calibrator.threshold_doubleclick = threshold_doubleclick;
calib_area->calibrator.threshold_misclick = threshold_misclick;
/* Set up the window */
calib_area->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable (GTK_WIDGET (calib_area->window), TRUE);
/* Black background */
gdk_rgba_parse (&black, "rgb(0,0,0)");
gtk_window_set_opacity (GTK_WINDOW (calib_area->window), WINDOW_OPACITY);
gtk_widget_realize (calib_area->window);
window = gtk_widget_get_window (calib_area->window);
gdk_window_set_background_rgba (window, &black);
/* No cursor */
cursor = gdk_cursor_new (GDK_BLANK_CURSOR);
gdk_window_set_cursor (window, cursor);
g_object_unref (cursor);
/* Listen for mouse events */
gtk_widget_add_events (calib_area->window, GDK_KEY_RELEASE_MASK | GDK_BUTTON_PRESS_MASK);
gtk_widget_set_can_focus (calib_area->window, TRUE);
gtk_window_fullscreen (GTK_WINDOW (calib_area->window));
gtk_window_set_keep_above (GTK_WINDOW (calib_area->window), TRUE);
/* Connect callbacks */
g_signal_connect (calib_area->window, "draw",
G_CALLBACK(draw), calib_area);
g_signal_connect (calib_area->window, "button-press-event",
G_CALLBACK(on_button_press_event), calib_area);
g_signal_connect (calib_area->window, "key-release-event",
G_CALLBACK(on_key_release_event), calib_area);
g_signal_connect (calib_area->window, "delete-event",
G_CALLBACK(on_delete_event), calib_area);
g_signal_connect (calib_area->window, "focus-out-event",
G_CALLBACK(on_focus_out_event), calib_area);
/* Setup timer for animation */
calib_area->anim_id = g_timeout_add(TIME_STEP, (GSourceFunc)on_timer_signal, calib_area);
/* Move to correct screen */
if (screen == NULL)
screen = gdk_screen_get_default ();
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
gtk_window_move (GTK_WINDOW (calib_area->window), rect.x, rect.y);
gtk_window_set_default_size (GTK_WINDOW (calib_area->window), rect.width, rect.height);
calib_area->calibrator.geometry.x = rect.x;
calib_area->calibrator.geometry.y = rect.y;
calib_area->calibrator.geometry.width = rect.width;
calib_area->calibrator.geometry.height = rect.height;
gtk_widget_show_all (calib_area->window);
return calib_area;
}
static void
display_entry (MetaTabPopup *popup,
TabEntry *te)
{
GdkRectangle rect;
GdkRegion *region;
GdkRegion *inner_region;
GdkWindow *window;
if (popup->current_selected_entry)
{
if (popup->outline)
unselect_image (popup->current_selected_entry->widget);
else
unselect_workspace (popup->current_selected_entry->widget);
}
gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
if (popup->outline)
select_image (te->widget);
else
select_workspace (te->widget);
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;
window = gtk_widget_get_window(GTK_WIDGET(popup->outline_window));
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);
#else
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
* with gdk functions.
*/
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_set_mapped (popup->outline_window, TRUE);
#else
GTK_WIDGET_SET_FLAGS (popup->outline_window, GTK_MAPPED);
#endif
gdk_window_show_unraised (window);
}
/* Must be before we handle an expose for the outline window */
popup->current_selected_entry = te;
}
int main (int argc, char **argv)
{
if (argc == 2 && 0 == g_strcmp0(argv[1], "-d"))
g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
if (is_application_running(SHUTDOWN_ID_NAME)) {
g_warning("another instance of application dosd is running...\n");
return 0;
}
singleton(SHUTDOWN_ID_NAME);
check_version();
init_i18n ();
gtk_init (&argc, &argv);
input_argv = argv;
gdk_window_set_cursor (gdk_get_default_root_window (), gdk_cursor_new (GDK_LEFT_PTR));
container = create_web_container (FALSE, TRUE);
gtk_window_set_decorated (GTK_WINDOW (container), FALSE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (container), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (container), TRUE);
gtk_window_set_keep_above (GTK_WINDOW (container), TRUE);
gtk_window_set_position (GTK_WINDOW (container), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_resize (GTK_WINDOW (container), width,height);
gtk_widget_set_events (GTK_WIDGET (container),
gtk_widget_get_events (GTK_WIDGET (container))
| GDK_POINTER_MOTION_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_KEY_PRESS_MASK
| GDK_KEY_RELEASE_MASK
| GDK_EXPOSURE_MASK
| GDK_VISIBILITY_NOTIFY_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
);
GtkWidget *webview = d_webview_new_with_uri (CHOICE_HTML_PATH);
gtk_container_add (GTK_CONTAINER(container), GTK_WIDGET (webview));
gtk_widget_realize (container);
gtk_widget_realize (webview);
/* style_context = gtk_widget_get_style_context(webview);*/
/*gtk_style_context_add_class(style_context,GTK_STYLE_CLASS_OSD);*/
/*gtk_style_context_add_class(style_context,GTK_STYLE_PROPERTY_BORDER_RADIUS);*/
/*cairo_t *cr;*/
/*cairo_surface_t *surface;*/
/*surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);*/
/*cr = cairo_create(surface);*/
/*[>cairo_set_source_rgba (cr, 1, 0, 0, 0.80);<]*/
/*[>cairo_fill (cr);<]*/
/*gtk_render_background(style_context,cr,radius,radius,width,height);*/
/*[>gtk_style_context_set_background(style_context,gdkwindow);<]*/
/*gtk_style_context_restore(style_context);*/
/*[>cairo_destory(cr);<]*/
/*[>cairo_surface_write_to_png(surface,"gtkbackground.png");<]*/
/*[>cairo_surface_destory(surface);<]*/
GdkWindow* gdkwindow = gtk_widget_get_window (container);
GdkRGBA rgba = { 0, 0, 0, 0.0 };
gdk_window_set_background_rgba (gdkwindow, &rgba);
gdk_window_set_opacity (gdkwindow, 0.7);
gdk_window_set_keep_above (gdkwindow, TRUE);
osd_set_focus(FALSE);
/*gdk_window_show(gdkwindow);*/
/*gtk_widget_show_all (container);*/
gtk_main ();
return 0;
}
int main (int argc, char **argv)
{
/* if (argc == 2 && 0 == g_strcmp0(argv[1], "-d")) */
g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
if (is_application_running(SHUTDOWN_ID_NAME)) {
g_warning("another instance of application shutdown is running...\n");
return 0;
}
singleton(SHUTDOWN_ID_NAME);
//remove option -f
parse_cmd_line (&argc, &argv);
check_version();
init_i18n ();
gtk_init (&argc, &argv);
gdk_window_set_cursor (gdk_get_default_root_window (), gdk_cursor_new (GDK_LEFT_PTR));
container = create_web_container (FALSE, TRUE);
ensure_fullscreen (container);
gtk_window_set_decorated (GTK_WINDOW (container), FALSE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (container), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (container), TRUE);
/*gtk_window_set_keep_above (GTK_WINDOW (container), TRUE);*/
gtk_window_fullscreen (GTK_WINDOW (container));
gtk_widget_set_events (GTK_WIDGET (container),
gtk_widget_get_events (GTK_WIDGET (container))
| GDK_POINTER_MOTION_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_KEY_PRESS_MASK
| GDK_KEY_RELEASE_MASK
| GDK_EXPOSURE_MASK
| GDK_VISIBILITY_NOTIFY_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK);
webview = d_webview_new_with_uri (SHUTDOWN_HTML_PATH);
gtk_container_add (GTK_CONTAINER(container), GTK_WIDGET (webview));
/*g_signal_connect (container, "show", G_CALLBACK (show_cb), NULL);*/
/*g_signal_connect (webview, "focus-out-event", G_CALLBACK( focus_out_cb), NULL);*/
gtk_widget_realize (container);
gtk_widget_realize (webview);
GdkWindow* gdkwindow = gtk_widget_get_window (container);
GdkRGBA rgba = { 0, 0, 0, 0.0 };
gdk_window_set_background_rgba (gdkwindow, &rgba);
gdk_window_set_skip_taskbar_hint (gdkwindow, TRUE);
gdk_window_set_cursor (gdkwindow, gdk_cursor_new(GDK_LEFT_PTR));
/*gdk_window_set_override_redirect (gdkwindow, TRUE);*/
/*select_popup_events ();*/
/*gdk_window_add_filter (NULL, (GdkFilterFunc)xevent_filter, gdkwindow);*/
dde_bg_g_settings = g_settings_new(SCHEMA_ID);
set_background(gtk_widget_get_window(webview), dde_bg_g_settings,
gdk_screen_width(), gdk_screen_height());
grab = gs_grab_new ();
gtk_widget_show_all (container);
gdk_window_focus (gtk_widget_get_window (container), 0);
gdk_window_stick (gdkwindow);
gtk_main ();
return 0;
}
static gboolean
panel_background_prepare (PanelBackground *background)
{
PanelBackgroundType effective_type;
GtkWidget *widget = NULL;
if (!background->transformed)
return FALSE;
effective_type = panel_background_effective_type (background);
switch (effective_type) {
case PANEL_BACK_NONE:
if (background->default_pattern) {
/* the theme background-image pattern must be scaled by
* the width & height of the panel so that when the
* backing region is cleared
* (gdk_window_clear_backing_region), the correctly
* scaled pattern is used */
cairo_matrix_t m;
cairo_surface_t *surface;
double width, height;
surface = NULL;
width = 1.0;
height = 1.0;
cairo_pattern_get_surface(background->default_pattern, &surface);
/* catch invalid images (e.g. -gtk-gradient) before scaling and rendering */
if (surface != NULL ){
cairo_surface_reference(surface);
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
cairo_matrix_init_translate (&m, 0, 0);
cairo_matrix_scale (&m,
width / background->region.width,
height / background->region.height);
cairo_pattern_set_matrix (background->default_pattern, &m);
gdk_window_set_background_pattern (background->window,
background->default_pattern);
}
else {
g_warning ("%s", "unsupported value of 'background-image' in GTK+ theme (such as '-gtk-gradient')");
/* use any background color that has been set if image is invalid */
gdk_window_set_background_rgba (
background->window, &background->default_color);
}
cairo_surface_destroy(surface);
} else
gdk_window_set_background_rgba (
background->window, &background->default_color);
break;
case PANEL_BACK_COLOR:
if (background->has_alpha &&
!gdk_window_check_composited_wm(background->window))
set_pixbuf_background (background);
else {
gdk_window_set_background_rgba (background->window,
&background->color);
}
break;
case PANEL_BACK_IMAGE:
set_pixbuf_background (background);
break;
default:
g_assert_not_reached ();
break;
}
/* Panel applets may use the panel's background pixmap to
* decide how to draw themselves. Therefore, we need to
* make sure that all drawing has been completed before
* the applet looks at the pixmap. */
gdk_display_sync (gdk_window_get_display (background->window));
gdk_window_get_user_data (GDK_WINDOW (background->window),
(gpointer) &widget);
if (GTK_IS_WIDGET (widget)) {
panel_background_apply_css (background, gtk_widget_get_toplevel(widget));
gtk_widget_set_app_paintable(widget,TRUE);
gtk_widget_queue_draw (widget);
}
background->notify_changed (background, background->user_data);
return TRUE;
}
int
main (int argc,
char** argv)
{
GtkWidget* window;
GdkRGBA transparent = {0.0, 0.0, 0.0, 0.0};
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (!window)
return 0;
gtk_window_set_type_hint (GTK_WINDOW (window),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_add_events (window,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
// hook up input/event handlers to window
g_signal_connect (G_OBJECT (window),
"screen-changed",
G_CALLBACK (screen_changed_handler),
NULL);
g_signal_connect (G_OBJECT (window),
"composited-changed",
G_CALLBACK (composited_changed_handler),
NULL);
gtk_window_move (GTK_WINDOW (window), POS_X, POS_Y);
// make sure the window opens with a RGBA-visual
screen_changed_handler (window, NULL, NULL);
gtk_widget_realize (window);
gdk_window_set_background_rgba (gtk_widget_get_window (window),
&transparent);
// hook up window-event handlers to window
g_signal_connect (G_OBJECT (window),
"draw",
G_CALLBACK (expose_handler),
NULL);
// FIXME: read out current mouse-pointer position every 1/25 second
g_timeout_add (1000/40,
(GSourceFunc) pointer_update,
(gpointer) window);
g_timeout_add (10000,
(GSourceFunc) quit,
NULL);
g_timeout_add (1000/40,
(GSourceFunc) grow,
(gpointer) window);
// "clear" input-mask, set title/icon/attributes
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);
gtk_window_set_opacity (GTK_WINDOW (window), 1.0f);
gtk_widget_set_size_request (window,
(gint) (BUBBLE_WIDTH + 2.0f *
BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f *
BUBBLE_SHADOW_SIZE));
gtk_widget_show (window);
g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window));
update_input_shape (window, 1, 1);
update_shape (window,
(gint) CORNER_RADIUS,
(gint) BUBBLE_SHADOW_SIZE);
set_bg_blur (window, TRUE);
setup_tile ((gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE));
g_print ("This test will run for 10 seconds and then quit.\n");
gtk_main ();
tile_destroy (g_tile);
return 0;
}
static void
hd_home_plugin_item_realize (GtkWidget *widget)
{
HDHomePluginItemPrivate *priv = HD_HOME_PLUGIN_ITEM (widget)->priv;
GdkDisplay *display;
Atom atom, wm_type;
gchar *applet_id;
GdkRGBA transparent = {0.0, 0.0, 0.0, 0.0};
GdkWindow *window;
GTK_WIDGET_CLASS (hd_home_plugin_item_parent_class)->realize (widget);
window = gtk_widget_get_window (widget);
/* No border as decoration */
gdk_window_set_decorations (window, 0);
/* Set the _NET_WM_WINDOW_TYPE property to _HILDON_WM_WINDOW_TYPE_HOME_APPLET */
display = gdk_window_get_display (window);
atom = gdk_x11_get_xatom_by_name_for_display (display,
"_NET_WM_WINDOW_TYPE");
wm_type = gdk_x11_get_xatom_by_name_for_display (display,
"_HILDON_WM_WINDOW_TYPE_HOME_APPLET");
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
atom, XA_ATOM, 32, PropModeReplace,
(unsigned char *)&wm_type, 1);
applet_id = hd_home_plugin_item_get_applet_id (HD_HOME_PLUGIN_ITEM (widget));
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
gdk_x11_get_xatom_by_name_for_display (display,
"_HILDON_APPLET_ID"),
gdk_x11_get_xatom_by_name_for_display (display,
"UTF8_STRING"),
8, PropModeReplace,
(guchar *) applet_id, strlen (applet_id));
g_free (applet_id);
/* Set or remove settings property */
if (priv->settings)
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
gdk_x11_get_xatom_by_name_for_display (display,
"_HILDON_APPLET_SETTINGS"),
XA_CARDINAL, 32, PropModeReplace,
(unsigned char *) &(priv->settings), 1);
else
XDeleteProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
gdk_x11_get_xatom_by_name_for_display (display,
"_HILDON_APPLET_SETTINGS"));
/* Set display on all views property */
if (priv->display_on_all_views)
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
gdk_x11_get_xatom_by_name_for_display (display,
"_HILDON_APPLET_DISPLAY_ON_ALL_VIEWS"),
XA_CARDINAL, 32, PropModeReplace,
(unsigned char *) &(priv->display_on_all_views), 1);
else
XDeleteProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
gdk_x11_get_xatom_by_name_for_display (display,
"_HILDON_APPLET_DISPLAY_ON_ALL_VIEWS"));
/* Install client message filter */
if (show_settings_atom == GDK_NONE)
show_settings_atom = gdk_atom_intern_static_string ("_HILDON_APPLET_SHOW_SETTINGS");
gdk_window_add_filter (window,
hd_home_plugin_item_event_filter, widget);
/* Set background to transparent */
gdk_window_set_background_rgba (window, &transparent);
}
MetaTabPopup*
meta_ui_tab_popup_new (const MetaTabEntry *entries,
int screen_number,
int entry_count,
int width,
gboolean outline)
{
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 */
AtkObject *obj;
GdkScreen *screen;
GdkVisual *visual;
int screen_width;
popup = g_new (MetaTabPopup, 1);
screen = gdk_display_get_screen (gdk_display_get_default (),
screen_number);
visual = gdk_screen_get_rgba_visual (screen);
if (outline)
{
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP);
if (visual)
gtk_widget_set_visual (popup->outline_window, visual);
gtk_window_set_screen (GTK_WINDOW (popup->outline_window),
screen);
gtk_widget_set_app_paintable (popup->outline_window, TRUE);
gtk_widget_realize (popup->outline_window);
gdk_window_set_background_rgba (gtk_widget_get_window (popup->outline_window),
&black);
g_signal_connect (G_OBJECT (popup->outline_window), "draw",
G_CALLBACK (outline_window_draw), popup);
gtk_widget_show (popup->outline_window);
}
else
popup->outline_window = NULL;
popup->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (popup->window),
screen);
gtk_window_set_position (GTK_WINDOW (popup->window),
GTK_WIN_POS_CENTER_ALWAYS);
/* enable resizing, to get never-shrink behavior */
gtk_window_set_resizable (GTK_WINDOW (popup->window),
TRUE);
popup->current = NULL;
popup->entries = NULL;
popup->current_selected_entry = NULL;
popup->outline = outline;
screen_width = gdk_screen_get_width (screen);
for (i = 0; i < entry_count; ++i)
{
TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline);
popup->entries = g_list_prepend (popup->entries, new_entry);
}
popup->entries = g_list_reverse (popup->entries);
g_assert (width > 0);
height = i / width;
if (i % width)
height += 1;
grid = gtk_grid_new ();
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
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 ("");
/* Set the accessible role of the label to a status bar so it
* will emit name changed events that can be used by screen
* readers.
*/
obj = gtk_widget_get_accessible (popup->label);
atk_object_set_role (obj, ATK_ROLE_STATUSBAR);
gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 3);
max_label_width = 0;
top = 0;
bottom = 1;
tmp = popup->entries;
while (tmp && top < height)
{
left = 0;
right = 1;
while (tmp && left < width)
{
GtkWidget *image;
GtkRequisition req;
TabEntry *te;
te = tmp->data;
if (te->blank)
{
/* just stick a widget here to avoid special cases */
image = gtk_label_new ("");
}
else if (outline)
{
if (te->dimmed_icon)
{
image = meta_select_image_new (te->dimmed_icon);
}
else
{
image = meta_select_image_new (te->icon);
}
gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (image, GTK_ALIGN_CENTER);
}
else
{
image = meta_select_workspace_new ((MetaWorkspace *) te->key);
}
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;
++left;
++right;
}
++top;
++bottom;
}
/* remove all the temporary text */
gtk_label_set_text (GTK_LABEL (popup->label), "");
/* Make it so that we ellipsize if the text is too long */
gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END);
/* Limit the window size to no bigger than screen_width/4 */
if (max_label_width>(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;
}
