static gboolean
is_in_viewport (GtkWindow *window,
GdkScreen *screen,
gint workspace,
gint viewport_x,
gint viewport_y)
{
GdkScreen *s;
GdkDisplay *display;
GdkWindow *gdkwindow;
const gchar *cur_name;
const gchar *name;
gint cur_n;
gint n;
gint ws;
gint sc_width, sc_height;
gint x, y, width, height;
gint vp_x, vp_y;
/* Check for screen and display match */
display = gdk_screen_get_display (screen);
cur_name = gdk_display_get_name (display);
cur_n = gdk_screen_get_number (screen);
s = gtk_window_get_screen (window);
display = gdk_screen_get_display (s);
name = gdk_display_get_name (display);
n = gdk_screen_get_number (s);
if (strcmp (cur_name, name) != 0 || cur_n != n)
{
return FALSE;
}
/* Check for workspace match */
ws = gedit_utils_get_window_workspace (window);
if (ws != workspace && ws != GEDIT_ALL_WORKSPACES)
{
return FALSE;
}
/* Check for viewport match */
gdkwindow = gtk_widget_get_window (GTK_WIDGET (window));
gdk_window_get_position (gdkwindow, &x, &y);
width = gdk_window_get_width (gdkwindow);
height = gdk_window_get_height (gdkwindow);
gedit_utils_get_current_viewport (screen, &vp_x, &vp_y);
x += vp_x;
y += vp_y;
sc_width = gdk_screen_get_width (screen);
sc_height = gdk_screen_get_height (screen);
return x + width * .25 >= viewport_x &&
x + width * .75 <= viewport_x + sc_width &&
y >= viewport_y &&
y + height <= viewport_y + sc_height;
}
static gboolean init(LXTermWindow* lxtermwin, gint argc, gchar** argv) {
/* Normally, LXTerminal uses one process to control all of its windows.
* The first process to start will create a Unix domain socket in
* g_get_user_runtime_dir(). It will then bind and listen on this socket.
* The subsequent processes will connect to the controller that owns the
* Unix domain socket. They will pass their command line over the socket
* and exit.
*
* If for any reason both the connect and bind fail, we will fall back to
* having that process be standalone; it will not be either the controller
* or a user of the controller.
*
* This function returns TRUE if this process should keep running and FALSE
* if it should exit. */
/* Formulate the path for the Unix domain socket. */
#if GLIB_CHECK_VERSION (2, 28, 0)
gchar * socket_path = g_strdup_printf("%s/.lxterminal-socket-%s",
g_get_user_runtime_dir(),
gdk_display_get_name(gdk_display_get_default()));
#else
gchar * socket_path = g_strdup_printf("%s/.lxterminal-socket-%s",
g_get_user_cache_dir(),
gdk_display_get_name(gdk_display_get_default()));
#endif
/* Create socket. */
int fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (fd < 0) {
g_warning("Socket create failed: %s\n", g_strerror(errno));
goto err_socket;
}
/* Initialize socket address for Unix domain socket. */
struct sockaddr_un sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sun_family = AF_UNIX;
snprintf(sock_addr.sun_path, sizeof(sock_addr.sun_path), "%s", socket_path);
/* Try to connect to an existing LXTerminal process. */
if (connect(fd, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) == 0) {
g_free(socket_path);
send_msg_to_controller(fd, argc, argv);
return FALSE;
}
unlink(socket_path);
g_free(socket_path);
start_controller(&sock_addr, lxtermwin, fd);
return TRUE;
err_socket:
g_free(socket_path);
return TRUE;
}
GdkDisplay *
_gdk_win32_display_open (const gchar *display_name)
{
GdkWin32Display *win32_display;
GDK_NOTE (MISC, g_print ("gdk_display_open: %s\n", (display_name ? display_name : "NULL")));
if (display_name == NULL ||
g_ascii_strcasecmp (display_name,
gdk_display_get_name (_gdk_display)) == 0)
{
if (_gdk_display != NULL)
{
GDK_NOTE (MISC, g_print ("... return _gdk_display\n"));
return _gdk_display;
}
}
else
{
GDK_NOTE (MISC, g_print ("... return NULL\n"));
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_WIN32_DISPLAY, NULL);
win32_display = GDK_WIN32_DISPLAY (_gdk_display);
win32_display->screen = g_object_new (GDK_TYPE_WIN32_SCREEN, NULL);
_gdk_events_init (_gdk_display);
_gdk_input_ignore_core = 0;
_gdk_device_manager = g_object_new (GDK_TYPE_DEVICE_MANAGER_WIN32,
NULL);
_gdk_device_manager->display = _gdk_display;
_gdk_drag_init ();
_gdk_drop_init ();
_gdk_display->clipboard = gdk_win32_clipboard_new (_gdk_display);
_gdk_display->primary_clipboard = gdk_clipboard_new (_gdk_display);
/* Precalculate display name */
(void) gdk_display_get_name (_gdk_display);
register_display_change_notification (_gdk_display);
g_signal_emit_by_name (_gdk_display, "opened");
GDK_NOTE (MISC, g_print ("... _gdk_display now set up\n"));
return _gdk_display;
}
GSource *
gdk_x11_event_source_new (GdkDisplay *display)
{
GSource *source;
GdkEventSource *event_source;
GdkX11Display *display_x11;
int connection_number;
char *name;
source = g_source_new (&event_funcs, sizeof (GdkEventSource));
name = g_strdup_printf ("GDK X11 Event source (%s)",
gdk_display_get_name (display));
g_source_set_name (source, name);
g_free (name);
event_source = (GdkEventSource *) source;
event_source->display = display;
display_x11 = GDK_X11_DISPLAY (display);
connection_number = ConnectionNumber (display_x11->xdisplay);
event_source->event_poll_fd.fd = connection_number;
event_source->event_poll_fd.events = G_IO_IN;
g_source_add_poll (source, &event_source->event_poll_fd);
g_source_set_priority (source, GDK_PRIORITY_EVENTS);
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
event_sources = g_list_prepend (event_sources, source);
return source;
}
static gboolean
osk_audio_init_canberra(OskAudio* audio)
{
GdkScreen* screen;
ca_proplist* props;
const char* name;
int nr;
if (ca_context_create(&audio->ca) != CA_SUCCESS)
return FALSE;
screen = gdk_screen_get_default();
nr = gdk_screen_get_number(screen);
name = gdk_display_get_name(gdk_screen_get_display(screen));
/* Set default application properties */
ca_proplist_create(&props);
ca_proplist_sets(props, CA_PROP_APPLICATION_NAME, "Onboard");
ca_proplist_sets(props, CA_PROP_APPLICATION_ID, "org.onboard.Onboard");
ca_proplist_sets(props, CA_PROP_APPLICATION_ICON_NAME, "onboard");
ca_proplist_sets(props, CA_PROP_WINDOW_X11_DISPLAY, name);
ca_proplist_setf(props, CA_PROP_WINDOW_X11_SCREEN, "%i", nr);
ca_context_change_props_full(audio->ca, props);
ca_proplist_destroy(props);
return TRUE;
}
static void
on_display_monitor_added (GdkDisplay *display,
GdkMonitor *monitor,
GSManager *manager)
{
GSList *l;
int n_monitors;
n_monitors = gdk_display_get_n_monitors (display);
gs_debug ("Monitor added on display %s, now there are %d",
gdk_display_get_name (display), n_monitors);
/* Tear down the unlock dialog in case we want to move it
* to the new monitor
*/
l = manager->priv->windows;
while (l != NULL)
{
gs_window_cancel_unlock_request (GS_WINDOW (l->data));
l = l->next;
}
/* add a new window */
gs_manager_create_window_for_monitor (manager, monitor);
/* and put unlock dialog up whereever it's supposed to be */
gs_manager_request_unlock (manager);
}
static void
gs_manager_create_windows_for_display (GSManager *manager,
GdkDisplay *display)
{
int n_monitors;
int i;
g_return_if_fail (manager != NULL);
g_return_if_fail (GS_IS_MANAGER (manager));
g_return_if_fail (GDK_IS_DISPLAY (display));
g_object_ref (manager);
g_object_ref (display);
n_monitors = gdk_display_get_n_monitors (display);
gs_debug ("Creating %d windows for display %s",
n_monitors, gdk_display_get_name (display));
for (i = 0; i < n_monitors; i++)
{
GdkMonitor *mon = gdk_display_get_monitor (display, i);
gs_manager_create_window_for_monitor (manager, mon);
}
g_object_unref (display);
g_object_unref (manager);
}
gboolean
totem_display_is_local (void)
{
const char *name, *work;
int display, screen;
gboolean has_hostname;
name = gdk_display_get_name (gdk_display_get_default ());
if (name == NULL)
return TRUE;
work = strstr (name, ":");
if (work == NULL)
return TRUE;
has_hostname = (work - name) > 0;
/* Get to the character after the colon */
work++;
if (*work == '\0')
return TRUE;
if (sscanf (work, "%d.%d", &display, &screen) != 2)
return TRUE;
if (has_hostname == FALSE)
return TRUE;
if (display < 10)
return TRUE;
return FALSE;
}
GdkDisplay *
_gdk_win32_display_open (const gchar *display_name)
{
GdkWin32Display *win32_display;
GDK_NOTE (MISC, g_print ("gdk_display_open: %s\n", (display_name ? display_name : "NULL")));
if (display_name == NULL ||
g_ascii_strcasecmp (display_name,
gdk_display_get_name (_gdk_display)) == 0)
{
if (_gdk_display != NULL)
{
GDK_NOTE (MISC, g_print ("... return _gdk_display\n"));
return _gdk_display;
}
}
else
{
GDK_NOTE (MISC, g_print ("... return NULL\n"));
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_WIN32_DISPLAY, NULL);
win32_display = GDK_WIN32_DISPLAY (_gdk_display);
win32_display->screen = g_object_new (GDK_TYPE_WIN32_SCREEN, NULL);
_gdk_monitor_init ();
_gdk_visual_init (win32_display->screen);
_gdk_screen_init_root_window (GDK_WIN32_SCREEN (win32_display->screen));
_gdk_events_init ();
_gdk_input_init (_gdk_display);
_gdk_dnd_init ();
/* Precalculate display name */
(void) gdk_display_get_name (_gdk_display);
register_display_change_notification (_gdk_display);
g_signal_emit_by_name (_gdk_display, "opened");
GDK_NOTE (MISC, g_print ("... _gdk_display now set up\n"));
return _gdk_display;
}
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
GDK_NOTE (MISC, g_print ("gdk_display_open: %s\n", (display_name ? display_name : "NULL")));
if (display_name == NULL ||
g_ascii_strcasecmp (display_name,
gdk_display_get_name (_gdk_display)) == 0)
{
if (_gdk_display != NULL)
{
GDK_NOTE (MISC, g_print ("... return _gdk_display\n"));
return _gdk_display;
}
}
else
{
GDK_NOTE (MISC, g_print ("... return NULL\n"));
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_monitor_init ();
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init (_gdk_display);
_gdk_dnd_init ();
/* Precalculate display name */
(void) gdk_display_get_name (_gdk_display);
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
GDK_NOTE (MISC, g_print ("... _gdk_display now set up\n"));
return _gdk_display;
}
static gchar *
gdk_x11_screen_make_display_name (GdkScreen *screen)
{
const gchar *old_display;
old_display = gdk_display_get_name (gdk_screen_get_display (screen));
return substitute_screen_number (old_display,
gdk_screen_get_number (screen));
}
static GSWindow *
find_window_at_pointer (GSManager *manager)
{
GdkDisplay *display;
GdkDevice *device;
GdkMonitor *monitor;
int x, y;
GSWindow *window;
GSList *l;
display = gdk_display_get_default ();
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
gdk_device_get_position (device, NULL, &x, &y);
monitor = gdk_display_get_monitor_at_point (display, x, y);
/* Find the gs-window that is on that monitor */
window = NULL;
for (l = manager->priv->windows; l; l = l->next)
{
GSWindow *win = GS_WINDOW (l->data);
if (gs_window_get_display (win) == display &&
gs_window_get_monitor (win) == monitor)
{
window = win;
}
}
if (window == NULL)
{
gs_debug ("WARNING: Could not find the GSWindow for display %s",
gdk_display_get_name (display));
/* take the first one */
window = manager->priv->windows->data;
}
else
{
gs_debug ("Requesting unlock for display %s",
gdk_display_get_name (display));
}
return window;
}
static gchar *
gdk_x11_screen_make_display_name (GdkScreen *screen)
{
const gchar *old_display;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
old_display = gdk_display_get_name (gdk_screen_get_display (screen));
return substitute_screen_number (old_display,
gdk_screen_get_number (screen));
}
static cairo_surface_t *
create_root_surface (GdkScreen *screen)
{
Atom prop_root, prop_esetroot;
gint number, width, height;
Display *display;
Pixmap pixmap;
cairo_surface_t *surface;
number = gdk_screen_get_number (screen);
width = gdk_screen_get_width (screen);
height = gdk_screen_get_height (screen);
/* Open a new connection so with Retain Permanent so the pixmap remains when the greeter quits */
gdk_flush ();
display = XOpenDisplay (gdk_display_get_name (gdk_screen_get_display (screen)));
if (!display)
{
g_warning ("Failed to create root pixmap");
return NULL;
}
XSetCloseDownMode (display, RetainPermanent);
pixmap = XCreatePixmap (display, RootWindow (display, number), width, height, DefaultDepth (display, number));
XCloseDisplay (display);
/* Convert into a Cairo surface */
surface = cairo_xlib_surface_create (GDK_SCREEN_XDISPLAY (screen),
pixmap,
GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (screen)),
width, height);
/* Use this pixmap for the background */
XSetWindowBackgroundPixmap (GDK_SCREEN_XDISPLAY (screen),
RootWindow (GDK_SCREEN_XDISPLAY (screen), number),
cairo_xlib_surface_get_drawable (surface));
/* Fix to make the code work when a compositor is running */
Pixmap xpm = cairo_xlib_surface_get_drawable (surface);
prop_root = XInternAtom(GDK_SCREEN_XDISPLAY (screen), "_XROOTPMAP_ID", False);
prop_esetroot = XInternAtom(GDK_SCREEN_XDISPLAY (screen), "ESETROOT_PMAP_ID", False);
XChangeProperty(GDK_SCREEN_XDISPLAY (screen), RootWindow (GDK_SCREEN_XDISPLAY (screen), number), prop_root, XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &xpm, 1);
XChangeProperty(GDK_SCREEN_XDISPLAY (screen), RootWindow (GDK_SCREEN_XDISPLAY (screen), number), prop_esetroot, XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &xpm, 1);
return surface;
}
static gchar *
gdk_app_launch_context_get_display (GAppLaunchContext *context,
GAppInfo *info,
GList *files)
{
GdkAppLaunchContext *ctx = GDK_APP_LAUNCH_CONTEXT (context);
GdkDisplay *display;
if (ctx->display)
display = ctx->display;
else
display = gdk_display_get_default ();
return g_strdup (gdk_display_get_name (display));
}
/* Adds a new display to our list of displays, and connects
* to the "closed" signal so that we can remove it from the
* list of displays again.
*/
static void
add_display (ChangeDisplayInfo *info,
GdkDisplay *display)
{
const gchar *name = gdk_display_get_name (display);
GtkTreeIter iter;
gtk_list_store_append (GTK_LIST_STORE (info->display_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (info->display_model), &iter,
DISPLAY_COLUMN_NAME, name,
DISPLAY_COLUMN_DISPLAY, display,
-1);
g_signal_connect (display, "closed",
G_CALLBACK (display_closed_cb), info);
}
static gboolean
remmina_plugin_nx_start_create_notify (RemminaProtocolWidget *gp)
{
RemminaPluginNxData *gpdata;
gpdata = (RemminaPluginNxData*) g_object_get_data (G_OBJECT (gp), "plugin-data");
gpdata->display = XOpenDisplay (gdk_display_get_name (gdk_display_get_default ()));
if (gpdata->display == NULL) return FALSE;
gpdata->orig_handler = XSetErrorHandler (remmina_plugin_nx_dummy_handler);
XSelectInput (gpdata->display, XDefaultRootWindow (gpdata->display), SubstructureNotifyMask);
return TRUE;
}
static gboolean
_clutter_backend_gdk_post_parse (ClutterBackend *backend,
GError **error)
{
ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend);
if (_foreign_dpy != NULL)
backend_gdk->display = _foreign_dpy;
/* Init Gdk, if outside code did not already */
if (!gdk_init_check (NULL, NULL))
return FALSE;
/*
* Only open connection if not already set by prior call to
* clutter_gdk_set_display()
*/
if (backend_gdk->display == NULL)
backend_gdk->display = g_object_ref (gdk_display_get_default ());
g_assert (backend_gdk->display != NULL);
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (backend_gdk->display))
{
/* Cogl needs to know the Xlib display connection for
CoglTexturePixmapX11 */
cogl_xlib_set_display (gdk_x11_display_get_xdisplay (backend_gdk->display));
}
#endif
backend_gdk->screen = gdk_display_get_default_screen (backend_gdk->display);
/* add event filter for Cogl events */
gdk_window_add_filter (NULL, cogl_gdk_filter, NULL);
clutter_backend_gdk_init_settings (backend_gdk);
CLUTTER_NOTE (BACKEND,
"Gdk Display '%s' opened",
gdk_display_get_name (backend_gdk->display));
return TRUE;
}
void
setup_environment (void)
{
const gchar *lang;
const gchar *sm;
gchar *authfile;
int fd;
/* check that no other session manager is running */
sm = g_getenv ("SESSION_MANAGER");
if (sm != NULL && strlen (sm) > 0)
{
fprintf (stderr, "xfce4-session: Another session manager is already running\n");
exit (EXIT_FAILURE);
}
/* check if running in verbose mode */
if (g_getenv ("XFSM_VERBOSE") != NULL)
xfsm_enable_verbose ();
/* pass correct DISPLAY to children, in case of --display in argv */
xfce_setenv ("DISPLAY", gdk_display_get_name (gdk_display_get_default ()), TRUE);
/* this is for compatibility with the GNOME Display Manager */
lang = g_getenv ("GDM_LANG");
if (lang != NULL)
{
xfce_setenv ("LANG", lang, TRUE);
xfce_unsetenv ("GDM_LANG");
}
/* check access to $HOME/.ICEauthority */
authfile = xfce_get_homefile (".ICEauthority", NULL);
fd = open (authfile, O_RDWR | O_CREAT, 0600);
if (fd < 0)
{
fprintf (stderr, "xfce4-session: Unable to access file %s: %s\n",
authfile, g_strerror (errno));
exit (EXIT_FAILURE);
}
g_free (authfile);
close (fd);
}
static gchar *
gdk_app_launch_context_get_display (GAppLaunchContext *context,
GAppInfo *info,
GList *files)
{
GdkDisplay *display;
GdkAppLaunchContextPrivate *priv;
priv = GDK_APP_LAUNCH_CONTEXT (context)->priv;
if (priv->screen)
return gdk_screen_make_display_name (priv->screen);
if (priv->display)
display = priv->display;
else
display = gdk_display_get_default ();
return g_strdup (gdk_display_get_name (display));
}
static void
window_menu_display_closed (GdkDisplay *display,
gboolean is_error,
GimpUIManager *manager)
{
const gchar *display_name;
gchar *merge_key;
guint merge_id;
display_name = gdk_display_get_name (display);
if (! display_name)
display_name = "eek";
merge_key = g_strdup_printf ("%s-display-merge-id", display_name);
merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
merge_key));
g_free (merge_key);
if (merge_id)
gtk_ui_manager_remove_ui (GTK_UI_MANAGER (manager), merge_id);
}
static char * get_display_string(visualizer_t * v)
{
char * ret;
GdkDisplay * dpy;
/* Get the display string */
gtk_widget_realize(v->normal_window.socket);
gtk_widget_realize(v->fullscreen_window.socket);
dpy = gdk_display_get_default();
// ret = bg_sprintf("%s:%08lx:%08lx", gdk_display_get_name(dpy),
// GDK_WINDOW_XID(v->normal_window.window->window),
// GDK_WINDOW_XID(v->fullscreen_window.window->window));
ret =
bg_sprintf("%s:%08lx:%08lx", gdk_display_get_name(dpy),
(long unsigned int)gtk_socket_get_id(GTK_SOCKET(v->normal_window.socket)),
(long unsigned int)gtk_socket_get_id(GTK_SOCKET(v->fullscreen_window.socket)));
return ret;
}
GdkMirEventSource *
_gdk_mir_event_source_new (GdkDisplay *display)
{
GdkMirEventSource *source;
GSource *g_source;
char *name;
g_source = g_source_new (&gdk_mir_event_source_funcs, sizeof (GdkMirEventSource));
name = g_strdup_printf ("GDK Mir Event source (%s)", gdk_display_get_name (display));
g_source_set_name (g_source, name);
g_free (name);
g_source_set_priority (g_source, GDK_PRIORITY_EVENTS);
g_source_set_can_recurse (g_source, TRUE);
g_source_attach (g_source, NULL);
source = (GdkMirEventSource *) g_source;
g_mutex_init (&source->mir_event_lock);
source->display = display;
source->log_events = (g_getenv ("GDK_MIR_LOG_EVENTS") != NULL);
return source;
}
static GdkDisplay *
display_open_if_needed (const gchar *name)
{
GSList *displays;
GSList *l;
GdkDisplay *display = NULL;
displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
for (l = displays; l != NULL; l = l->next)
{
if (strcmp (gdk_display_get_name ((GdkDisplay *) l->data), name) == 0)
{
display = l->data;
break;
}
}
g_slist_free (displays);
return display != NULL ? display : gdk_display_open (name);
}
static void
bus_test_client_class_init (BusTestClientClass *klass)
{
IDEBUG ("%s", __FUNCTION__);
IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass);
ibus_object_class->destroy = bus_test_client_destroy;
/* init display object */
if (_xdisplay == NULL) {
_xdisplay = XOpenDisplay (gdk_display_get_name (gdk_display_get_default ()));
}
/* init bus object */
if (_bus == NULL) {
ibus_set_display (XDisplayString (_xdisplay));
_bus = ibus_bus_new();
}
g_signal_connect (_bus, "disconnected", G_CALLBACK (_bus_disconnected_cb), NULL);
}
static void
on_display_monitor_removed (GdkDisplay *display,
GdkMonitor *monitor,
GSManager *manager)
{
GSList *l;
int n_monitors;
n_monitors = gdk_display_get_n_monitors (display);
gs_debug ("Monitor removed on display %s, now there are %d",
gdk_display_get_name (display), n_monitors);
gdk_x11_grab_server ();
/* remove the now extra window */
l = manager->priv->windows;
while (l != NULL)
{
GdkDisplay *this_display;
GdkMonitor *this_monitor;
GSList *next = l->next;
this_display = gs_window_get_display (GS_WINDOW (l->data));
this_monitor = gs_window_get_monitor (GS_WINDOW (l->data));
if (this_display == display && this_monitor == monitor)
{
manager_maybe_stop_job_for_window (manager,
GS_WINDOW (l->data));
g_hash_table_remove (manager->priv->jobs, l->data);
gs_window_destroy (GS_WINDOW (l->data));
manager->priv->windows = g_slist_delete_link (manager->priv->windows, l);
}
l = next;
}
gdk_display_flush (display);
gdk_x11_ungrab_server ();
}
GSource *
_gdk_broadway_event_source_new (GdkDisplay *display)
{
GSource *source;
GdkEventSource *event_source;
char *name;
source = g_source_new (&event_funcs, sizeof (GdkEventSource));
name = g_strdup_printf ("GDK Broadway Event source (%s)",
gdk_display_get_name (display));
g_source_set_name (source, name);
g_free (name);
event_source = (GdkEventSource *) source;
event_source->display = display;
g_source_set_priority (source, GDK_PRIORITY_EVENTS);
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
event_sources = g_list_prepend (event_sources, source);
return source;
}
static char *
get_display_number (void)
{
const char *display_name;
char *retval;
char *p;
display_name = gdk_display_get_name (gdk_display_get_default ());
p = strchr (display_name, ':');
if (!p)
return g_strdup ("0");
while (*p == ':') p++;
retval = g_strdup (p);
p = strchr (retval, '.');
if (p != NULL)
*p = '\0';
return retval;
}
gchar *
gdk_screen_make_display_name (GdkScreen *screen)
{
return g_strdup (gdk_display_get_name (_gdk_display));
}
/* clientside */
static void
send_bacon_message (void)
{
GdkScreen *screen;
GdkDisplay *display;
const gchar *display_name;
gint screen_number;
gint ws;
gint viewport_x;
gint viewport_y;
GString *command;
/* the messages have the following format:
* <--- header ---> <---- body ----->
* timestamp \t display_name \t screen_number \t workspace \t viewport_x \t viewport_y \v OP1 \t arg \t arg \v OP2 \t arg \t arg|...
*
* when the arg is a list of uri, they are separated by a space.
* So the delimiters are \v for the commands, \t for the tokens in
* a command and ' ' for the uris: note that such delimiters cannot
* be part of an uri, this way parsing is easier.
*/
pluma_debug (DEBUG_APP);
screen = gdk_screen_get_default ();
display = gdk_screen_get_display (screen);
display_name = gdk_display_get_name (display);
screen_number = gdk_screen_get_number (screen);
pluma_debug_message (DEBUG_APP, "Display: %s", display_name);
pluma_debug_message (DEBUG_APP, "Screen: %d", screen_number);
ws = pluma_utils_get_current_workspace (screen);
pluma_utils_get_current_viewport (screen, &viewport_x, &viewport_y);
command = g_string_new (NULL);
/* header */
g_string_append_printf (command,
"%" G_GUINT32_FORMAT "\t%s\t%d\t%d\t%d\t%d",
startup_timestamp,
display_name,
screen_number,
ws,
viewport_x,
viewport_y);
/* NEW-WINDOW command */
if (new_window_option)
{
command = g_string_append_c (command, '\v');
command = g_string_append (command, "NEW-WINDOW");
}
/* NEW-DOCUMENT command */
if (new_document_option)
{
command = g_string_append_c (command, '\v');
command = g_string_append (command, "NEW-DOCUMENT");
}
/* OPEN_URIS command, optionally specify line_num and encoding */
if (file_list)
{
GSList *l;
command = g_string_append_c (command, '\v');
command = g_string_append (command, "OPEN-URIS");
g_string_append_printf (command,
"\t%d\t%s\t%u\t",
line_position,
encoding_charset ? encoding_charset : "",
g_slist_length (file_list));
for (l = file_list; l != NULL; l = l->next)
{
gchar *uri;
uri = g_file_get_uri (G_FILE (l->data));
command = g_string_append (command, uri);
if (l->next != NULL)
command = g_string_append_c (command, ' ');
g_free (uri);
}
}
pluma_debug_message (DEBUG_APP, "Bacon Message: %s", command->str);
bacon_message_connection_send (connection,
command->str);
g_string_free (command, TRUE);
}
