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); }