/* Sort in order of
* 1) screen
* 2) monitor
* 3) depth (for drawers)
* 4) top, bottom, left, right
* 5) strut_start ascending
* 6) strut_end descending
*/
static int
panel_struts_compare (const PanelStrut *s1,
const PanelStrut *s2)
{
int s1_depth;
int s2_depth;
if (s1->screen != s2->screen)
return gdk_x11_screen_get_screen_number (s1->screen) -
gdk_x11_screen_get_screen_number (s2->screen);
if (s1->monitor != s2->monitor)
return s1->monitor - s2->monitor;
s1_depth = get_toplevel_depth (s1->toplevel);
s2_depth = get_toplevel_depth (s2->toplevel);
if (s1_depth != s2_depth)
return s2_depth - s1_depth;
if (s1->orientation != s2->orientation)
return orientation_to_order (s1->orientation) -
orientation_to_order (s2->orientation);
if (s1->strut_start != s2->strut_start)
return s1->strut_start - s2->strut_start;
if (s1->strut_end != s2->strut_end)
return s2->strut_end - s1->strut_end;
return 0;
}
static void show_desktop_applet_realized(MatePanelApplet* applet, gpointer data)
{
ShowDesktopData* sdd;
GdkScreen* screen;
sdd = (ShowDesktopData*) data;
if (sdd->wnck_screen != NULL)
g_signal_handlers_disconnect_by_func(sdd->wnck_screen, show_desktop_changed_callback, sdd);
if (sdd->icon_theme != NULL)
g_signal_handlers_disconnect_by_func(sdd->icon_theme, theme_changed_callback, sdd);
screen = gtk_widget_get_screen(sdd->applet);
sdd->wnck_screen = wnck_screen_get(gdk_x11_screen_get_screen_number (screen));
if (sdd->wnck_screen != NULL)
wncklet_connect_while_alive(sdd->wnck_screen, "showing_desktop_changed", G_CALLBACK(show_desktop_changed_callback), sdd, sdd->applet);
else
g_warning("Could not get WnckScreen!");
show_desktop_changed_callback(sdd->wnck_screen, sdd);
sdd->icon_theme = gtk_icon_theme_get_for_screen (screen);
wncklet_connect_while_alive(sdd->icon_theme, "changed", G_CALLBACK(theme_changed_callback), sdd, sdd->applet);
update_icon (sdd);
}
static gboolean
_vte_gl_check(struct _vte_draw *draw, GtkWidget *widget)
{
int attributes[] = {_vte_gl_attributes};
XVisualInfo *visual_info;
GLXContext context = NULL;
GdkDisplay *gdisplay;
Display *display;
GdkScreen *gscreen;
int screen;
int error, event;
gboolean direct;
gdisplay = gtk_widget_get_display (widget);
display = gdk_x11_display_get_xdisplay (gdisplay);
gscreen = gtk_widget_get_screen (widget);
screen = gdk_x11_screen_get_screen_number (gscreen);
/* Check for GLX. */
if (!glXQueryExtension(display, &error, &event)) {
#ifdef VTE_DEBUG
g_warning("Unable to use GLX.\n");
#endif
return FALSE;
}
/* See if a suitable visual exists. */
visual_info = glXChooseVisual(display, screen, attributes);
if (visual_info == NULL) {
#ifdef VTE_DEBUG
g_warning("Unable to find a suitable GLX visual.\n");
#endif
return FALSE;
}
/* Create a GLX context. */
context = glXCreateContext(display, visual_info, NULL, GL_TRUE);
if (context == NULL) {
#ifdef VTE_DEBUG
g_warning("Unable to create a GLX context.\n");
#endif
return FALSE;
}
/* Check if it's a direct rendering context. */
direct = glXIsDirect(display, context);
#ifdef VTE_DEBUG
if (!direct) {
g_warning("Unable to create a direct GLX context.\n");
}
#endif
glXDestroyContext(display, context);
return (direct == True) ? TRUE : FALSE;
}
static void
_vte_gl_create(struct _vte_draw *draw, GtkWidget *widget)
{
struct _vte_gl_data *data;
int attributes[] = {_vte_gl_attributes};
GdkDisplay *gdisplay;
Display *display;
GdkScreen *gscreen;
int screen;
draw->impl_data = g_slice_new(struct _vte_gl_data);
data = (struct _vte_gl_data*) draw->impl_data;
gdisplay = gtk_widget_get_display (widget);
display = gdk_x11_display_get_xdisplay (gdisplay);
gscreen = gtk_widget_get_screen (widget);
screen = gdk_x11_screen_get_screen_number (gscreen);
data->display = display;
data->visual_info = glXChooseVisual(display, screen, attributes);
if (data->visual_info == NULL) {
g_error("Unable to find a suitable GLX visual.\n");
}
data->context = glXCreateContext(display, data->visual_info,
NULL, GL_TRUE);
if (data->context == NULL) {
g_error("Unable to create a GLX context.\n");
}
data->color.red = 0;
data->color.green = 0;
data->color.blue = 0;
data->bgpixbuf = NULL;
data->glwindow = -1;
data->scrollx = data->scrolly = 0;
data->cache = _vte_glyph_cache_new();
data->buffer = _vte_buffer_new();
gtk_widget_set_double_buffered(widget, FALSE);
draw->requires_clear = TRUE;
}
static int
get_current_desktop (GdkX11Screen *screen)
{
Display *display;
Window win;
Atom current_desktop, type;
int format;
unsigned long n_items, bytes_after;
unsigned char *data_return = NULL;
int workspace = 0;
if (!gdk_x11_screen_supports_net_wm_hint (screen,
g_intern_static_string ("_NET_CURRENT_DESKTOP")))
return workspace;
display = GDK_DISPLAY_XDISPLAY (GDK_SCREEN_DISPLAY (screen));
win = XRootWindow (display, gdk_x11_screen_get_screen_number (screen));
current_desktop = XInternAtom (display, "_NET_CURRENT_DESKTOP", True);
XGetWindowProperty (display,
win,
current_desktop,
0, G_MAXLONG,
False, XA_CARDINAL,
&type, &format, &n_items, &bytes_after,
&data_return);
if (type == XA_CARDINAL && format == 32 && n_items > 0)
workspace = ((long *) data_return)[0];
if (data_return)
XFree (data_return);
return workspace;
}
static gboolean
egg_desktop_file_launchv (EggDesktopFile *desktop_file,
GSList *documents, va_list args,
GError **error)
{
EggDesktopFileLaunchOption option;
GSList *translated_documents = NULL, *docs;
char *command, **argv;
int argc, i, screen_num;
gboolean success, current_success;
GdkDisplay *display;
char *startup_id;
GPtrArray *env = NULL;
char **variables = NULL;
GdkScreen *screen = NULL;
int workspace = -1;
const char *directory = NULL;
guint32 launch_time = (guint32)-1;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH;
GSpawnChildSetupFunc setup_func = NULL;
gpointer setup_data = NULL;
GPid *ret_pid = NULL;
int *ret_stdin = NULL, *ret_stdout = NULL, *ret_stderr = NULL;
char **ret_startup_id = NULL;
if (documents && desktop_file->document_code == 0)
{
g_set_error (error, EGG_DESKTOP_FILE_ERROR,
EGG_DESKTOP_FILE_ERROR_NOT_LAUNCHABLE,
_("Application does not accept documents on command line"));
return FALSE;
}
/* Read the options: technically it's incorrect for the caller to
* NULL-terminate the list of options (rather than 0-terminating
* it), but NULL-terminating lets us use G_GNUC_NULL_TERMINATED,
* it's more consistent with other glib/gtk methods, and it will
* work as long as sizeof (int) <= sizeof (NULL), and NULL is
* represented as 0. (Which is true everywhere we care about.)
*/
while ((option = va_arg (args, EggDesktopFileLaunchOption)))
{
switch (option)
{
case EGG_DESKTOP_FILE_LAUNCH_CLEARENV:
if (env)
g_ptr_array_free (env, TRUE);
env = g_ptr_array_new ();
break;
case EGG_DESKTOP_FILE_LAUNCH_PUTENV:
variables = va_arg (args, char **);
for (i = 0; variables[i]; i++)
env = array_putenv (env, variables[i]);
break;
case EGG_DESKTOP_FILE_LAUNCH_SCREEN:
screen = va_arg (args, GdkScreen *);
break;
case EGG_DESKTOP_FILE_LAUNCH_WORKSPACE:
workspace = va_arg (args, int);
break;
case EGG_DESKTOP_FILE_LAUNCH_DIRECTORY:
directory = va_arg (args, const char *);
break;
case EGG_DESKTOP_FILE_LAUNCH_TIME:
launch_time = va_arg (args, guint32);
break;
case EGG_DESKTOP_FILE_LAUNCH_FLAGS:
flags |= va_arg (args, GSpawnFlags);
/* Make sure they didn't set any flags that don't make sense. */
flags &= ~G_SPAWN_FILE_AND_ARGV_ZERO;
break;
case EGG_DESKTOP_FILE_LAUNCH_SETUP_FUNC:
setup_func = va_arg (args, GSpawnChildSetupFunc);
setup_data = va_arg (args, gpointer);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_PID:
ret_pid = va_arg (args, GPid *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDIN_PIPE:
ret_stdin = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDOUT_PIPE:
ret_stdout = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDERR_PIPE:
ret_stderr = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STARTUP_ID:
ret_startup_id = va_arg (args, char **);
break;
default:
g_set_error (error, EGG_DESKTOP_FILE_ERROR,
EGG_DESKTOP_FILE_ERROR_UNRECOGNIZED_OPTION,
_("Unrecognized launch option: %d"),
GPOINTER_TO_INT (option));
success = FALSE;
goto out;
}
}
if (screen)
{
display = gdk_screen_get_display (screen);
char *display_name = g_strdup (gdk_display_get_name (display));
char *display_env = g_strdup_printf ("DISPLAY=%s", display_name);
env = array_putenv (env, display_env);
g_free (display_name);
g_free (display_env);
}
else
{
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
}
screen_num = gdk_x11_screen_get_screen_number (screen);
translated_documents = translate_document_list (desktop_file, documents);
docs = translated_documents;
success = FALSE;
do
{
command = parse_exec (desktop_file, &docs, error);
if (!command)
goto out;
if (!g_shell_parse_argv (command, &argc, &argv, error))
{
g_free (command);
goto out;
}
g_free (command);
startup_id = start_startup_notification (display, desktop_file,
argv[0], screen_num,
workspace, launch_time);
if (startup_id)
{
char *startup_id_env = g_strdup_printf ("DESKTOP_STARTUP_ID=%s",
startup_id);
env = array_putenv (env, startup_id_env);
g_free (startup_id_env);
}
if (env != NULL)
g_ptr_array_add (env, NULL);
current_success =
g_spawn_async_with_pipes (directory,
argv,
env ? (char **)(env->pdata) : NULL,
flags,
setup_func, setup_data,
ret_pid,
ret_stdin, ret_stdout, ret_stderr,
error);
g_strfreev (argv);
if (startup_id)
{
if (current_success)
{
set_startup_notification_timeout (display, startup_id);
if (ret_startup_id)
*ret_startup_id = startup_id;
else
g_free (startup_id);
}
else
g_free (startup_id);
}
else if (ret_startup_id)
*ret_startup_id = NULL;
if (current_success)
{
/* If we successfully launch any instances of the app, make
* sure we return TRUE and don't set @error.
*/
success = TRUE;
error = NULL;
/* Also, only set the output params on the first one */
ret_pid = NULL;
ret_stdin = ret_stdout = ret_stderr = NULL;
ret_startup_id = NULL;
}
}
while (docs && current_success);
out:
if (env)
{
g_strfreev ((char **)env->pdata);
g_ptr_array_free (env, FALSE);
}
free_document_list (translated_documents);
return success;
}
static char *
gdk_x11_app_launch_context_get_startup_notify_id (GAppLaunchContext *context,
GAppInfo *info,
GList *files)
{
static int sequence = 0;
GdkDisplay *display;
GdkX11Screen *screen;
int files_count;
char *description;
char *icon_name;
const char *binary_name;
const char *application_id;
char *screen_str;
char *workspace_str;
GIcon *icon;
guint32 timestamp;
char *startup_id;
GFileInfo *fileinfo;
GdkAppLaunchContext *ctx;
ctx = GDK_APP_LAUNCH_CONTEXT (context);
display = ctx->display;
screen = GDK_X11_DISPLAY (display)->screen;
fileinfo = NULL;
files_count = g_list_length (files);
if (files_count == 0)
{
description = g_strdup_printf (_("Starting %s"), g_app_info_get_name (info));
}
else if (files_count == 1)
{
gchar *display_name;
if (g_file_is_native (files->data))
fileinfo = g_file_query_info (files->data,
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
G_FILE_ATTRIBUTE_STANDARD_ICON,
0, NULL, NULL);
display_name = get_display_name (files->data, fileinfo);
description = g_strdup_printf (_("Opening %s"), display_name);
g_free (display_name);
}
else
description = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE,
"Opening %d Item",
"Opening %d Items",
files_count), files_count);
icon_name = NULL;
if (ctx->icon_name)
icon_name = g_strdup (ctx->icon_name);
else
{
icon = NULL;
if (ctx->icon != NULL)
icon = g_object_ref (ctx->icon);
else if (files_count == 1)
icon = get_icon (files->data, fileinfo);
if (icon == NULL)
{
icon = g_app_info_get_icon (info);
if (icon != NULL)
g_object_ref (icon);
}
if (icon != NULL)
{
icon_name = gicon_to_string (icon);
g_object_unref (icon);
}
}
binary_name = g_app_info_get_executable (info);
timestamp = ctx->timestamp;
if (timestamp == GDK_CURRENT_TIME)
timestamp = gdk_x11_display_get_user_time (display);
screen_str = g_strdup_printf ("%d", gdk_x11_screen_get_screen_number (screen));
if (ctx->workspace > -1)
workspace_str = g_strdup_printf ("%d", ctx->workspace);
else
workspace_str = NULL;
if (G_IS_DESKTOP_APP_INFO (info))
application_id = g_desktop_app_info_get_filename (G_DESKTOP_APP_INFO (info));
else
application_id = NULL;
startup_id = g_strdup_printf ("%s-%lu-%s-%s-%d_TIME%lu",
g_get_prgname (),
(unsigned long)getpid (),
g_get_host_name (),
binary_name,
sequence++,
(unsigned long)timestamp);
gdk_x11_display_broadcast_startup_message (display, "new",
"ID", startup_id,
"NAME", g_app_info_get_name (info),
"SCREEN", screen_str,
"BIN", binary_name,
"ICON", icon_name,
"DESKTOP", workspace_str,
"DESCRIPTION", description,
"WMCLASS", NULL, /* FIXME */
"APPLICATION_ID", application_id,
NULL);
g_free (description);
g_free (screen_str);
g_free (workspace_str);
g_free (icon_name);
if (fileinfo)
g_object_unref (fileinfo);
add_startup_timeout (screen, startup_id);
return startup_id;
}
void
gdk_x11_screen_get_work_area (GdkX11Screen *x11_screen,
GdkRectangle *area)
{
Atom workarea;
Atom type;
Window win;
int format;
gulong num;
gulong leftovers;
gulong max_len = 4 * 32;
guchar *ret_workarea = NULL;
long *workareas;
int result;
int desktop;
Display *display;
display = GDK_SCREEN_XDISPLAY (x11_screen);
workarea = XInternAtom (display, "_NET_WORKAREA", True);
/* Defaults in case of error */
area->x = 0;
area->y = 0;
area->width = WidthOfScreen (x11_screen->xscreen);
area->height = HeightOfScreen (x11_screen->xscreen);
if (!gdk_x11_screen_supports_net_wm_hint (x11_screen,
g_intern_static_string ("_NET_WORKAREA")))
return;
if (workarea == None)
return;
win = XRootWindow (display, gdk_x11_screen_get_screen_number (x11_screen));
result = XGetWindowProperty (display,
win,
workarea,
0,
max_len,
False,
AnyPropertyType,
&type,
&format,
&num,
&leftovers,
&ret_workarea);
if (result != Success ||
type == None ||
format == 0 ||
leftovers ||
num % 4 != 0)
goto out;
desktop = get_current_desktop (x11_screen);
if (desktop + 1 > num / 4) /* fvwm gets this wrong */
goto out;
workareas = (long *) ret_workarea;
area->x = workareas[desktop * 4];
area->y = workareas[desktop * 4 + 1];
area->width = workareas[desktop * 4 + 2];
area->height = workareas[desktop * 4 + 3];
area->x /= x11_screen->surface_scale;
area->y /= x11_screen->surface_scale;
area->width /= x11_screen->surface_scale;
area->height /= x11_screen->surface_scale;
out:
if (ret_workarea)
XFree (ret_workarea);
}
