/* The panel can't use gdk_screen_get_monitor_at_point() since it has its own
* view of which monitors are present. Look at get_monitors_for_screen() above
* to see why. */
int
panel_multiscreen_get_monitor_at_point (GdkScreen *screen,
int x,
int y)
{
int n_screen;
int i;
int n_monitors;
GdkRectangle *geoms;
int min_dist_squared;
int closest_monitor;
/* not -1 as callers expect a real monitor */
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
n_screen = gdk_screen_get_number (screen);
n_monitors = monitors[n_screen];
geoms = geometries[n_screen];
min_dist_squared = G_MAXINT32;
closest_monitor = 0;
for (i = 0; i < n_monitors; i++) {
int dist_x, dist_y;
int dist_squared;
dist_x = axis_distance (x, geoms[i].x, geoms[i].width);
dist_y = axis_distance (y, geoms[i].y, geoms[i].height);
if (dist_x == 0 && dist_y == 0)
return i;
dist_squared = dist_x * dist_x + dist_y * dist_y;
if (dist_squared < min_dist_squared) {
min_dist_squared = dist_squared;
closest_monitor = i;
}
}
return closest_monitor;
}
void
window_move_to_screen_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GtkWidget *widget;
GdkScreen *screen;
return_if_no_widget (widget, data);
if (! gtk_widget_is_toplevel (widget))
widget = gtk_widget_get_toplevel (widget);
screen = g_object_get_data (G_OBJECT (current), "screen");
if (GDK_IS_SCREEN (screen) && screen != gtk_widget_get_screen (widget))
{
gtk_window_set_screen (GTK_WINDOW (widget), screen);
}
}
/**
* gimp_dock_with_window_new:
* @factory: a #GimpDialogFacotry
* @screen: the #GdkScreen the dock window should appear on
* @toolbox: if %TRUE; gives a "gimp-toolbox-window" with a
* "gimp-toolbox", "gimp-dock-window"+"gimp-dock"
* otherwise
*
* Returns: the newly created #GimpDock with the #GimpDockWindow
**/
GtkWidget *
gimp_dock_with_window_new (GimpDialogFactory *factory,
GdkScreen *screen,
gboolean toolbox)
{
GtkWidget *dock_window;
GimpDockContainer *dock_container;
GtkWidget *dock;
GimpUIManager *ui_manager;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
/* Create a dock window to put the dock in. We need to create the
* dock window before the dock because the dock has a dependency to
* the ui manager in the dock window
*/
dock_window = gimp_dialog_factory_dialog_new (factory, screen,
NULL /*ui_manager*/,
(toolbox ?
"gimp-toolbox-window" :
"gimp-dock-window"),
-1 /*view_size*/,
FALSE /*present*/);
dock_container = GIMP_DOCK_CONTAINER (dock_window);
ui_manager = gimp_dock_container_get_ui_manager (dock_container);
dock = gimp_dialog_factory_dialog_new (factory,
screen,
ui_manager,
(toolbox ?
"gimp-toolbox" :
"gimp-dock"),
-1 /*view_size*/,
FALSE /*present*/);
if (dock)
gimp_dock_window_add_dock (GIMP_DOCK_WINDOW (dock_window),
GIMP_DOCK (dock),
-1);
return dock;
}
/**
* gimp_dialog_factory_dialog_new:
* @factory: a #GimpDialogFactory
* @screen: the #GdkScreen the dialog should appear on
* @identifier: the identifier of the dialog as registered with
* gimp_dialog_factory_register_entry()
* @view_size:
* @present: whether gtk_window_present() should be called
*
* Creates a new toplevel dialog or a #GimpDockable, depending on whether
* %factory is a toplevel of dockable factory.
*
* Return value: the newly created dialog or an already existing singleton
* dialog.
**/
GtkWidget *
gimp_dialog_factory_dialog_new (GimpDialogFactory *factory,
GdkScreen *screen,
const gchar *identifier,
gint view_size,
gboolean present)
{
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (identifier != NULL, NULL);
return gimp_dialog_factory_dialog_new_internal (factory,
screen,
factory->context,
identifier,
view_size,
FALSE,
present);
}
/**
* gdk_screen_set_font_options:
* @screen: a #GdkScreen
* @options: (allow-none): a #cairo_font_options_t, or %NULL to unset any
* previously set default font options.
*
* Sets the default font options for the screen. These
* options will be set on any #PangoContext’s newly created
* with gdk_pango_context_get_for_screen(). Changing the
* default set of font options does not affect contexts that
* have already been created.
*
* Since: 2.10
**/
void
gdk_screen_set_font_options (GdkScreen *screen,
const cairo_font_options_t *options)
{
g_return_if_fail (GDK_IS_SCREEN (screen));
if (screen->font_options != options)
{
if (screen->font_options)
cairo_font_options_destroy (screen->font_options);
if (options)
screen->font_options = cairo_font_options_copy (options);
else
screen->font_options = NULL;
g_object_notify (G_OBJECT (screen), "font-options");
}
}
/**
* gdk_pango_context_get_for_screen:
* @screen: the #GdkScreen for which the context is to be created.
*
* Creates a #PangoContext for @screen.
*
* The context must be freed when you're finished with it.
*
* When using GTK+, normally you should use gtk_widget_get_pango_context()
* instead of this function, to get the appropriate context for
* the widget you intend to render text onto.
*
* The newly created context will have the default font options
* (see #cairo_font_options_t) for the screen; if these options
* change it will not be updated. Using gtk_widget_get_pango_context()
* is more convenient if you want to keep a context around and track
* changes to the screen's font rendering settings.
*
* Return value: (transfer full): a new #PangoContext for @screen
*
* Since: 2.2
**/
PangoContext *
gdk_pango_context_get_for_screen (GdkScreen *screen)
{
PangoFontMap *fontmap;
PangoContext *context;
const cairo_font_options_t *options;
double dpi;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
fontmap = pango_cairo_font_map_get_default ();
context = pango_font_map_create_context (fontmap);
options = gdk_screen_get_font_options (screen);
pango_cairo_context_set_font_options (context, options);
dpi = gdk_screen_get_resolution (screen);
pango_cairo_context_set_resolution (context, dpi);
return context;
}
NotifyStack *
notify_stack_new (NotifyDaemon *daemon,
GdkScreen *screen,
guint monitor,
NotifyStackLocation location)
{
NotifyStack *stack;
g_assert (daemon != NULL);
g_assert (screen != NULL && GDK_IS_SCREEN (screen));
g_assert (monitor < (guint)gdk_screen_get_n_monitors (screen));
g_assert (location != NOTIFY_STACK_LOCATION_UNKNOWN);
stack = g_new0 (NotifyStack, 1);
stack->daemon = daemon;
stack->screen = screen;
stack->monitor = monitor;
stack->location = location;
return stack;
}
/**
* gedit_utils_get_current_workspace: Get the current workspace
*
* Get the currently visible workspace for the #GdkScreen.
*
* If the X11 window property isn't found, 0 (the first workspace)
* is returned.
*/
guint
gedit_utils_get_current_workspace (GdkScreen *screen)
{
#ifdef GDK_WINDOWING_X11
GdkWindow *root_win;
GdkDisplay *display;
Atom type;
gint format;
gulong nitems;
gulong bytes_after;
guint *current_desktop;
gint err, result;
guint ret = 0;
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
root_win = gdk_screen_get_root_window (screen);
display = gdk_screen_get_display (screen);
gdk_error_trap_push ();
result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (root_win),
gdk_x11_get_xatom_by_name_for_display (display, "_NET_CURRENT_DESKTOP"),
0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems,
&bytes_after, (gpointer) ¤t_desktop);
err = gdk_error_trap_pop ();
if (err != Success || result != Success)
return ret;
if (type == XA_CARDINAL && format == 32 && nitems > 0)
ret = current_desktop[0];
XFree (current_desktop);
return ret;
#else
/* FIXME: on mac etc proably there are native APIs
* to get the current workspace etc */
return 0;
#endif
}
gboolean
panel_show_uri_force_mime_type (GdkScreen *screen,
const gchar *uri,
const gchar *mime_type,
guint32 timestamp,
GError **error)
{
GFile *file;
GAppInfo *appinfo;
gboolean ret;
GdkDisplay *display;
GdkAppLaunchContext *context;
GList *uris;
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (uri != NULL, FALSE);
g_return_val_if_fail (mime_type != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
file = g_file_new_for_uri (uri);
appinfo = g_app_info_get_default_for_type (mime_type,
!g_file_is_native (file));
g_object_unref (file);
if (appinfo == NULL) {
/* no application for the mime type, so let's fallback on
* automatic detection */
return panel_show_uri (screen, uri, timestamp, error);
}
uris = g_list_append (NULL, (gpointer)uri);
display = gdk_screen_get_display (screen);
context = gdk_display_get_app_launch_context (display);
ret = g_app_info_launch_uris (appinfo, uris, G_APP_LAUNCH_CONTEXT(context), error);
g_object_unref (context);
g_list_free (uris);
g_object_unref (appinfo);
return ret;
}
static void
get_rgba_at_cursor (GstyleEyedropper *self,
GdkScreen *screen,
GdkDevice *device,
gint x,
gint y,
GdkRGBA *rgba)
{
GdkWindow *window;
GdkPixbuf *pixbuf;
guchar *pixels;
g_assert (GSTYLE_IS_EYEDROPPER (self));
g_assert (GDK_IS_SCREEN (screen));
g_assert (GDK_IS_DEVICE (device));
window = gdk_screen_get_root_window (screen);
pixbuf = gdk_pixbuf_get_from_window (window, x, y, 1, 1);
if (!pixbuf)
{
window = gdk_device_get_window_at_position (device, &x, &y);
if (!window)
return;
pixbuf = gdk_pixbuf_get_from_window (window, x, y, 1, 1);
if (!pixbuf)
return;
}
g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
pixels = gdk_pixbuf_get_pixels (pixbuf);
rgba->red = pixels[0] / 255.0;
rgba->green = pixels[1] / 255.0;
rgba->blue = pixels[2] /255.0;
rgba->alpha = 1.0;
g_object_unref (pixbuf);
}
gboolean
gdk_spawn_on_screen (GdkScreen *screen,
const gchar *working_directory,
gchar **argv,
gchar **envp,
GSpawnFlags flags,
GSpawnChildSetupFunc child_setup,
gpointer user_data,
gint *child_pid,
GError **error)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
return g_spawn_async (working_directory,
argv,
envp,
flags,
child_setup,
user_data,
child_pid,
error);
}
int
clip_GTK_ICONTHEMEGETFORSCREEN(ClipMachine * cm)
{
C_object *cscreen = _fetch_co_arg(cm);
C_object *cicon;
GtkIconTheme *icon;
CHECKCOBJ(cscreen, GDK_IS_SCREEN(cscreen->object));
icon = gtk_icon_theme_get_for_screen(GDK_SCREEN(cscreen->object));
if (icon)
{
cicon = _list_get_cobject(cm,icon);
if (!cicon) cicon = _register_object(cm,icon,GTK_TYPE_ICON_THEME,NULL,NULL);
if (cicon) _clip_mclone(cm,RETPTR(cm),&cicon->obj);
}
return 0;
err:
return 1;
}
static GailScreenInfo *
get_screen_info (GdkScreen *screen)
{
int screen_n;
gail_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
screen_n = gdk_screen_get_number (screen);
if (gail_screens && gail_screens [screen_n].screen_initialized)
return &gail_screens [screen_n];
if (!gail_screens)
init_gail_screens ();
g_assert (gail_screens != NULL);
init_gail_screen (screen, screen_n);
g_assert (gail_screens [screen_n].screen_initialized);
return &gail_screens [screen_n];
}
/**
* gimp_dialog_factory_dock_new:
* @factory: a #GimpDialogFacotry
* @screen: the #GdkScreen the dock should appear on
*
* Returns a new #GimpDock in this %factory's context. We use a function
* pointer passed to this %factory's constructor instead of simply
* gimp_dock_new() because we may want different instances of
* #GimpDialogFactory create different subclasses of #GimpDock.
*
* Return value: the newly created #GimpDock.
**/
GtkWidget *
gimp_dialog_factory_dock_new (GimpDialogFactory *factory,
GdkScreen *screen)
{
GtkWidget *dock;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (factory->new_dock_func != NULL, NULL);
dock = factory->new_dock_func (factory, factory->context, 0);
if (dock)
{
gtk_window_set_screen (GTK_WINDOW (dock), screen);
gimp_dialog_factory_set_widget_data (dock, factory, NULL);
gimp_dialog_factory_add_dialog (factory, dock);
}
return dock;
}
gboolean
panel_launch_desktop_file (const char *desktop_file,
GdkScreen *screen,
GError **error)
{
GDesktopAppInfo *appinfo;
gboolean retval;
g_return_val_if_fail (desktop_file != NULL, FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
appinfo = NULL;
if (g_path_is_absolute (desktop_file))
appinfo = g_desktop_app_info_new_from_filename (desktop_file);
else {
char *full;
full = panel_g_lookup_in_applications_dirs (desktop_file);
if (full) {
appinfo = g_desktop_app_info_new_from_filename (full);
g_free (full);
}
}
if (appinfo == NULL)
return FALSE;
retval = panel_app_info_launch_uris (G_APP_INFO (appinfo), NULL, screen,
gtk_get_current_event_time (),
error);
g_object_unref (appinfo);
return retval;
}
static void
xfce_dialog_show_help_uri (GdkScreen *screen,
GtkWindow *parent,
GString *uri)
{
GError *error = NULL;
gchar *path;
gchar *cmd;
gboolean result;
g_return_if_fail (GDK_IS_SCREEN (screen));
g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
path = g_find_program_in_path ("exo-open");
if (G_LIKELY (path != NULL))
{
cmd = g_strdup_printf ("%s --launch WebBrowser '%s'", path, uri->str);
result = xfce_spawn_command_line_on_screen (screen, cmd, FALSE, TRUE, &error);
g_free (path);
g_free (cmd);
}
else
{
/* not very likely to happen, but it is possible exo is not installed */
result = gtk_show_uri (screen, uri->str, gtk_get_current_event_time (), &error);
}
if (!result)
{
xfce_dialog_show_error (parent, error,
_("Failed to open web browser for online documentation"));
g_error_free (error);
}
}
/**
* gtk_mount_operation_set_screen:
* @op: a #GtkMountOperation
* @screen: a #GdkScreen
*
* Sets the screen to show windows of the #GtkMountOperation on.
*
* Since: 2.14
*/
void
gtk_mount_operation_set_screen (GtkMountOperation *op,
GdkScreen *screen)
{
GtkMountOperationPrivate *priv;
g_return_if_fail (GTK_IS_MOUNT_OPERATION (op));
g_return_if_fail (GDK_IS_SCREEN (screen));
priv = op->priv;
if (priv->screen == screen)
return;
if (priv->screen)
g_object_unref (priv->screen);
priv->screen = g_object_ref (screen);
if (priv->dialog)
gtk_window_set_screen (GTK_WINDOW (priv->dialog), screen);
g_object_notify (G_OBJECT (op), "screen");
}
gboolean
panel_show_help (GdkScreen *screen,
const gchar *doc,
const gchar *link,
GError **error)
{
GError *local_error = NULL;
char *uri;
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (doc != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (link)
uri = g_strdup_printf ("help:%s/%s", doc, link);
else
uri = g_strdup_printf ("help:%s", doc);
gtk_show_uri (screen, uri, gtk_get_current_event_time (), &local_error);
g_free (uri);
return _panel_show_help_handle_error (doc, screen, local_error, error);
}
EggTrayIcon *egg_tray_icon_new_for_screen(GdkScreen * screen, const char *name)
{
g_return_val_if_fail(GDK_IS_SCREEN(screen), NULL);
return egg_tray_icon_new_for_xscreen(GDK_SCREEN_XSCREEN(screen), name);
}
GtkWidget *
na_tray_child_new (GdkScreen *screen,
Window icon_window)
{
XWindowAttributes window_attributes;
Display *xdisplay;
NaTrayChild *child;
GdkVisual *visual;
gboolean visual_has_alpha;
GdkColormap *colormap;
gboolean new_colormap;
int red_prec, green_prec, blue_prec, depth;
int result;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (icon_window != None, NULL);
xdisplay = GDK_SCREEN_XDISPLAY (screen);
/* We need to determine the visual of the window we are embedding and create
* the socket in the same visual.
*/
gdk_error_trap_push ();
result = XGetWindowAttributes (xdisplay, icon_window,
&window_attributes);
gdk_error_trap_pop ();
if (!result) /* Window already gone */
return NULL;
visual = gdk_x11_screen_lookup_visual (screen,
window_attributes.visual->visualid);
if (!visual) /* Icon window is on another screen? */
return NULL;
new_colormap = FALSE;
if (visual == gdk_screen_get_rgb_visual (screen))
colormap = gdk_screen_get_rgb_colormap (screen);
else if (visual == gdk_screen_get_rgba_visual (screen))
colormap = gdk_screen_get_rgba_colormap (screen);
else if (visual == gdk_screen_get_system_visual (screen))
colormap = gdk_screen_get_system_colormap (screen);
else
{
colormap = gdk_colormap_new (visual, FALSE);
new_colormap = TRUE;
}
child = g_object_new (NA_TYPE_TRAY_CHILD, NULL);
child->icon_window = icon_window;
gtk_widget_set_colormap (GTK_WIDGET (child), colormap);
/* We have alpha if the visual has something other than red, green,
* and blue */
gdk_visual_get_red_pixel_details (visual, NULL, NULL, &red_prec);
gdk_visual_get_green_pixel_details (visual, NULL, NULL, &green_prec);
gdk_visual_get_blue_pixel_details (visual, NULL, NULL, &blue_prec);
depth = gdk_visual_get_depth (visual);
visual_has_alpha = red_prec + blue_prec + green_prec < depth;
child->has_alpha = (visual_has_alpha &&
gdk_display_supports_composite (gdk_screen_get_display (screen)));
child->composited = child->has_alpha;
if (new_colormap)
g_object_unref (colormap);
return GTK_WIDGET (child);
}
ScreenInfo *
myScreenInit (DisplayInfo *display_info, GdkScreen *gscr, unsigned long event_mask, gboolean replace_wm)
{
#ifdef ENABLE_KDE_SYSTRAY_PROXY
gchar selection[32];
#endif
ScreenInfo *screen_info;
GdkWindow *event_win;
PangoLayout *layout;
long desktop_visible;
int i, j;
g_return_val_if_fail (display_info, NULL);
g_return_val_if_fail (GDK_IS_SCREEN (gscr), NULL);
TRACE ("entering myScreenInit");
screen_info = g_new0 (ScreenInfo, 1);
screen_info->params = g_new0 (XfwmParams, 1);
screen_info->display_info = display_info;
screen_info->gscr = gscr;
desktop_visible = 0;
layout = NULL;
/* Create a GTK window so that we are just like any other GTK application */
screen_info->gtk_win = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (screen_info->gtk_win), gscr);
gtk_window_resize (GTK_WINDOW (screen_info->gtk_win), 5, 5);
gtk_window_move (GTK_WINDOW (screen_info->gtk_win), -1000, -1000);
gtk_widget_set_name (screen_info->gtk_win, "xfwm");
gtk_widget_show_now (screen_info->gtk_win);
/*
* The first time the first Gtk application on a display uses pango,
* pango grabs the XServer while it creates the font cache window.
* Therefore, force the cache window to be created now instead of
* trying to do it while we have another grab and deadlocking the server.
*/
layout = gtk_widget_create_pango_layout (screen_info->gtk_win, "-");
pango_layout_get_pixel_extents (layout, NULL, NULL);
g_object_unref (G_OBJECT (layout));
screen_info->xscreen = gdk_x11_screen_get_xscreen (gscr);
screen_info->xroot = (Window) GDK_DRAWABLE_XID(gdk_screen_get_root_window (gscr));
screen_info->screen = gdk_screen_get_number (gscr);
screen_info->cmap = GDK_COLORMAP_XCOLORMAP(gdk_screen_get_rgb_colormap (gscr));
screen_info->depth = DefaultDepth (display_info->dpy, screen_info->screen);
screen_info->visual = DefaultVisual (display_info->dpy, screen_info->screen);
screen_info->shape_win = (Window) None;
myScreenComputeSize (screen_info);
screen_info->xfwm4_win = GDK_WINDOW_XWINDOW (screen_info->gtk_win->window);
if (!myScreenSetWMAtom (screen_info, replace_wm))
{
gtk_widget_destroy (screen_info->gtk_win);
g_free (screen_info);
return NULL;
}
event_win = eventFilterAddWin (gscr, event_mask);
if (!event_win)
{
gtk_widget_destroy (screen_info->gtk_win);
g_free (screen_info);
return NULL;
}
gdk_window_set_user_data (event_win, screen_info->gtk_win);
screen_info->current_ws = 0;
screen_info->previous_ws = 0;
screen_info->current_ws = 0;
screen_info->previous_ws = 0;
screen_info->margins[STRUTS_TOP] = screen_info->gnome_margins[STRUTS_TOP] = 0;
screen_info->margins[STRUTS_LEFT] = screen_info->gnome_margins[STRUTS_LEFT] = 0;
screen_info->margins[STRUTS_RIGHT] = screen_info->gnome_margins[STRUTS_RIGHT] = 0;
screen_info->margins[STRUTS_BOTTOM] = screen_info->gnome_margins[STRUTS_BOTTOM] = 0;
screen_info->workspace_count = 0;
screen_info->workspace_names = NULL;
screen_info->workspace_names_items = 0;
screen_info->windows_stack = NULL;
screen_info->last_raise = NULL;
screen_info->windows = NULL;
screen_info->clients = NULL;
screen_info->client_count = 0;
screen_info->client_serial = 0L;
screen_info->button_handler_id = 0L;
screen_info->key_grabs = 0;
screen_info->pointer_grabs = 0;
getHint (display_info, screen_info->xroot, NET_SHOWING_DESKTOP, &desktop_visible);
screen_info->show_desktop = (desktop_visible != 0);
/* Create the side windows to detect edge movement */
/*left*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[0],
0, 0,
1, screen_info->height,
EnterWindowMask,
TRUE);
/*right*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[1],
screen_info->width - 1, 0,
1, screen_info->height,
EnterWindowMask,
TRUE);
/*top*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[2],
0, 0,
screen_info->width, 1,
EnterWindowMask,
TRUE);
/*bottom*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[3],
0, screen_info->height - 1,
screen_info->width, 1,
EnterWindowMask,
TRUE);
#ifdef ENABLE_KDE_SYSTRAY_PROXY
g_snprintf (selection, sizeof (selection), "_NET_SYSTEM_TRAY_S%d", screen_info->screen);
screen_info->net_system_tray_selection = XInternAtom (display_info->dpy, selection, FALSE);
screen_info->systray = getSystrayWindow (display_info, screen_info->net_system_tray_selection);
#endif
screen_info->font_height = 0;
screen_info->box_gc = None;
screen_info->black_gc = NULL;
screen_info->white_gc = NULL;
screen_info->title_colors[ACTIVE].gc = NULL;
screen_info->title_colors[ACTIVE].allocated = FALSE;
screen_info->title_colors[INACTIVE].gc = NULL;
screen_info->title_colors[INACTIVE].allocated = FALSE;
screen_info->title_shadow_colors[ACTIVE].gc = NULL;
screen_info->title_shadow_colors[ACTIVE].allocated = FALSE;
screen_info->title_shadow_colors[INACTIVE].gc = NULL;
screen_info->title_shadow_colors[INACTIVE].allocated = FALSE;
for (i = 0; i < SIDE_COUNT; i++)
{
xfwmPixmapInit (screen_info, &screen_info->sides[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->sides[i][INACTIVE]);
}
for (i = 0; i < CORNER_COUNT; i++)
{
xfwmPixmapInit (screen_info, &screen_info->corners[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->corners[i][INACTIVE]);
}
for (i = 0; i < BUTTON_COUNT; i++)
{
for (j = 0; j < STATE_COUNT; j++)
{
xfwmPixmapInit (screen_info, &screen_info->buttons[i][j]);
}
}
for (i = 0; i < TITLE_COUNT; i++)
{
xfwmPixmapInit (screen_info, &screen_info->title[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->title[i][INACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->top[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->top[i][INACTIVE]);
}
screen_info->monitors_index = NULL;
myScreenInvalidateMonitorCache (screen_info);
myScreenRebuildMonitorIndex (screen_info);
return (screen_info);
}
void
_gdk_visual_init (GdkScreen *screen)
{
static const gint possible_depths[8] = { 32, 30, 24, 16, 15, 8, 4, 1 };
static const GdkVisualType possible_types[6] =
{
GDK_VISUAL_DIRECT_COLOR,
GDK_VISUAL_TRUE_COLOR,
GDK_VISUAL_PSEUDO_COLOR,
GDK_VISUAL_STATIC_COLOR,
GDK_VISUAL_GRAYSCALE,
GDK_VISUAL_STATIC_GRAY
};
GdkScreenX11 *screen_x11;
XVisualInfo *visual_list;
XVisualInfo visual_template;
GdkVisualPrivate *temp_visual;
Visual *default_xvisual;
GdkVisualPrivate **visuals;
int nxvisuals;
int nvisuals;
int i, j;
g_return_if_fail (GDK_IS_SCREEN (screen));
screen_x11 = GDK_SCREEN_X11 (screen);
nxvisuals = 0;
visual_template.screen = screen_x11->screen_num;
visual_list = XGetVisualInfo (screen_x11->xdisplay, VisualScreenMask, &visual_template, &nxvisuals);
visuals = g_new (GdkVisualPrivate *, nxvisuals);
for (i = 0; i < nxvisuals; i++)
visuals[i] = g_object_new (GDK_TYPE_VISUAL, NULL);
default_xvisual = DefaultVisual (screen_x11->xdisplay, screen_x11->screen_num);
nvisuals = 0;
for (i = 0; i < nxvisuals; i++)
{
visuals[nvisuals]->screen = screen;
if (visual_list[i].depth >= 1)
{
#ifdef __cplusplus
switch (visual_list[i].c_class)
#else /* __cplusplus */
switch (visual_list[i].class)
#endif /* __cplusplus */
{
case StaticGray:
visuals[nvisuals]->visual.type = GDK_VISUAL_STATIC_GRAY;
break;
case GrayScale:
visuals[nvisuals]->visual.type = GDK_VISUAL_GRAYSCALE;
break;
case StaticColor:
visuals[nvisuals]->visual.type = GDK_VISUAL_STATIC_COLOR;
break;
case PseudoColor:
visuals[nvisuals]->visual.type = GDK_VISUAL_PSEUDO_COLOR;
break;
case TrueColor:
visuals[nvisuals]->visual.type = GDK_VISUAL_TRUE_COLOR;
break;
case DirectColor:
visuals[nvisuals]->visual.type = GDK_VISUAL_DIRECT_COLOR;
break;
}
visuals[nvisuals]->visual.depth = visual_list[i].depth;
visuals[nvisuals]->visual.byte_order =
(ImageByteOrder(screen_x11->xdisplay) == LSBFirst) ?
GDK_LSB_FIRST : GDK_MSB_FIRST;
visuals[nvisuals]->visual.red_mask = visual_list[i].red_mask;
visuals[nvisuals]->visual.green_mask = visual_list[i].green_mask;
visuals[nvisuals]->visual.blue_mask = visual_list[i].blue_mask;
visuals[nvisuals]->visual.colormap_size = visual_list[i].colormap_size;
visuals[nvisuals]->visual.bits_per_rgb = visual_list[i].bits_per_rgb;
visuals[nvisuals]->xvisual = visual_list[i].visual;
if ((visuals[nvisuals]->visual.type == GDK_VISUAL_TRUE_COLOR) ||
(visuals[nvisuals]->visual.type == GDK_VISUAL_DIRECT_COLOR))
{
gdk_visual_decompose_mask (visuals[nvisuals]->visual.red_mask,
&visuals[nvisuals]->visual.red_shift,
&visuals[nvisuals]->visual.red_prec);
gdk_visual_decompose_mask (visuals[nvisuals]->visual.green_mask,
&visuals[nvisuals]->visual.green_shift,
&visuals[nvisuals]->visual.green_prec);
gdk_visual_decompose_mask (visuals[nvisuals]->visual.blue_mask,
&visuals[nvisuals]->visual.blue_shift,
&visuals[nvisuals]->visual.blue_prec);
}
else
{
visuals[nvisuals]->visual.red_mask = 0;
visuals[nvisuals]->visual.red_shift = 0;
visuals[nvisuals]->visual.red_prec = 0;
visuals[nvisuals]->visual.green_mask = 0;
visuals[nvisuals]->visual.green_shift = 0;
visuals[nvisuals]->visual.green_prec = 0;
visuals[nvisuals]->visual.blue_mask = 0;
visuals[nvisuals]->visual.blue_shift = 0;
visuals[nvisuals]->visual.blue_prec = 0;
}
nvisuals += 1;
}
}
if (visual_list)
XFree (visual_list);
for (i = 0; i < nvisuals; i++)
{
for (j = i+1; j < nvisuals; j++)
{
if (visuals[j]->visual.depth >= visuals[i]->visual.depth)
{
if ((visuals[j]->visual.depth == 8) && (visuals[i]->visual.depth == 8))
{
if (visuals[j]->visual.type == GDK_VISUAL_PSEUDO_COLOR)
{
temp_visual = visuals[j];
visuals[j] = visuals[i];
visuals[i] = temp_visual;
}
else if ((visuals[i]->visual.type != GDK_VISUAL_PSEUDO_COLOR) &&
visuals[j]->visual.type > visuals[i]->visual.type)
{
temp_visual = visuals[j];
visuals[j] = visuals[i];
visuals[i] = temp_visual;
}
}
else if ((visuals[j]->visual.depth > visuals[i]->visual.depth) ||
((visuals[j]->visual.depth == visuals[i]->visual.depth) &&
(visuals[j]->visual.type > visuals[i]->visual.type)))
{
temp_visual = visuals[j];
visuals[j] = visuals[i];
visuals[i] = temp_visual;
}
}
}
}
for (i = 0; i < nvisuals; i++)
{
if (default_xvisual->visualid == visuals[i]->xvisual->visualid)
screen_x11->system_visual = visuals[i];
/* For now, we only support 8888 ARGB for the "rgba visual".
* Additional formats (like ABGR) could be added later if they
* turn up.
*/
if (visuals[i]->visual.depth == 32 &&
(visuals[i]->visual.red_mask == 0xff0000 &&
visuals[i]->visual.green_mask == 0x00ff00 &&
visuals[i]->visual.blue_mask == 0x0000ff))
{
screen_x11->rgba_visual = GDK_VISUAL (visuals[i]);
}
}
#ifdef G_ENABLE_DEBUG
if (_gdk_debug_flags & GDK_DEBUG_MISC)
for (i = 0; i < nvisuals; i++)
g_message ("visual: %s: %d",
visual_names[visuals[i]->visual.type],
visuals[i]->visual.depth);
#endif /* G_ENABLE_DEBUG */
screen_x11->navailable_depths = 0;
for (i = 0; i < G_N_ELEMENTS (possible_depths); i++)
{
for (j = 0; j < nvisuals; j++)
{
if (visuals[j]->visual.depth == possible_depths[i])
{
screen_x11->available_depths[screen_x11->navailable_depths++] = visuals[j]->visual.depth;
break;
}
}
}
if (screen_x11->navailable_depths == 0)
g_error ("unable to find a usable depth");
screen_x11->navailable_types = 0;
for (i = 0; i < G_N_ELEMENTS (possible_types); i++)
{
for (j = 0; j < nvisuals; j++)
{
if (visuals[j]->visual.type == possible_types[i])
{
screen_x11->available_types[screen_x11->navailable_types++] = visuals[j]->visual.type;
break;
}
}
}
for (i = 0; i < nvisuals; i++)
gdk_visual_add ((GdkVisual*) visuals[i]);
if (screen_x11->navailable_types == 0)
g_error ("unable to find a usable visual type");
screen_x11->visuals = visuals;
screen_x11->nvisuals = nvisuals;
}
void
detect_desktop_environment(OperatingSystem * os)
{
const gchar *tmp = g_getenv("GNOME_DESKTOP_SESSION_ID");
FILE *version;
char vers[16];
if (tmp) {
/* FIXME: this might not be true, as the gnome-panel in path
may not be the one that's running.
see where the user's running panel is and run *that* to
obtain the version. */
version = popen("gnome-about --gnome-version", "r");
if (version) {
(void)fscanf(version, _("Version: %s"), vers);
if (pclose(version))
goto unknown;
} else {
goto unknown;
}
os->desktop = g_strdup_printf("GNOME %s", vers);
} else if (g_getenv("KDE_FULL_SESSION")) {
if (g_getenv("KDE_SESSION_VERSION") && strstr(g_getenv("KDE_SESSION_VERSION"),(gchar *)"4")) {
version = popen("kwin --version", "r");
} else {
version = popen("kcontrol --version", "r");
}
if (version) {
char buf[32];
(void)fgets(buf, 32, version);
(void)fscanf(version, "KDE: %s", vers);
if (pclose(version))
goto unknown;
} else {
goto unknown;
}
os->desktop = g_strdup_printf("KDE %s", vers);
} else {
unknown:
os->desktop = NULL;
if (!g_getenv("DISPLAY")) {
os->desktop = g_strdup(_("Terminal"));
} else {
GdkScreen *screen = gdk_screen_get_default();
if (screen && GDK_IS_SCREEN(screen)) {
const gchar *windowman;
windowman = gdk_x11_screen_get_window_manager_name(screen);
if (g_str_equal(windowman, "Xfwm4")) {
/* FIXME: check if xprop -root | grep XFCE_DESKTOP_WINDOW is defined */
os->desktop = g_strdup("XFCE 4");
} else if ((tmp = g_getenv("XDG_CURRENT_DESKTOP"))) {
os->desktop = g_strdup(tmp);
if ((tmp = g_getenv("DESKTOP_SESSION")) && !g_str_equal(os->desktop, tmp)) {
g_free(os->desktop);
os->desktop = g_strdup(tmp);
}
}
if (!os->desktop) {
os->desktop = g_strdup_printf(_("Unknown (Window Manager: %s)"),
windowman);
}
} else {
os->desktop = g_strdup(_("Unknown"));
}
}
}
}
XfdesktopRegularFileIcon *
xfdesktop_regular_file_icon_new(GFile *file,
GFileInfo *file_info,
GdkScreen *screen,
XfdesktopFileIconManager *fmanager)
{
XfdesktopRegularFileIcon *regular_file_icon;
g_return_val_if_fail(G_IS_FILE(file), NULL);
g_return_val_if_fail(G_IS_FILE_INFO(file_info), NULL);
g_return_val_if_fail(GDK_IS_SCREEN(screen), NULL);
regular_file_icon = g_object_new(XFDESKTOP_TYPE_REGULAR_FILE_ICON, NULL);
regular_file_icon->priv->file = g_object_ref(file);
regular_file_icon->priv->file_info = g_object_ref(file_info);
/* set the display name */
regular_file_icon->priv->display_name = xfdesktop_file_utils_get_display_name(file,
file_info);
/* query file system information from GIO */
regular_file_icon->priv->filesystem_info = g_file_query_filesystem_info(regular_file_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
/* query file information from GIO */
regular_file_icon->priv->file_info = g_file_query_info(regular_file_icon->priv->file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
regular_file_icon->priv->gscreen = screen;
regular_file_icon->priv->fmanager = fmanager;
g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)),
"changed",
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
regular_file_icon);
if(g_file_info_get_file_type(regular_file_icon->priv->file_info) == G_FILE_TYPE_DIRECTORY) {
regular_file_icon->priv->monitor = g_file_monitor(regular_file_icon->priv->file,
G_FILE_MONITOR_NONE,
NULL,
NULL);
g_signal_connect(regular_file_icon->priv->monitor, "changed",
G_CALLBACK(cb_folder_contents_changed),
regular_file_icon);
g_object_get(regular_file_icon->priv->fmanager,
"show-thumbnails", ®ular_file_icon->priv->show_thumbnails,
NULL);
/* Keep an eye on the show-thumbnails property for folder thumbnails */
g_signal_connect(G_OBJECT(fmanager), "notify::show-thumbnails",
G_CALLBACK(cb_show_thumbnails_notify), regular_file_icon);
}
return regular_file_icon;
}
/**
* gdk_x11_screen_supports_net_wm_hint:
* @screen: the relevant #GdkScreen.
* @property: a property atom.
*
* This function is specific to the X11 backend of GDK, and indicates
* whether the window manager supports a certain hint from the
* Extended Window Manager Hints Specification. You can find this
* specification on
* <ulink url="http://www.freedesktop.org">http://www.freedesktop.org</ulink>.
*
* When using this function, keep in mind that the window manager
* can change over time; so you shouldn't use this function in
* a way that impacts persistent application state. A common bug
* is that your application can start up before the window manager
* does when the user logs in, and before the window manager starts
* gdk_x11_screen_supports_net_wm_hint() will return %FALSE for every property.
* You can monitor the window_manager_changed signal on #GdkScreen to detect
* a window manager change.
*
* Return value: %TRUE if the window manager supports @property
*
* Since: 2.2
**/
gboolean
gdk_x11_screen_supports_net_wm_hint (GdkScreen *screen,
GdkAtom property)
{
gulong i;
GdkX11Screen *x11_screen;
NetWmSupportedAtoms *supported_atoms;
GdkDisplay *display;
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
x11_screen = GDK_X11_SCREEN (screen);
display = x11_screen->display;
if (!G_LIKELY (GDK_X11_DISPLAY (display)->trusted_client))
return FALSE;
supported_atoms = g_object_get_data (G_OBJECT (screen), "gdk-net-wm-supported-atoms");
if (!supported_atoms)
{
supported_atoms = g_new0 (NetWmSupportedAtoms, 1);
g_object_set_data_full (G_OBJECT (screen), "gdk-net-wm-supported-atoms", supported_atoms, cleanup_atoms);
}
fetch_net_wm_check_window (screen);
if (x11_screen->wmspec_check_window == None)
return FALSE;
if (x11_screen->need_refetch_net_supported)
{
/* WM has changed since we last got the supported list,
* refetch it.
*/
Atom type;
gint format;
gulong bytes_after;
x11_screen->need_refetch_net_supported = FALSE;
if (supported_atoms->atoms)
XFree (supported_atoms->atoms);
supported_atoms->atoms = NULL;
supported_atoms->n_atoms = 0;
XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), x11_screen->xroot_window,
gdk_x11_get_xatom_by_name_for_display (display, "_NET_SUPPORTED"),
0, G_MAXLONG, False, XA_ATOM, &type, &format,
&supported_atoms->n_atoms, &bytes_after,
(guchar **)&supported_atoms->atoms);
if (type != XA_ATOM)
return FALSE;
}
if (supported_atoms->atoms == NULL)
return FALSE;
i = 0;
while (i < supported_atoms->n_atoms)
{
if (supported_atoms->atoms[i] == gdk_x11_atom_to_xatom_for_display (display, property))
return TRUE;
++i;
}
return FALSE;
}
static gboolean
gdk_x11_screen_get_setting (GdkScreen *screen,
const gchar *name,
GValue *value)
{
const char *xsettings_name = NULL;
XSettingsResult result;
XSettingsSetting *setting = NULL;
GdkX11Screen *x11_screen;
gboolean success = FALSE;
gint i;
GValue tmp_val = { 0, };
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
x11_screen = GDK_X11_SCREEN (screen);
for (i = 0; i < GDK_SETTINGS_N_ELEMENTS(); i++)
if (strcmp (GDK_SETTINGS_GDK_NAME (i), name) == 0)
{
xsettings_name = GDK_SETTINGS_X_NAME (i);
break;
}
if (!xsettings_name)
goto out;
result = xsettings_client_get_setting (x11_screen->xsettings_client,
xsettings_name, &setting);
if (result != XSETTINGS_SUCCESS)
goto out;
switch (setting->type)
{
case XSETTINGS_TYPE_INT:
if (check_transform (xsettings_name, G_TYPE_INT, G_VALUE_TYPE (value)))
{
g_value_init (&tmp_val, G_TYPE_INT);
g_value_set_int (&tmp_val, setting->data.v_int);
g_value_transform (&tmp_val, value);
success = TRUE;
}
break;
case XSETTINGS_TYPE_STRING:
if (check_transform (xsettings_name, G_TYPE_STRING, G_VALUE_TYPE (value)))
{
g_value_init (&tmp_val, G_TYPE_STRING);
g_value_set_string (&tmp_val, setting->data.v_string);
g_value_transform (&tmp_val, value);
success = TRUE;
}
break;
case XSETTINGS_TYPE_COLOR:
if (!check_transform (xsettings_name, GDK_TYPE_COLOR, G_VALUE_TYPE (value)))
{
GdkColor color;
g_value_init (&tmp_val, GDK_TYPE_COLOR);
color.pixel = 0;
color.red = setting->data.v_color.red;
color.green = setting->data.v_color.green;
color.blue = setting->data.v_color.blue;
g_value_set_boxed (&tmp_val, &color);
g_value_transform (&tmp_val, value);
success = TRUE;
}
break;
}
g_value_unset (&tmp_val);
out:
if (setting)
xsettings_setting_free (setting);
if (success)
return TRUE;
else
return _gdk_x11_get_xft_setting (screen, name, value);
}
/**
* thunar_dbus_client_bulk_rename:
* @working_directory : the default working directory for the bulk rename dialog.
* @filenames : the list of files that should be displayed by default or
* the empty list to start with an empty bulk rename dialog.
* @standalone : whether to run the bulk renamer in standalone mode.
* @screen : the #GdkScreen on which to display the dialog or %NULL to
* use the default #GdkScreen.
* @error : return location for errors or %NULL.
*
* Tries to invoke the BulkRename() method on a running Thunar instance, that is
* registered with the current D-BUS session bus. Returns %TRUE if the method was
* successfully invoked, else %FALSE.
*
* If %TRUE is returned, the current process may afterwards just terminate, as
* all @filenames will be handled by the remote instance.
*
* Return value: %TRUE on success, else %FALSE.
**/
gboolean
thunar_dbus_client_bulk_rename (const gchar *working_directory,
gchar **filenames,
gboolean standalone,
GdkScreen *screen,
GError **error)
{
DBusConnection *connection;
DBusMessage *message;
DBusMessage *result;
DBusError derror;
gchar *display_name;
_thunar_return_val_if_fail (screen == NULL || GDK_IS_SCREEN (screen), FALSE);
_thunar_return_val_if_fail (g_path_is_absolute (working_directory), FALSE);
_thunar_return_val_if_fail (error == NULL || *error == NULL, FALSE);
_thunar_return_val_if_fail (filenames != NULL, FALSE);
/* initialize the DBusError struct */
dbus_error_init (&derror);
/* fallback to default screen if no other is specified */
if (G_LIKELY (screen == NULL))
screen = gdk_screen_get_default ();
/* try to connect to the session bus */
connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
if (G_UNLIKELY (connection == NULL))
{
dbus_set_g_error (error, &derror);
dbus_error_free (&derror);
return FALSE;
}
/* determine the display name for the screen */
display_name = gdk_screen_make_display_name (screen);
/* generate the BulkRename() method (disable activation!) */
message = dbus_message_new_method_call ("org.xfce.Thunar", "/org/xfce/FileManager", "org.xfce.Thunar", "BulkRename");
dbus_message_set_auto_start (message, FALSE);
dbus_message_append_args (message,
DBUS_TYPE_STRING, &working_directory,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &filenames, g_strv_length (filenames),
DBUS_TYPE_BOOLEAN, &standalone,
DBUS_TYPE_STRING, &display_name,
DBUS_TYPE_INVALID);
/* release the display name */
g_free (display_name);
/* send the message and release our references on connection and message */
result = dbus_connection_send_with_reply_and_block (connection, message, -1, &derror);
dbus_message_unref (message);
/* check if no reply was received */
if (G_UNLIKELY (result == NULL))
{
dbus_set_g_error (error, &derror);
dbus_error_free (&derror);
return FALSE;
}
/* but maybe we received an error */
if (dbus_message_get_type (result) == DBUS_MESSAGE_TYPE_ERROR)
{
dbus_set_error_from_message (&derror, result);
dbus_set_g_error (error, &derror);
dbus_message_unref (result);
dbus_error_free (&derror);
return FALSE;
}
/* let's asume that it worked */
dbus_message_unref (result);
return TRUE;
}
EggTrayIcon *egg_tray_icon_new_for_screen (GdkScreen *screen, const char *name)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
return g_object_new (EGG_TYPE_TRAY_ICON, "screen", screen, "title", name, NULL);
}
GimpDock *
gimp_session_info_dock_restore (GimpSessionInfoDock *dock_info,
GimpDialogFactory *factory,
GdkScreen *screen,
gint monitor,
GimpDockContainer *dock_container)
{
gint n_books = 0;
GtkWidget *dock;
GList *iter;
GimpUIManager *ui_manager;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
ui_manager = gimp_dock_container_get_ui_manager (dock_container);
dock = gimp_dialog_factory_dialog_new (factory,
screen,
monitor,
ui_manager,
dock_info->dock_type,
-1 /*view_size*/,
FALSE /*present*/);
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
/* Add the dock to the dock window immediately so the stuff in the
* dock has access to e.g. a dialog factory
*/
gimp_dock_container_add_dock (dock_container,
GIMP_DOCK (dock),
dock_info);
/* Note that if it is a toolbox, we will get here even though we
* don't have any books
*/
for (iter = dock_info->books;
iter;
iter = g_list_next (iter))
{
GimpSessionInfoBook *book_info = iter->data;
GtkWidget *dockbook;
dockbook = GTK_WIDGET (gimp_session_info_book_restore (book_info,
GIMP_DOCK (dock)));
if (dockbook)
{
GtkWidget *parent = gtk_widget_get_parent (dockbook);
n_books++;
if (GTK_IS_PANED (parent))
{
GtkPaned *paned = GTK_PANED (parent);
if (dockbook == gtk_paned_get_child2 (paned))
gtk_paned_set_position (paned, book_info->position);
}
}
}
/* Now remove empty dockbooks from the list, check the comment in
* gimp_session_info_book_restore() which explains why the dock
* can contain empty dockbooks at all
*/
if (dock_info->books)
{
GList *books;
books = g_list_copy (gimp_dock_get_dockbooks (GIMP_DOCK (dock)));
while (books)
{
GtkContainer *dockbook = books->data;
GList *children = gtk_container_get_children (dockbook);
if (children)
{
g_list_free (children);
}
else
{
g_object_ref (dockbook);
gimp_dock_remove_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook));
gtk_widget_destroy (GTK_WIDGET (dockbook));
g_object_unref (dockbook);
n_books--;
}
books = g_list_remove (books, dockbook);
}
}
/* if we removed all books again, the dock was destroyed, so bail out */
if (dock_info->books && n_books == 0)
{
return NULL;
}
gtk_widget_show (dock);
return GIMP_DOCK (dock);
}
/**
* thunar_dialogs_show_rename_file:
* @parent : a #GtkWidget on which the error dialog should be shown, or a #GdkScreen
* if no #GtkWidget is known. May also be %NULL, in which case the default
* #GdkScreen will be used.
* @file : the #ThunarFile we're going to rename.
*
* Displays the Thunar rename dialog for a single file rename.
*
* Return value: The #ThunarJob responsible for renaming the file or
* %NULL if there was no renaming required.
**/
ThunarJob *
thunar_dialogs_show_rename_file (gpointer parent,
ThunarFile *file)
{
ThunarIconFactory *icon_factory;
GtkIconTheme *icon_theme;
const gchar *filename;
const gchar *text;
ThunarJob *job = NULL;
GtkWidget *dialog;
GtkWidget *entry;
GtkWidget *label;
GtkWidget *image;
GtkWidget *table;
GtkWindow *window;
GdkPixbuf *icon;
GdkScreen *screen;
glong offset;
gchar *title;
gint response;
PangoLayout *layout;
gint layout_width;
gint layout_offset;
gint parent_width = 500;
_thunar_return_val_if_fail (parent == NULL || GDK_IS_SCREEN (parent) || GTK_IS_WINDOW (parent), FALSE);
_thunar_return_val_if_fail (THUNAR_IS_FILE (file), FALSE);
/* parse the parent window and screen */
screen = thunar_util_parse_parent (parent, &window);
/* get the filename of the file */
filename = thunar_file_get_display_name (file);
/* create a new dialog window */
title = g_strdup_printf (_("Rename \"%s\""), filename);
dialog = gtk_dialog_new_with_buttons (title,
window,
GTK_DIALOG_MODAL
| GTK_DIALOG_NO_SEPARATOR
| GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("_Rename"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
g_free (title);
/* move the dialog to the appropriate screen */
if (G_UNLIKELY (window == NULL && screen != NULL))
gtk_window_set_screen (GTK_WINDOW (dialog), screen);
table = g_object_new (GTK_TYPE_TABLE, "border-width", 6, "column-spacing", 6, "row-spacing", 3, NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (dialog));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
icon = thunar_icon_factory_load_file_icon (icon_factory, file, THUNAR_FILE_ICON_STATE_DEFAULT, 48);
g_object_unref (G_OBJECT (icon_factory));
image = gtk_image_new_from_pixbuf (icon);
gtk_misc_set_padding (GTK_MISC (image), 6, 6);
gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
label = gtk_label_new (_("Enter the new name:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (entry);
/* setup the old filename */
gtk_entry_set_text (GTK_ENTRY (entry), filename);
/* check if we don't have a directory here */
if (!thunar_file_is_directory (file))
{
/* check if the filename contains an extension */
text = thunar_util_str_get_extension (filename);
if (G_LIKELY (text != NULL))
{
/* grab focus to the entry first, else the selection will be altered later */
gtk_widget_grab_focus (entry);
/* determine the UTF-8 char offset */
offset = g_utf8_pointer_to_offset (filename, text);
/* select the text prior to the dot */
if (G_LIKELY (offset > 0))
gtk_editable_select_region (GTK_EDITABLE (entry), 0, offset);
}
}
/* get the size the entry requires to render the full text */
layout = gtk_entry_get_layout (GTK_ENTRY (entry));
pango_layout_get_pixel_size (layout, &layout_width, NULL);
gtk_entry_get_layout_offsets (GTK_ENTRY (entry), &layout_offset, NULL);
layout_width += (layout_offset * 2) + (12 * 4) + 48; /* 12px free space in entry */
/* parent window width */
if (G_LIKELY (window != NULL))
{
/* keep below 90% of the parent window width */
gtk_window_get_size (GTK_WINDOW (window), &parent_width, NULL);
parent_width *= 0.90f;
}
/* resize the dialog to make long names fit as much as possible */
gtk_window_set_default_size (GTK_WINDOW (dialog), CLAMP (layout_width, 300, parent_width), -1);
/* run the dialog */
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (G_LIKELY (response == GTK_RESPONSE_OK))
{
/* hide the dialog */
gtk_widget_hide (dialog);
/* determine the new filename */
text = gtk_entry_get_text (GTK_ENTRY (entry));
/* check if we have a new name here */
if (G_LIKELY (!exo_str_is_equal (filename, text)))
{
/* try to rename the file */
job = thunar_io_jobs_rename_file (file, text);
}
}
/* cleanup */
gtk_widget_destroy (dialog);
return job;
}