void
cb_widget_screen_changed(GtkWidget* widget, GdkScreen* previous_screen, gpointer data)
{
girara_debug("called");
zathura_t* zathura = data;
if (widget == NULL || zathura == NULL) {
return;
}
/* disconnect previous screen handler if present */
if (previous_screen != NULL && zathura->signals.monitors_changed_handler > 0) {
g_signal_handler_disconnect(previous_screen, zathura->signals.monitors_changed_handler);
zathura->signals.monitors_changed_handler = 0;
}
if (gtk_widget_has_screen(widget)) {
GdkScreen* screen = gtk_widget_get_screen(widget);
/* connect to new screen */
zathura->signals.monitors_changed_handler = g_signal_connect(G_OBJECT(screen),
"monitors-changed", G_CALLBACK(cb_monitors_changed), zathura);
}
zathura_update_view_ppi(zathura);
}
static void
gtk_scale_button_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen)
{
GtkScaleButton *button = (GtkScaleButton *) widget;
GtkScaleButtonPrivate *priv;
GdkScreen *screen;
GValue value = { 0, };
if (gtk_widget_has_screen (widget) == FALSE)
return;
priv = button->priv;
screen = gtk_widget_get_screen (widget);
g_value_init (&value, G_TYPE_INT);
if (gdk_screen_get_setting (screen,
"gtk-double-click-time",
&value) == FALSE)
{
priv->click_timeout = CLICK_TIMEOUT;
return;
}
priv->click_timeout = g_value_get_int (&value);
}
static GdkPixbuf *
load_pixbuf (GsdMediaKeysWindow *window,
const char *name,
int icon_size)
{
GtkIconTheme *theme;
GdkPixbuf *pixbuf;
if (window != NULL && gtk_widget_has_screen (GTK_WIDGET (window))) {
theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
} else {
theme = gtk_icon_theme_get_default ();
}
pixbuf = gtk_icon_theme_load_icon (theme,
name,
icon_size,
GTK_ICON_LOOKUP_FORCE_SVG,
NULL);
/* make sure the pixbuf is close to the requested size
* this is necessary because GTK_ICON_LOOKUP_FORCE_SVG
* seems to be broken */
if (pixbuf != NULL) {
int width;
width = gdk_pixbuf_get_width (pixbuf);
if (width < (float)icon_size * 0.75) {
g_object_unref (pixbuf);
pixbuf = NULL;
}
}
return pixbuf;
}
static void
gtk_image_menu_item_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen)
{
GtkSettings *settings;
guint show_image_connection;
if (!gtk_widget_has_screen (widget))
return;
settings = gtk_widget_get_settings (widget);
show_image_connection =
GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (settings),
"gtk-image-menu-item-connection"));
if (show_image_connection)
return;
show_image_connection =
g_signal_connect (settings, "notify::gtk-menu-images",
G_CALLBACK (gtk_image_menu_item_setting_changed), NULL);
g_object_set_data (G_OBJECT (settings),
I_("gtk-image-menu-item-connection"),
GUINT_TO_POINTER (show_image_connection));
show_image_change_notify (GTK_IMAGE_MENU_ITEM (widget));
}
/* POSITIONING */
void
awn_tooltip_update_position (AwnTooltip *tooltip)
{
AwnTooltipPrivate *priv;
GtkRequisition req;
gint x = 0, y = 0, w, h;
gint fx, fy, fw, fh;
GdkWindow *focus_win;
g_return_if_fail (AWN_IS_TOOLTIP (tooltip));
priv = tooltip->priv;
/* Get our dimensions */
gtk_widget_size_request (GTK_WIDGET (tooltip), &req);
w = req.width;
h = req.height;
/* Get the dimesions of the widget we are focusing on */
focus_win = gtk_widget_get_window (priv->focus);
gdk_window_get_origin (focus_win, &fx, &fy);
gdk_drawable_get_size (GDK_DRAWABLE (focus_win), &fw, &fh);
/* Find and set our position */
#define TOOLTIP_OFFSET 16
switch (priv->position) {
case GTK_POS_TOP:
x = fx + (fw / 2) - (w / 2);
y = fy + priv->size + priv->icon_offset + TOOLTIP_OFFSET;
break;
case GTK_POS_BOTTOM:
x = fx + (fw / 2) - (w / 2);
y = fy + fh - priv->size - priv->icon_offset - TOOLTIP_OFFSET - h;
break;
case GTK_POS_RIGHT:
x = fx + fw - priv->size - priv->icon_offset - TOOLTIP_OFFSET - w;
y = fy + (fh / 2) - h / 2;
break;
case GTK_POS_LEFT:
x = fx + priv->size + priv->icon_offset + TOOLTIP_OFFSET;
y = fy + (fh / 2) - h / 2;
break;
}
if (gtk_widget_has_screen (GTK_WIDGET (tooltip)))
{
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tooltip));
gint screen_w = gdk_screen_get_width (screen);
if (x + w > screen_w) x -= x + w - screen_w;
}
if (x < 0) x = 0;
if (y < 0) y = 0;
gtk_window_move (GTK_WINDOW (tooltip), x, y);
}
/**
* gtk_clutter_texture_set_from_icon_name:
* @texture: a #GtkClutterTexture
* @widget: (allow-none): a #GtkWidget or %NULL
* @icon_name: the name of the icon
* @icon_size: the icon size or -1
* @error: a return location for errors, or %NULL
*
* Sets the contents of @texture using the @icon_name from the
* current icon theme.
*
* Return value: %TRUE on success, %FALSE on failure
*
* Since: 1.0
*/
gboolean
gtk_clutter_texture_set_from_icon_name (GtkClutterTexture *texture,
GtkWidget *widget,
const gchar *icon_name,
GtkIconSize icon_size,
GError **error)
{
GError *local_error = NULL;
GtkSettings *settings;
GtkIconTheme *icon_theme;
gboolean returnval;
gint width, height;
GdkPixbuf *pixbuf;
g_return_val_if_fail (CLUTTER_IS_TEXTURE (texture), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (icon_name != NULL, FALSE);
g_return_val_if_fail ((icon_size > GTK_ICON_SIZE_INVALID) || (icon_size == -1), FALSE);
if (widget && gtk_widget_has_screen (widget))
{
GdkScreen *screen;
screen = gtk_widget_get_screen (widget);
settings = gtk_settings_get_for_screen (screen);
icon_theme = gtk_icon_theme_get_for_screen (screen);
}
else
{
settings = gtk_settings_get_default ();
icon_theme = gtk_icon_theme_get_default ();
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (icon_size == -1 ||
!gtk_icon_size_lookup_for_settings (settings, icon_size, &width, &height))
{
width = height = 48;
}
G_GNUC_END_IGNORE_DEPRECATIONS
pixbuf = gtk_icon_theme_load_icon (icon_theme,
icon_name,
MIN (width, height), 0,
&local_error);
if (local_error)
{
g_propagate_error (error, local_error);
return FALSE;
}
returnval = gtk_clutter_texture_set_from_pixbuf (texture, pixbuf, error);
g_object_unref (pixbuf);
return returnval;
}
static MatewnckScreen *
matewnck_selector_get_screen (MatewnckSelector *selector)
{
GdkScreen *screen;
g_assert (gtk_widget_has_screen (GTK_WIDGET (selector)));
screen = gtk_widget_get_screen (GTK_WIDGET (selector));
return matewnck_screen_get (gdk_screen_get_number (screen));
}
FloatRect screenRect(Widget* widget)
{
GtkWidget* container = gtk_widget_get_toplevel(GTK_WIDGET(widget->root()->hostWindow()->platformWindow()));
if (!GTK_WIDGET_TOPLEVEL(container))
return FloatRect();
GdkScreen* screen = gtk_widget_has_screen(container) ? gtk_widget_get_screen(container) : gdk_screen_get_default();
if (!screen)
return FloatRect();
gint monitor = gdk_screen_get_monitor_at_window(screen, GTK_WIDGET(container)->window);
GdkRectangle geometry;
gdk_screen_get_monitor_geometry(screen, monitor, &geometry);
return FloatRect(geometry.x, geometry.y, geometry.width, geometry.height);
}
FloatRect screenRect(Widget* widget)
{
GtkWidget* container = GTK_WIDGET(widget->containingWindow());
if (!container)
return FloatRect();
GdkScreen* screen = gtk_widget_has_screen(container) ? gtk_widget_get_screen(container) : gdk_screen_get_default();
if (!screen)
return FloatRect();
gint monitor = gdk_screen_get_monitor_at_window(screen, GTK_WIDGET(container)->window);
GdkRectangle geometry;
gdk_screen_get_monitor_geometry(screen, monitor, &geometry);
return FloatRect(geometry.x, geometry.y, geometry.width, geometry.height);
}
static void
setup_icons (GdmUserChooserWidget *widget)
{
if (gtk_widget_has_screen (GTK_WIDGET (widget))) {
widget->priv->icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (widget)));
} else {
widget->priv->icon_theme = gtk_icon_theme_get_default ();
}
if (widget->priv->icon_theme != NULL) {
g_signal_connect (widget->priv->icon_theme,
"changed",
G_CALLBACK (on_icon_theme_changed),
widget);
}
load_icons (widget);
}
static void
gtk_button_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen)
{
GtkButton *button;
GtkButtonPrivate *priv;
if (!gtk_widget_has_screen (widget))
return;
button = GTK_BUTTON (widget);
priv = button->priv;
/* If the button is being pressed while the screen changes the
release might never occur, so we reset the state. */
if (priv->button_down)
{
priv->button_down = FALSE;
gtk_button_update_state (button);
}
}
static GdkPixbuf *
load_pixbuf (GsdMediaKeysWindow *window,
const char *name,
int icon_size)
{
GtkIconTheme *theme;
GtkIconInfo *info;
GdkPixbuf *pixbuf;
GtkStyleContext *context;
GdkRGBA color;
if (window != NULL && gtk_widget_has_screen (GTK_WIDGET (window))) {
theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
} else {
theme = gtk_icon_theme_get_default ();
}
context = gtk_widget_get_style_context (GTK_WIDGET (window));
gtk_style_context_get_background_color (context, GTK_STATE_NORMAL, &color);
info = gtk_icon_theme_lookup_icon (theme,
name,
icon_size,
GTK_ICON_LOOKUP_FORCE_SIZE | GTK_ICON_LOOKUP_GENERIC_FALLBACK);
if (info == NULL) {
g_warning ("Failed to load '%s'", name);
return NULL;
}
pixbuf = gtk_icon_info_load_symbolic (info,
&color,
NULL,
NULL,
NULL,
NULL,
NULL);
gtk_icon_info_free (info);
return pixbuf;
}
static GdkPixbuf *
load_pixbuf (MsdMediaKeysWindow *window,
const char *name,
int icon_size)
{
GtkIconTheme *theme;
GdkPixbuf *pixbuf;
if (window != NULL && gtk_widget_has_screen (GTK_WIDGET (window))) {
theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
} else {
theme = gtk_icon_theme_get_default ();
}
pixbuf = gtk_icon_theme_load_icon (theme,
name,
icon_size,
GTK_ICON_LOOKUP_FORCE_SIZE,
NULL);
return pixbuf;
}
static void setSelectionPrimaryClipboardIfNeeded(WebKitWebView* webView)
{
if (!gtk_widget_has_screen(GTK_WIDGET(webView)))
return;
GtkClipboard* clipboard = gtk_widget_get_clipboard(GTK_WIDGET(webView), GDK_SELECTION_PRIMARY);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
WebCore::Page* corePage = core(webView);
Frame* targetFrame = corePage->focusController()->focusedOrMainFrame();
if (!targetFrame->selection()->isRange())
return;
dataObject->clear();
dataObject->setRange(targetFrame->selection()->toNormalizedRange());
viewSettingClipboard = webView;
GClosure* callback = g_cclosure_new_object(G_CALLBACK(collapseSelection), G_OBJECT(webView));
g_closure_set_marshal(callback, g_cclosure_marshal_VOID__VOID);
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard, PasteboardHelper::DoNotIncludeSmartPaste, callback);
viewSettingClipboard = 0;
}
static void
gtk_image_menu_item_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen)
{
GtkSettings *settings;
gulong show_image_connection;
if (!gtk_widget_has_screen (widget))
return;
settings = gtk_widget_get_settings (widget);
show_image_connection =
g_signal_handler_find (settings, G_SIGNAL_MATCH_FUNC, 0, 0,
NULL, gtk_image_menu_item_setting_changed, NULL);
if (show_image_connection)
return;
g_signal_connect (settings, "notify::gtk-menu-images",
G_CALLBACK (gtk_image_menu_item_setting_changed), NULL);
show_image_change_notify (GTK_IMAGE_MENU_ITEM (widget));
}
static void
menu_style_set_cb (GtkWidget *menu, GtkStyle *old_style,
ShellStatusMenu *status)
{
ShellStatusMenuPrivate *priv = status->priv;
GtkSettings *settings;
int width;
int height;
priv->icon_size = gtk_icon_size_from_name ("panel-menu");
if (priv->icon_size == GTK_ICON_SIZE_INVALID)
priv->icon_size = gtk_icon_size_register ("panel-menu", 24, 24);
if (gtk_widget_has_screen (menu))
settings = gtk_settings_get_for_screen (gtk_widget_get_screen (menu));
else
settings = gtk_settings_get_default ();
if (!gtk_icon_size_lookup_for_settings (settings, priv->icon_size, &width,
&height))
priv->pixel_size = -1;
else
priv->pixel_size = MAX(width, height);
}
static VALUE
rg_has_screen_p(VALUE self)
{
return CBOOL2RVAL(gtk_widget_has_screen(_SELF(self)));
}
static GdkScreen* getScreen(GtkWidget* widget)
{
return gtk_widget_has_screen(widget) ? gtk_widget_get_screen(widget) : gdk_screen_get_default();
}
static GdkPixbuf *
render_icon (GtkStyle *style,
const GtkIconSource *source,
GtkTextDirection direction,
GtkStateType state,
GtkIconSize size,
GtkWidget *widget,
const gchar *detail)
{
int width = 1;
int height = 1;
GdkPixbuf *scaled;
GdkPixbuf *stated;
GdkPixbuf *base_pixbuf;
GdkScreen *screen;
GtkSettings *settings;
/* Oddly, style can be NULL in this function, because
* GtkIconSet can be used without a style and if so
* it uses this function.
*/
base_pixbuf = gtk_icon_source_get_pixbuf (source);
g_return_val_if_fail (base_pixbuf != NULL, NULL);
if (widget && gtk_widget_has_screen (widget))
{
screen = gtk_widget_get_screen (widget);
settings = gtk_settings_get_for_screen (screen);
}
else if (style->colormap)
{
screen = gdk_colormap_get_screen (style->colormap);
settings = gtk_settings_get_for_screen (screen);
}
else
{
settings = gtk_settings_get_default ();
GTK_NOTE (MULTIHEAD,
g_warning ("Using the default screen for gtk_default_render_icon()"));
}
if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height))
{
g_warning (G_STRLOC ": invalid icon size '%d'", size);
return NULL;
}
/* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
* leave it alone.
*/
if (size != (GtkIconSize)-1 && gtk_icon_source_get_size_wildcarded (source))
scaled = scale_or_ref (base_pixbuf, width, height);
else
scaled = g_object_ref (base_pixbuf);
/* If the state was wildcarded, then generate a state. */
if (gtk_icon_source_get_state_wildcarded (source))
{
if (state == GTK_STATE_INSENSITIVE)
{
stated = set_transparency (scaled, 0.3);
gdk_pixbuf_saturate_and_pixelate (stated, stated, 0.1, FALSE);
g_object_unref (scaled);
}
else if (state == GTK_STATE_PRELIGHT)
{
stated = gdk_pixbuf_copy (scaled);
gdk_pixbuf_saturate_and_pixelate (scaled, stated, 1.2, FALSE);
g_object_unref (scaled);
}
else
{
stated = scaled;
}
}
else
stated = scaled;
return stated;
}
gboolean
load_image_by_id (GtkImage * image, GtkIconSize size, const gchar * image_id)
{
GdkPixbuf *pixbuf;
gint width;
gint height;
GtkIconTheme *icon_theme;
gchar *id;
gboolean icon_exists;
if (!image_id)
return FALSE;
id = g_strdup (image_id);
gtk_icon_size_lookup (size, &width, &height);
if (g_path_is_absolute (id))
{
pixbuf = gdk_pixbuf_new_from_file_at_size (id, width, height, NULL);
icon_exists = (pixbuf != NULL);
if (icon_exists)
{
gtk_image_set_from_pixbuf (image, pixbuf);
g_object_unref (pixbuf);
}
else
gtk_image_set_from_icon_name (image, "image-missing", size);
}
else
{
if ( /* file extensions are not copesetic with loading by "name" */
g_str_has_suffix (id, ".png") ||
g_str_has_suffix (id, ".svg") ||
g_str_has_suffix (id, ".xpm")
)
id[strlen (id) - 4] = '\0';
if (gtk_widget_has_screen (GTK_WIDGET (image)))
icon_theme =
gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET
(image)));
else
icon_theme = gtk_icon_theme_get_default ();
icon_exists = gtk_icon_theme_has_icon (icon_theme, id);
if (icon_exists)
gtk_image_set_from_icon_name (image, id, size);
else
gtk_image_set_from_icon_name (image, "image-missing", size);
}
g_free (id);
return icon_exists;
}
