static VALUE
rg_m_owner_set(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE owner, selection, time, send_event;
int ret;
if (argc == 4){
rb_scan_args(argc, argv, "40", &owner, &selection, &time, &send_event);
ret = gdk_selection_owner_set(GDK_WINDOW(RVAL2GOBJ(owner)),
RVAL2ATOM(selection),
NUM2UINT(time), RVAL2CBOOL(send_event));
} else {
#if GTK_CHECK_VERSION(2,2,0)
VALUE display = Qnil;
rb_scan_args(argc, argv, "50", &display, &owner, &selection, &time, &send_event);
ret = gdk_selection_owner_set_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
GDK_WINDOW(RVAL2GOBJ(owner)),
RVAL2ATOM(selection),
NUM2UINT(time), RVAL2CBOOL(send_event));
#else
rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
#endif
}
return CBOOL2RVAL(ret);
}
void
gdk_property_delete (GdkWindow *window,
GdkAtom property)
{
g_return_if_fail (!window || GDK_IS_WINDOW (window));
if (!window)
{
GdkScreen *screen = gdk_screen_get_default ();
window = gdk_screen_get_root_window (screen);
GDK_NOTE (MULTIHEAD,
g_message ("gdk_property_delete(): window is NULL\n"));
}
if (GDK_WINDOW_DESTROYED (window))
return;
gi_atom_id_t aid;
GdkDisplay *display = GDK_DISPLAY_OBJECT(_gdk_display);
aid = gdk_x11_atom_to_xatom_for_display (display, property);
gi_delete_property ( GDK_DRAWABLE_GIX_ID (window), aid);
}
static VALUE
rg_m_send_notify(int argc, VALUE *argv, VALUE self)
{
VALUE requestor, selection, target, property, time;
if (argc == 5) {
rb_scan_args(argc, argv, "50", &requestor, &selection, &target, &property, &time);
gdk_selection_send_notify(RVAL2GDKNATIVEWINDOW(requestor), RVAL2ATOM(selection),
RVAL2ATOM(target),
NIL_P(property) ? GDK_NONE : RVAL2ATOM(property),
NUM2INT(time));
} else {
#if GTK_CHECK_VERSION(2,2,0)
VALUE display = Qnil;
rb_scan_args(argc, argv, "60", &display, &requestor, &selection, &target, &property, &time);
gdk_selection_send_notify_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2GDKNATIVEWINDOW(requestor), RVAL2ATOM(selection),
RVAL2ATOM(target),
NIL_P(property) ? GDK_NONE : RVAL2ATOM(property),
NUM2INT(time));
#else
rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
#endif
}
return self;
}
static void
gdk_display_handle_global(struct wl_display *display, uint32_t id,
const char *interface, uint32_t version, void *data)
{
GdkDisplayWayland *display_wayland = data;
GdkDisplay *gdk_display = GDK_DISPLAY_OBJECT (data);
struct wl_input_device *input;
if (strcmp(interface, "wl_compositor") == 0) {
display_wayland->compositor = wl_compositor_create(display, id, 1);
wl_compositor_add_listener(display_wayland->compositor,
&compositor_listener, display_wayland);
} else if (strcmp(interface, "wl_shm") == 0) {
display_wayland->shm = wl_shm_create(display, id, 1);
} else if (strcmp(interface, "wl_shell") == 0) {
display_wayland->shell = wl_shell_create(display, id, 1);
wl_shell_add_listener(display_wayland->shell,
&shell_listener, display_wayland);
} else if (strcmp(interface, "wl_output") == 0) {
display_wayland->output = wl_output_create(display, id, 1);
wl_output_add_listener(display_wayland->output,
&output_listener, display_wayland);
} else if (strcmp(interface, "wl_input_device") == 0) {
input = wl_input_device_create(display, id, 1);
_gdk_wayland_device_manager_add_device (gdk_display->device_manager,
input);
}
}
static void
_gdk_wayland_display_add_seat (GdkWaylandDisplay *display_wayland,
uint32_t id,
uint32_t version)
{
GdkDisplay *gdk_display = GDK_DISPLAY_OBJECT (display_wayland);
struct wl_seat *seat;
seat = wl_registry_bind (display_wayland->wl_registry,
id, &wl_seat_interface, MIN (version, 4));
_gdk_wayland_device_manager_add_seat (gdk_display->device_manager,
id, seat);
_gdk_wayland_display_async_roundtrip (display_wayland);
}
static VALUE
rg_m_owner_get(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE selection;
if (argc == 1) {
rb_scan_args(argc, argv, "10", &selection);
return GOBJ2RVAL(gdk_selection_owner_get(RVAL2ATOM(selection)));
} else {
VALUE display = Qnil;
rb_scan_args(argc, argv, "20", &display, &selection);
return GOBJ2RVAL(gdk_selection_owner_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2ATOM(selection)));
}
}
static VALUE
gdkeventclient_send_client_message(int argc, VALUE *argv, VALUE self)
{
VALUE xid, display;
rb_scan_args(argc, argv, "11", &xid, &display);
if (NIL_P(display)){
return CBOOL2RVAL(gdk_event_send_client_message(
get_gdkevent(self), RVAL2GDKNATIVEWINDOW(xid)));
} else {
return CBOOL2RVAL(gdk_event_send_client_message_for_display(
GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
get_gdkevent(self),
RVAL2GDKNATIVEWINDOW(xid)));
}
}
static VALUE
rg_m_text_property_to_utf8_list(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
gint num, i;
gchar** list;
VALUE ret = Qnil;
if (argc == 3) {
VALUE encoding, format, text;
rb_scan_args(argc, argv, "30", &encoding, &format, &text);
StringValue(text);
num = gdk_text_property_to_utf8_list(RVAL2ATOM(encoding),
NUM2INT(format),
(const guchar*)RVAL2CSTR(text),
RSTRING_LEN(text), &list);
} else {
#if GTK_CHECK_VERSION(2,2,0)
VALUE display, encoding, format, text;
rb_scan_args(argc, argv, "40", &display, &encoding, &format, &text);
StringValue(text);
num = gdk_text_property_to_utf8_list_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2ATOM(encoding),
NUM2INT(format),
(const guchar*)RVAL2CSTR(text),
RSTRING_LEN(text),
&list);
#else
VALUE encoding, format, text;
rb_scan_args(argc, argv, "30", &encoding, &format, &text);
StringValue(text);
rb_warn("Gdk::Property.text_property_to_utf8_list: Not supported arguments in GTK+-2.0.x.");
num = gdk_text_property_to_utf8_list(RVAL2ATOM(encoding),
NUM2INT(format),
(const guchar*)RVAL2CSTR(text),
RSTRING_LEN(text), &list);
#endif
}
ret = rb_ary_new2(num);
for (i =0; i < num; i++) {
rb_ary_push(ret, CSTR2RVAL(list[i]));
}
g_strfreev(list);
return ret;
}
void
_gdk_init_input_core (void)
{
GdkDisplay *display = GDK_DISPLAY_OBJECT(_gdk_display);
_gdk_core_pointer = g_object_new (GDK_TYPE_DEVICE, NULL);
_gdk_core_pointer->name = "Core Pointer";
_gdk_core_pointer->source = GDK_SOURCE_MOUSE;
_gdk_core_pointer->mode = GDK_MODE_SCREEN;
_gdk_core_pointer->has_cursor = TRUE;
_gdk_core_pointer->num_axes = 2;
_gdk_core_pointer->axes = gdk_input_core_axes;
_gdk_core_pointer->num_keys = 0;
_gdk_core_pointer->keys = NULL;
display->core_pointer = _gdk_core_pointer;
}
static VALUE
rg_m_utf8_to_compound_text(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
GdkAtom encoding;
gint format;
guchar *ctext;
gint length;
gint ret;
if (argc == 1) {
VALUE str;
rb_scan_args(argc, argv, "10", &str);
ret = gdk_utf8_to_compound_text(RVAL2CSTR(str),
&encoding, &format,
&ctext, &length);
} else {
#if GTK_CHECK_VERSION(2,2,0)
VALUE display, str;
rb_scan_args(argc, argv, "20", &display, &str);
ret = gdk_utf8_to_compound_text_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2CSTR(str),
&encoding, &format,
&ctext, &length);
#else
VALUE str;
rb_scan_args(argc, argv, "10", &str);
rb_warn("Gdk::Property.utf8_to_compound_text: Not supported arguments in GTK+-2.0.x.");
ret = gdk_utf8_to_compound_text(RVAL2CSTR(str),
&encoding, &format,
&ctext, &length);
#endif
}
if (ret) {
VALUE val = CSTR2RVAL((const char*)ctext);
gdk_free_compound_text(ctext);
return rb_ary_new3(3, BOXED2RVAL(encoding, GDK_TYPE_ATOM),
INT2NUM(format), val);
} else {
rb_raise(rb_eRuntimeError, "failed to converts a string %d\n", ret);
}
return Qnil;
}
static void
gdk_registry_handle_global(void *data, struct wl_registry *registry, uint32_t id,
const char *interface, uint32_t version)
{
GdkWaylandDisplay *display_wayland = data;
GdkDisplay *gdk_display = GDK_DISPLAY_OBJECT (data);
struct wl_seat *seat;
struct wl_output *output;
if (strcmp(interface, "wl_compositor") == 0) {
display_wayland->compositor =
wl_registry_bind(display_wayland->wl_registry, id, &wl_compositor_interface, MIN (version, 3));
display_wayland->compositor_version = MIN (version, 3);
} else if (strcmp(interface, "wl_shm") == 0) {
display_wayland->shm =
wl_registry_bind(display_wayland->wl_registry, id, &wl_shm_interface, 1);
/* SHM interface is prerequisite */
_gdk_wayland_display_load_cursor_theme(display_wayland);
} else if (strcmp(interface, "xdg_shell") == 0) {
display_wayland->xdg_shell =
wl_registry_bind(display_wayland->wl_registry, id, &xdg_shell_interface, 1);
xdg_shell_use_unstable_version(display_wayland->xdg_shell, XDG_SHELL_VERSION_CURRENT);
xdg_shell_add_listener(display_wayland->xdg_shell, &xdg_shell_listener, display_wayland);
} else if (strcmp(interface, "gtk_shell") == 0) {
display_wayland->gtk_shell =
wl_registry_bind(display_wayland->wl_registry, id, >k_shell_interface, 1);
_gdk_wayland_screen_set_has_gtk_shell (display_wayland->screen);
} else if (strcmp(interface, "wl_output") == 0) {
output =
wl_registry_bind(display_wayland->wl_registry, id, &wl_output_interface, MIN (version, 2));
_gdk_wayland_screen_add_output(display_wayland->screen, id, output, MIN (version, 2));
} else if (strcmp(interface, "wl_seat") == 0) {
seat = wl_registry_bind(display_wayland->wl_registry, id, &wl_seat_interface, 4);
_gdk_wayland_device_manager_add_seat (gdk_display->device_manager, id, seat);
} else if (strcmp(interface, "wl_data_device_manager") == 0) {
display_wayland->data_device_manager =
wl_registry_bind(display_wayland->wl_registry, id,
&wl_data_device_manager_interface, 1);
} else if (strcmp (interface, "wl_subcompositor") == 0) {
display_wayland->subcompositor =
wl_registry_bind (display_wayland->wl_registry, id,
&wl_subcompositor_interface, 1);
}
}
static void
gdk_broadway_display_finalize (GObject *object)
{
GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (object);
/* Keymap */
if (broadway_display->keymap)
g_object_unref (broadway_display->keymap);
_gdk_broadway_cursor_display_finalize (GDK_DISPLAY_OBJECT(broadway_display));
/* input GdkDevice list */
g_list_free_full (broadway_display->input_devices, g_object_unref);
/* Free all GdkScreens */
g_object_unref (broadway_display->screens[0]);
g_free (broadway_display->screens);
G_OBJECT_CLASS (gdk_broadway_display_parent_class)->finalize (object);
}
static void
gdk_registry_handle_global(void *data, struct wl_registry *registry, uint32_t id,
const char *interface, uint32_t version)
{
GdkWaylandDisplay *display_wayland = data;
GdkDisplay *gdk_display = GDK_DISPLAY_OBJECT (data);
struct wl_seat *seat;
struct wl_output *output;
if (strcmp(interface, "wl_compositor") == 0) {
display_wayland->compositor =
wl_registry_bind(display_wayland->wl_registry, id, &wl_compositor_interface, MIN (version, 3));
display_wayland->compositor_version = MIN (version, 3);
} else if (strcmp(interface, "wl_shm") == 0) {
display_wayland->shm =
wl_registry_bind(display_wayland->wl_registry, id, &wl_shm_interface, 1);
/* SHM interface is prerequisite */
_gdk_wayland_display_load_cursor_theme(display_wayland);
} else if (strcmp(interface, "wl_shell") == 0) {
display_wayland->shell =
wl_registry_bind(display_wayland->wl_registry, id, &wl_shell_interface, 1);
} else if (strcmp(interface, "wl_output") == 0) {
output =
wl_registry_bind(display_wayland->wl_registry, id, &wl_output_interface, MIN (version, 2));
_gdk_wayland_screen_add_output(display_wayland->screen, id, output, MIN (version, 2));
/* We need another roundtrip to receive the modes and geometry
* events for the output, which gives us the physical properties
* and available modes on the output. */
wait_for_roundtrip(display_wayland);
} else if (strcmp(interface, "wl_seat") == 0) {
seat = wl_registry_bind(display_wayland->wl_registry, id, &wl_seat_interface, 1);
_gdk_wayland_device_manager_add_seat (gdk_display->device_manager, id, seat);
/* We need another roundtrip to receive the wl_seat capabilities
* event which informs us of available input devices on this
* seat. */
wait_for_roundtrip(display_wayland);
} else if (strcmp(interface, "wl_data_device_manager") == 0) {
display_wayland->data_device_manager =
wl_registry_bind(display_wayland->wl_registry, id,
&wl_data_device_manager_interface, 1);
}
}
static VALUE
rg_s_get_protocol(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE xid;
GdkDragProtocol prot;
GdkNativeWindow ret;
if (argc == 1) {
rb_scan_args(argc, argv, "10", &xid);
ret = gdk_drag_get_protocol(RVAL2GDKNATIVEWINDOW(xid), &prot);
} else {
VALUE display;
rb_scan_args(argc, argv, "20", &display, &xid);
ret = gdk_drag_get_protocol_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2GDKNATIVEWINDOW(xid), &prot);
}
return rb_ary_new3(2, GENUM2RVAL(prot, GDK_TYPE_DRAG_PROTOCOL), GDKNATIVEWINDOW2RVAL(ret));
}
static VALUE
rg_m_owner_get(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE selection;
if (argc == 1) {
rb_scan_args(argc, argv, "10", &selection);
return GOBJ2RVAL(gdk_selection_owner_get(RVAL2ATOM(selection)));
} else {
#if GTK_CHECK_VERSION(2,2,0)
VALUE display = Qnil;
rb_scan_args(argc, argv, "20", &display, &selection);
return GOBJ2RVAL(gdk_selection_owner_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2ATOM(selection)));
#else
rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
#endif
}
}
static VALUE
rg_s_get(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
GtkClipboard *clipboard;
if (argc == 1){
VALUE selection;
rb_scan_args(argc, argv, "10", &selection);
clipboard = gtk_clipboard_get(RVAL2ATOM(selection));
} else {
#if GTK_CHECK_VERSION(2,2,0)
VALUE display, selection;
rb_scan_args(argc, argv, "20", &display, &selection);
clipboard = gtk_clipboard_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2ATOM(selection));
#else
rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
#endif
}
return CLIPBOARD2RVAL(clipboard);
}
static VALUE
rg_m_owner_set(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE owner, selection, time, send_event;
int ret;
if (argc == 4){
rb_scan_args(argc, argv, "40", &owner, &selection, &time, &send_event);
ret = gdk_selection_owner_set(GDK_WINDOW(RVAL2GOBJ(owner)),
RVAL2ATOM(selection),
NUM2UINT(time), RVAL2CBOOL(send_event));
} else {
VALUE display = Qnil;
rb_scan_args(argc, argv, "50", &display, &owner, &selection, &time, &send_event);
ret = gdk_selection_owner_set_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
GDK_WINDOW(RVAL2GOBJ(owner)),
RVAL2ATOM(selection),
NUM2UINT(time), RVAL2CBOOL(send_event));
}
return CBOOL2RVAL(ret);
}
static gint
tooltip_popup_timeout (gpointer data)
{
GdkDisplay *display;
GtkTooltip *tooltip;
display = GDK_DISPLAY_OBJECT (data);
tooltip = g_object_get_data (G_OBJECT (display),
"gdk-display-current-tooltip");
/* This usually does not happen. However, it does occur in language
* bindings were reference counting of objects behaves differently.
*/
if (!tooltip)
return FALSE;
gtk_tooltip_show_tooltip (display);
tooltip->timeout_id = 0;
return FALSE;
}
static VALUE
rg_m_send_notify(int argc, VALUE *argv, VALUE self)
{
VALUE requestor, selection, target, property, time;
if (argc == 5) {
rb_scan_args(argc, argv, "50", &requestor, &selection, &target, &property, &time);
gdk_selection_send_notify(RVAL2GDKNATIVEWINDOW(requestor), RVAL2ATOM(selection),
RVAL2ATOM(target),
NIL_P(property) ? GDK_NONE : RVAL2ATOM(property),
NUM2INT(time));
} else {
VALUE display = Qnil;
rb_scan_args(argc, argv, "60", &display, &requestor, &selection, &target, &property, &time);
gdk_selection_send_notify_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2GDKNATIVEWINDOW(requestor), RVAL2ATOM(selection),
RVAL2ATOM(target),
NIL_P(property) ? GDK_NONE : RVAL2ATOM(property),
NUM2INT(time));
}
return self;
}
static VALUE
gtkdrag_selection_owner_set(int argc, VALUE *argv, VALUE self)
{
gboolean ret;
if (argc == 3){
VALUE widget, selection, time;
rb_scan_args(argc, argv, "30", &widget, &selection, &time);
ret = gtk_selection_owner_set(RVAL2WIDGET(widget),
RVAL2ATOM(selection), NUM2INT(time));
} else {
#if GTK_CHECK_VERSION(2,2,0)
VALUE display, widget, selection, time;
rb_scan_args(argc, argv, "40", &display, &widget, &selection, &time);
ret = gtk_selection_owner_set_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2WIDGET(widget),
RVAL2ATOM(selection), NUM2INT(time));
#else
rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
#endif
}
return CBOOL2RVAL(ret);
}
static VALUE
rg_s_for_display(G_GNUC_UNUSED VALUE self, VALUE display)
{
return GOBJ2RVAL(gdk_keymap_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display))));
}
GdkGrabStatus
_gdk_windowing_pointer_grab (GdkWindow *window,
GdkWindow *native,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time)
{
gint return_val;
GdkCursorPrivate *cursor_private;
GdkDisplayX11 *display_x11;
guint xevent_mask;
Window xwindow;
Window xconfine_to;
Cursor xcursor;
int i;
if (confine_to)
confine_to = _gdk_window_get_impl_window (confine_to);
display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (native));
cursor_private = (GdkCursorPrivate*) cursor;
xwindow = GDK_WINDOW_XID (native);
if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))
xconfine_to = None;
else
xconfine_to = GDK_WINDOW_XID (confine_to);
if (!cursor)
xcursor = None;
else
{
_gdk_x11_cursor_update_theme (cursor);
xcursor = cursor_private->xcursor;
}
xevent_mask = 0;
for (i = 0; i < _gdk_nenvent_masks; i++)
{
if (event_mask & (1 << (i + 1)))
xevent_mask |= _gdk_event_mask_table[i];
}
/* We don't want to set a native motion hint mask, as we're emulating motion
* hints. If we set a native one we just wouldn't get any events.
*/
xevent_mask &= ~PointerMotionHintMask;
return_val = _gdk_input_grab_pointer (window,
native,
owner_events,
event_mask,
confine_to,
time);
if (return_val == GrabSuccess ||
G_UNLIKELY (!display_x11->trusted_client && return_val == AlreadyGrabbed))
{
if (!GDK_WINDOW_DESTROYED (native))
{
#ifdef G_ENABLE_DEBUG
if (_gdk_debug_flags & GDK_DEBUG_NOGRABS)
return_val = GrabSuccess;
else
#endif
return_val = XGrabPointer (GDK_WINDOW_XDISPLAY (native),
xwindow,
owner_events,
xevent_mask,
GrabModeAsync, GrabModeAsync,
xconfine_to,
xcursor,
time);
}
else
return_val = AlreadyGrabbed;
}
if (return_val == GrabSuccess)
_gdk_x11_roundtrip_async (GDK_DISPLAY_OBJECT (display_x11),
has_pointer_grab_callback,
NULL);
return gdk_x11_convert_grab_status (return_val);
}
/* Main entry point for gdk in 2.6 args are parsed
*/
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
IDirectFB *directfb;
IDirectFBDisplayLayer *layer;
IDirectFBInputDevice *keyboard;
DFBResult ret;
if (_gdk_display)
{
return GDK_DISPLAY_OBJECT (_gdk_display); /* single display only */
}
ret = DirectFBInit (NULL, NULL);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBInit", ret);
return NULL;
}
ret = DirectFBCreate (&directfb);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBCreate", ret);
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_DISPLAY_DFB, NULL);
_gdk_display->directfb = directfb;
ret = directfb->GetDisplayLayer (directfb, DLID_PRIMARY, &layer);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetDisplayLayer", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
ret = directfb->GetInputDevice (directfb, DIDID_KEYBOARD, &keyboard);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetInputDevice", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
_gdk_display->layer = layer;
_gdk_display->keyboard = keyboard;
_gdk_directfb_keyboard_init ();
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_visual_init ();
_gdk_windowing_window_init (_gdk_screen);
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init ();
_gdk_dnd_init ();
layer->EnableCursor (layer, 1);
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return GDK_DISPLAY_OBJECT (_gdk_display);
}
GdkDisplay * gdk_screen_get_display (GdkScreen *screen)
{
ENTER();
LEAVE();
return GDK_DISPLAY_OBJECT(_gdk_display);
}
