static void attach_jobject (GdkWindow *window, jobject *obj) { GdkAtom addr_atom = gdk_atom_intern ("_GNU_GTKAWT_ADDR", FALSE); GdkAtom type_atom = gdk_atom_intern ("CARDINAL", FALSE); gdk_window_set_events (window, gdk_window_get_events (window) | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_STRUCTURE_MASK | GDK_KEY_PRESS_MASK | GDK_FOCUS_CHANGE_MASK); // g_print("storing obj %p property on window %p\n", obj, window); gdk_property_change (window, addr_atom, type_atom, 8, GDK_PROP_MODE_REPLACE, (guchar *)obj, sizeof (jobject)); }
/* title_on_screen_changed */ static void _title_on_screen_changed(GtkWidget * widget, GdkScreen * previous, gpointer data) { Title * title = data; GdkEventMask events; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif if(title->root != NULL) gdk_window_remove_filter(title->root, _title_on_filter, title); title->screen = gtk_widget_get_screen(widget); title->display = gdk_screen_get_display(title->screen); title->root = gdk_screen_get_root_window(title->screen); events = gdk_window_get_events(title->root); gdk_window_set_events(title->root, events | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(title->root, _title_on_filter, title); title->atom_active = gdk_x11_get_xatom_by_name_for_display( title->display, "_NET_ACTIVE_WINDOW"); title->atom_name = gdk_x11_get_xatom_by_name_for_display( title->display, "_NET_WM_NAME"); title->atom_utf8_string = gdk_x11_get_xatom_by_name_for_display( title->display, "UTF8_STRING"); title->atom_visible_name = gdk_x11_get_xatom_by_name_for_display( title->display, "_NET_WM_VISIBLE_NAME"); _title_do(title); }
// this function will make sure that everything has been initialized. nsresult nsScreenManagerGtk :: EnsureInit() { if (mCachedScreenArray.Count() > 0) return NS_OK; #if GTK_CHECK_VERSION(2,2,0) mRootWindow = gdk_get_default_root_window(); #else mRootWindow = GDK_ROOT_PARENT(); #endif // GTK_CHECK_VERSION(2,2,0) g_object_ref(mRootWindow); // GDK_STRUCTURE_MASK ==> StructureNotifyMask, for ConfigureNotify // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify gdk_window_set_events(mRootWindow, GdkEventMask(gdk_window_get_events(mRootWindow) | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK)); gdk_window_add_filter(mRootWindow, root_window_event_filter, this); #ifdef MOZ_X11 mNetWorkareaAtom = XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow), "_NET_WORKAREA", False); #endif return Init(); }
/* on_screen_changed */ static void _on_screen_changed(GtkWidget * widget, GdkScreen * previous, gpointer data) { Close * close = data; GdkWindow * window; GdkEventMask events; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif close->screen = gtk_widget_get_screen(widget); close->display = gdk_screen_get_display(close->screen); close->root = gdk_screen_get_root_window(close->screen); close->panel = ((window = gtk_widget_get_parent_window(widget)) != NULL) ? GDK_WINDOW_XID(window) : None; events = gdk_window_get_events(close->root); gdk_window_set_events(close->root, events | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(close->root, _on_filter, close); close->atom_active = gdk_x11_get_xatom_by_name_for_display( close->display, "_NET_ACTIVE_WINDOW"); close->atom_close = gdk_x11_get_xatom_by_name_for_display( close->display, "_NET_CLOSE_WINDOW"); _close_do(close); }
static GtkWidget *create_video_window(LinphoneCall *call){ char *remote,*title; GtkWidget *video_window; const LinphoneAddress *addr; guint timeout; MSVideoSize vsize={MS_VIDEO_SIZE_CIF_W,MS_VIDEO_SIZE_CIF_H}; GdkColor color; addr=linphone_call_get_remote_address(call); remote=linphone_gtk_address(addr); video_window=gtk_window_new(GTK_WINDOW_TOPLEVEL); /*gtk_window_set_transient_for(GTK_WINDOW(video_window), GTK_WINDOW(linphone_gtk_get_main_window()));*/ title=g_strdup_printf("%s - Video call with %s",linphone_gtk_get_ui_config("title","Linphone"),remote); ms_free(remote); gtk_window_set_title(GTK_WINDOW(video_window),title); g_free(title); gtk_window_resize(GTK_WINDOW(video_window),vsize.width,vsize.height); gdk_color_parse("black",&color); gtk_widget_modify_bg(video_window,GTK_STATE_NORMAL,&color); gtk_drag_dest_set(video_window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(GtkTargetEntry), GDK_ACTION_COPY); gtk_widget_show(video_window); gdk_window_set_events(gtk_widget_get_window(video_window), gdk_window_get_events(gtk_widget_get_window(video_window)) | GDK_POINTER_MOTION_MASK); timeout=g_timeout_add(500,(GSourceFunc)resize_video_window,call); g_signal_connect(video_window,"destroy",(GCallback)on_video_window_destroy,GINT_TO_POINTER(timeout)); g_signal_connect(video_window,"key-press-event",(GCallback)on_video_window_key_press,NULL); g_signal_connect_swapped(video_window,"motion-notify-event",(GCallback)show_video_controls,video_window); g_signal_connect(video_window,"configure-event",(GCallback)video_window_moved,NULL); g_signal_connect(video_window, "drag-data-received",(GCallback)drag_data_received, NULL); g_signal_connect(video_window, "drag-drop",(GCallback)drag_drop, NULL); g_object_set_data(G_OBJECT(video_window),"call",call); return video_window; }
// this function will make sure that everything has been initialized. nsresult nsScreenManagerGtk :: EnsureInit() { if (mCachedScreenArray.Count() > 0) return NS_OK; mRootWindow = gdk_get_default_root_window(); if (!mRootWindow) { // Sometimes we don't initial X (e.g., xpcshell) return NS_OK; } g_object_ref(mRootWindow); // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify gdk_window_set_events(mRootWindow, GdkEventMask(gdk_window_get_events(mRootWindow) | GDK_PROPERTY_CHANGE_MASK)); g_signal_connect(gdk_screen_get_default(), "monitors-changed", G_CALLBACK(monitors_changed), this); #ifdef MOZ_X11 gdk_window_add_filter(mRootWindow, root_window_event_filter, this); if (GDK_IS_X11_DISPLAY(gdk_display_get_default())) mNetWorkareaAtom = XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow), "_NET_WORKAREA", False); #endif return Init(); }
JNIEXPORT jint JNICALL Java_org_gnome_gdk_GdkWindow_gdk_1window_1get_1events ( JNIEnv* env, jclass cls, jlong _self ) { GdkEventMask result; jint _result; GdkWindow* self; // convert parameter self self = (GdkWindow*) _self; // call function result = gdk_window_get_events(self); // cleanup parameter self // translate return value to JNI type _result = (jint) result; // and finally return _result; }
/* * Set up a shape to call cow_clicked when it's clicked. */ static void close_when_clicked(float_shape_t *shape) { GdkEventMask events = gdk_window_get_events(shape_window(shape)->window); events |= GDK_BUTTON_PRESS_MASK; gdk_window_set_events(shape_window(shape)->window, events); g_signal_connect(G_OBJECT(shape_window(shape)), "button-press-event", G_CALLBACK(cow_clicked), NULL); }
static void matenu_settings_real_attach_to_window (MatenuSettings* self, GdkWindow* window) { GdkEventMask events; g_return_if_fail (self != NULL); if (self->priv->_window != NULL) { gdk_window_remove_filter (window, _matenu_settings_event_filter_gdk_filter_func, self); } if (window == NULL) { return; } matenu_settings_set_window (self, window); gdk_window_add_filter (self->priv->_window, _matenu_settings_event_filter_gdk_filter_func, self); events = gdk_window_get_events (self->priv->_window); gdk_window_set_events (self->priv->_window, events | GDK_PROPERTY_CHANGE_MASK); matenu_settings_pull (self); }
static void tbo_drawing_realize (GtkWidget *widget) { GdkWindow *bin_window; if (GTK_WIDGET_CLASS (tbo_drawing_parent_class)->realize) (* GTK_WIDGET_CLASS (tbo_drawing_parent_class)->realize) (widget); bin_window = gtk_layout_get_bin_window (GTK_LAYOUT (widget)); gdk_window_set_events (bin_window, (gdk_window_get_events (bin_window) | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK)); }
static void initialize_root_window (HDDesktop *desktop) { HDDesktopPrivate *priv = desktop->priv; priv->root_window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), gdk_x11_get_default_root_xwindow ()); gdk_window_set_events (priv->root_window, gdk_window_get_events (priv->root_window) | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter (priv->root_window, filter_property_changed, desktop); }
static void mate_rr_labeler_init (MateRRLabeler *labeler) { GdkWindow *gdkwindow; labeler->priv = G_TYPE_INSTANCE_GET_PRIVATE (labeler, MATE_TYPE_RR_LABELER, MateRRLabelerPrivate); labeler->priv->workarea_atom = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "_NET_WORKAREA", True); labeler->priv->screen = gdk_screen_get_default (); /* code is not really designed to handle multiple screens so *shrug* */ gdkwindow = gdk_screen_get_root_window (labeler->priv->screen); gdk_window_add_filter (gdkwindow, (GdkFilterFunc) screen_xevent_filter, labeler); gdk_window_set_events (gdkwindow, gdk_window_get_events (gdkwindow) | GDK_PROPERTY_CHANGE_MASK); }
/** * Get the events that the underlying GdkWindow receives. */ JNIEXPORT jint JNICALL Java_org_gnome_gtk_GtkWidgetOverride_gtk_1widget_1get_1events ( JNIEnv* env, jclass cls, jlong _self ) { GtkWidget* self; GdkWindow* window; GdkEventMask mask; // convert parameter self self = (GtkWidget*) _self; window = gtk_widget_get_window(self); mask = gdk_window_get_events(window); return (jint) mask; }
/* * Standard Gtk+ function */ static void Dw_gtk_viewport_realize (GtkWidget *widget) { GtkDwViewport *viewport; GTK_WIDGET_CLASS(parent_class)->realize (widget); gdk_window_set_events (widget->window, gdk_window_get_events (widget->window) | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK); viewport = GTK_DW_VIEWPORT (widget); gdk_window_get_geometry (widget->window, NULL, NULL, NULL, NULL, &viewport->depth); Dw_gtk_viewport_update_background (viewport); if (viewport->child) Dw_widget_update_cursor (viewport->child); }
/** * hildon_program_add_window: * @self: The @HildonProgram to which the window should be registered * @window: A @HildonWindow to be added * * Registers a @HildonWindow as belonging to a given @HildonProgram. This * allows to apply program-wide settings as all the registered windows, * such as hildon_program_set_common_menu() and * hildon_pogram_set_common_toolbar() **/ void hildon_program_add_window (HildonProgram *self, HildonWindow *window) { HildonProgramPrivate *priv; g_return_if_fail (HILDON_IS_PROGRAM (self)); priv = HILDON_PROGRAM_GET_PRIVATE (self); g_assert (priv); if (g_slist_find_custom (priv->windows, window, hildon_program_window_list_compare) ) { /* We already have that window */ return; } if (!priv->window_count) { hildon_program_update_top_most (self); /* Now that we have a window we should start keeping track of * the root window */ gdk_window_set_events (gdk_get_default_root_window (), gdk_window_get_events (gdk_get_default_root_window ()) | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter (gdk_get_default_root_window (), hildon_program_root_window_event_filter, self ); } hildon_window_set_can_hibernate_property (window, &priv->killable); hildon_window_set_program (window, G_OBJECT (self)); priv->windows = g_slist_append (priv->windows, window); priv->window_count ++; }
void container_size_workaround(GtkWidget* container, GdkRectangle* allocation) { static GRWLock lock; g_rw_lock_writer_lock(&lock); update_primary_info(&dock); g_rw_lock_writer_unlock(&lock); if (gtk_widget_get_realized(container) && (dock.width != allocation->width || dock.height != allocation->height)) { GdkWindow* w = gtk_widget_get_window(container); GdkGeometry geo = {0}; geo.min_width = 0; geo.min_height = 0; gdk_window_set_geometry_hints(w, &geo, GDK_HINT_MIN_SIZE); XSelectInput(gdk_x11_get_default_xdisplay(), GDK_WINDOW_XID(w), NoEventMask); gdk_window_move_resize(w, dock.x, dock.y, dock.width, dock.height); gdk_flush(); gdk_window_set_events(w, gdk_window_get_events(w)); g_warning("[%s] size workaround run fix (%d,%d) to (%d,%d)\n", __func__, allocation->width, allocation->height, dock.width, dock.height); } }
static void panel_background_monitor_connect_to_screen (PanelBackgroundMonitor *monitor, GdkScreen *screen) { if (monitor->screen != NULL && monitor->gdkwindow != NULL) { gdk_window_remove_filter (monitor->gdkwindow, panel_background_monitor_xevent_filter, monitor); } monitor->screen = screen; g_signal_connect_swapped (screen, "size-changed", G_CALLBACK (panel_background_monitor_changed), monitor); monitor->gdkwindow = gdk_screen_get_root_window (screen); monitor->xwindow = gdk_x11_drawable_get_xid (monitor->gdkwindow); gdk_window_add_filter ( monitor->gdkwindow, panel_background_monitor_xevent_filter, monitor); gdk_window_set_events ( monitor->gdkwindow, gdk_window_get_events (monitor->gdkwindow) | GDK_PROPERTY_CHANGE_MASK); }
GdkFilterReturn event_filter_func (GdkXEvent *gdkxevent, GdkEvent *event, gpointer data) { GdkDisplay *gdkdisplay; XEvent *xevent = gdkxevent; gulong xid = 0; Window select = 0; gdkdisplay = gdk_display_get_default (); switch (xevent->type) { case CreateNotify: { if (!wnck_window_get (xevent->xcreatewindow.window)) { GdkWindow *toplevel = create_foreign_window (xevent->xcreatewindow.window); if (toplevel) { gdk_window_set_events (toplevel, gdk_window_get_events (toplevel) | GDK_PROPERTY_CHANGE_MASK); /* check if the window is a switcher and update accordingly */ if (get_window_prop (xevent->xcreatewindow.window, select_window_atom, &select)) update_switcher_window (xevent->xcreatewindow.window, select); } } } break; case ButtonPress: case ButtonRelease: xid = (gulong) g_hash_table_lookup (frame_table, GINT_TO_POINTER (xevent->xbutton.window)); break; case EnterNotify: case LeaveNotify: xid = (gulong) g_hash_table_lookup (frame_table, GINT_TO_POINTER (xevent->xcrossing.window)); break; case MotionNotify: xid = (gulong) g_hash_table_lookup (frame_table, GINT_TO_POINTER (xevent->xmotion.window)); break; case PropertyNotify: if (xevent->xproperty.atom == frame_input_window_atom) { WnckWindow *win; xid = xevent->xproperty.window; win = wnck_window_get (xid); if (win) { Window frame; if (!get_window_prop (xid, select_window_atom, &select)) { if (get_window_prop (xid, frame_input_window_atom, &frame)) add_frame_window (win, frame, FALSE); else remove_frame_window (win); } } } if (xevent->xproperty.atom == frame_output_window_atom) { WnckWindow *win; xid = xevent->xproperty.window; win = wnck_window_get (xid); if (win) { Window frame; if (!get_window_prop (xid, select_window_atom, &select)) { if (get_window_prop (xid, frame_output_window_atom, &frame)) add_frame_window (win, frame, TRUE); else remove_frame_window (win); } } } else if (xevent->xproperty.atom == compiz_shadow_info_atom || xevent->xproperty.atom == compiz_shadow_color_atom) { GdkScreen *g_screen = gdk_display_get_default_screen (gdkdisplay); Window root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (g_screen)); WnckScreen *screen; screen = wnck_screen_get_for_root (root); if (screen) { if (gwd_process_decor_shadow_property_update ()) decorations_changed (screen); } } else if (xevent->xproperty.atom == mwm_hints_atom) { WnckWindow *win; xid = xevent->xproperty.window; win = wnck_window_get (xid); if (win) { decor_t *d = g_object_get_data (G_OBJECT (win), "decor"); gboolean decorated = FALSE; /* Only decorations that are actually bound to windows can be decorated * ignore cases where a broken application which shouldn't be decorated * sets the decoration hint */ if (get_mwm_prop (xid) & (MWM_DECOR_ALL | MWM_DECOR_TITLE) && d->win) decorated = TRUE; if (decorated != d->decorated) { d->decorated = decorated; if (decorated) { d->context = NULL; d->width = d->height = 0; d->frame = gwd_get_decor_frame (get_frame_type (win)); update_window_decoration_state (win); update_window_decoration_actions (win); update_window_decoration_icon (win); request_update_window_decoration_size (win); update_event_windows (win); } else { remove_frame_window (win); } } } } else if (xevent->xproperty.atom == select_window_atom) { Window select; if (get_window_prop (xevent->xproperty.window, select_window_atom, &select)) update_switcher_window (xevent->xproperty.window, select); } break; case DestroyNotify: g_hash_table_remove (frame_table, GINT_TO_POINTER (xevent->xproperty.window)); break; case ClientMessage: if (xevent->xclient.message_type == toolkit_action_atom) { long action; action = xevent->xclient.data.l[0]; if (action == toolkit_action_window_menu_atom) { WnckWindow *win; win = wnck_window_get (xevent->xclient.window); if (win) { action_menu_map (win, xevent->xclient.data.l[2], xevent->xclient.data.l[1]); } } else if (action == toolkit_action_force_quit_dialog_atom) { WnckWindow *win; win = wnck_window_get (xevent->xclient.window); if (win) { if (xevent->xclient.data.l[2]) show_force_quit_dialog (win, xevent->xclient.data.l[1]); else hide_force_quit_dialog (win); } } } else if (xevent->xclient.message_type == decor_request_atom) { WnckWindow *win = wnck_window_get (xevent->xclient.window); if (win) update_window_decoration_size (win); } default: break; } if (xid) { WnckWindow *win; win = wnck_window_get (xid); if (win) { decor_t *d = g_object_get_data (G_OBJECT (win), "decor"); if (d->decorated) { gint i, j; event_callback cb = NULL; Window w = xevent->xany.window; for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) if (d->event_windows[i][j].window == w) cb = d->event_windows[i][j].callback; if (!cb) { for (i = 0; i < BUTTON_NUM; ++i) if (d->button_windows[i].window == w) cb = d->button_windows[i].callback; } if (cb) { decor_event gtkwd_event; decor_event_type gtkwd_type; gtkwd_event.window = w; switch (xevent->type) { case ButtonPress: case ButtonRelease: if (xevent->type == ButtonPress) gtkwd_type = GButtonPress; else gtkwd_type = GButtonRelease; gtkwd_event.button = xevent->xbutton.button; gtkwd_event.x = xevent->xbutton.x; gtkwd_event.y = xevent->xbutton.y; gtkwd_event.x_root = xevent->xbutton.x_root; gtkwd_event.y_root = xevent->xbutton.y_root; gtkwd_event.time = xevent->xbutton.time; break; case EnterNotify: case LeaveNotify: if (xevent->type == EnterNotify) gtkwd_type = GEnterNotify; else gtkwd_type = GLeaveNotify; gtkwd_event.x = xevent->xcrossing.x; gtkwd_event.y = xevent->xcrossing.y; gtkwd_event.x_root = xevent->xcrossing.x_root; gtkwd_event.y_root = xevent->xcrossing.y_root; gtkwd_event.time = xevent->xcrossing.time; break; default: cb = NULL; break; } if (cb) (*cb) (win, >kwd_event, gtkwd_type); } } } } return GDK_FILTER_CONTINUE; }
static VALUE gdkwin_get_events(VALUE self) { return GFLAGS2RVAL(gdk_window_get_events(_SELF(self)), GDK_TYPE_EVENT_MASK); }
Panel * panel_new(PanelPrefs const * prefs) { Panel * panel; GdkRectangle rect; GtkIconSize iconsize; char const * p; gboolean focus; gboolean above; if((panel = object_new(sizeof(*panel))) == NULL) return NULL; panel->screen = gdk_screen_get_default(); if(_new_config(panel) == 0) _new_prefs(panel->config, panel->screen, &panel->prefs, prefs); panel->top_helper.panel = panel; panel->top_helper.type = PANEL_APPLET_TYPE_NORMAL; panel->top_helper.icon_size = GTK_ICON_SIZE_LARGE_TOOLBAR; panel->top_helper.config_get = _panel_helper_config_get; panel->top_helper.config_set = _panel_helper_config_set; panel->top_helper.error = _panel_helper_error; panel->top_helper.about_dialog = _panel_helper_about_dialog; panel->top_helper.lock = _panel_helper_lock; #ifndef EMBEDDED panel->top_helper.logout_dialog = _panel_helper_logout_dialog; #else panel->top_helper.logout_dialog = NULL; #endif panel->top_helper.position_menu = _panel_helper_position_menu_top; panel->top_helper.preferences_dialog = _panel_helper_preferences_dialog; panel->top_helper.rotate_screen = _panel_helper_rotate_screen; panel->top_helper.shutdown_dialog = _panel_helper_shutdown_dialog; panel->top_helper.suspend = (_panel_can_suspend()) ? _panel_helper_suspend : NULL; panel->top = NULL; panel->bottom_helper = panel->top_helper; panel->bottom_helper.position_menu = _panel_helper_position_menu_bottom; panel->bottom = NULL; iconsize = GTK_ICON_SIZE_INVALID; if(panel->prefs.iconsize != NULL) iconsize = gtk_icon_size_from_name(panel->prefs.iconsize); if(iconsize == GTK_ICON_SIZE_INVALID) { panel->top_helper.icon_size = _new_size(panel, PANEL_POSITION_TOP); panel->bottom_helper.icon_size = _new_size(panel, PANEL_POSITION_BOTTOM); } else { panel->top_helper.icon_size = iconsize; panel->bottom_helper.icon_size = iconsize; } panel->pr_window = NULL; panel->ab_window = NULL; #ifndef EMBEDDED panel->lo_window = NULL; #endif panel->sh_window = NULL; if(panel->config == NULL) { panel_error(NULL, error_get(), 0); /* XXX put up a dialog box */ panel_delete(panel); return NULL; } /* root window */ panel->root = gdk_screen_get_root_window(panel->screen); _panel_reset(panel, &rect); focus = ((p = config_get(panel->config, NULL, "accept_focus")) == NULL || strcmp(p, "1") == 0) ? TRUE : FALSE; above = ((p = config_get(panel->config, NULL, "keep_above")) == NULL || strcmp(p, "1") == 0) ? TRUE : FALSE; panel->source = 0; /* top panel */ if(config_get(panel->config, NULL, "top") != NULL) { panel->top = panel_window_new(PANEL_POSITION_TOP, &panel->top_helper, &rect); panel_window_set_accept_focus(panel->top, focus); panel_window_set_keep_above(panel->top, above); } /* bottom panel */ if(config_get(panel->config, NULL, "bottom") != NULL || config_get(panel->config, NULL, "top") == NULL) { panel->bottom = panel_window_new(PANEL_POSITION_BOTTOM, &panel->bottom_helper, &rect); panel_window_set_accept_focus(panel->bottom, focus); panel_window_set_keep_above(panel->bottom, above); } /* messages */ desktop_message_register(PANEL_CLIENT_MESSAGE, _new_on_message, panel); /* manage root window events */ gdk_window_set_events(panel->root, gdk_window_get_events( panel->root) | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(panel->root, _on_root_event, panel); /* load plug-ins when idle */ panel->source = g_idle_add(_on_idle, panel); return panel; }
int main (int argc, char *argv[]) { GdkDisplay *gdkdisplay; Display *xdisplay; GdkScreen *gdkscreen; WnckScreen *screen; gint i, j, status; gboolean replace = FALSE; unsigned int nchildren; Window root_ret, parent_ret; Window *children = NULL; GList *windows, *win; decor_frame_t *bare_p, *switcher_p; const char *option_meta_theme = NULL; gint option_blur_type = 0; program_name = argv[0]; gtk_init (&argc, &argv); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); for (i = 0; i < argc; i++) { if (strcmp (argv[i], "--minimal") == 0) { minimal = TRUE; } else if (strcmp (argv[i], "--replace") == 0) { replace = TRUE; } else if (strcmp (argv[i], "--blur") == 0) { if (argc > ++i) { if (strcmp (argv[i], "titlebar") == 0) option_blur_type = BLUR_TYPE_TITLEBAR; else if (strcmp (argv[i], "all") == 0) option_blur_type = BLUR_TYPE_ALL; } } #ifdef USE_METACITY else if (strcmp (argv[i], "--metacity-theme") == 0) { if (argc > ++i) option_meta_theme = argv[i]; } #endif else if (strcmp (argv[i], "--help") == 0) { fprintf (stderr, "%s " "[--minimal] " "[--replace] " "[--blur none|titlebar|all] " #ifdef USE_METACITY "[--metacity-theme THEME] " #endif "[--help]" "\n", program_name); return 0; } } gdkdisplay = gdk_display_get_default (); xdisplay = gdk_x11_display_get_xdisplay (gdkdisplay); gdkscreen = gdk_display_get_default_screen (gdkdisplay); frame_input_window_atom = XInternAtom (xdisplay, DECOR_INPUT_FRAME_ATOM_NAME, FALSE); frame_output_window_atom = XInternAtom (xdisplay, DECOR_OUTPUT_FRAME_ATOM_NAME, FALSE); win_decor_atom = XInternAtom (xdisplay, DECOR_WINDOW_ATOM_NAME, FALSE); win_blur_decor_atom = XInternAtom (xdisplay, DECOR_BLUR_ATOM_NAME, FALSE); wm_move_resize_atom = XInternAtom (xdisplay, "_NET_WM_MOVERESIZE", FALSE); restack_window_atom = XInternAtom (xdisplay, "_NET_RESTACK_WINDOW", FALSE); select_window_atom = XInternAtom (xdisplay, DECOR_SWITCH_WINDOW_ATOM_NAME, FALSE); mwm_hints_atom = XInternAtom (xdisplay, "_MOTIF_WM_HINTS", FALSE); switcher_fg_atom = XInternAtom (xdisplay, DECOR_SWITCH_FOREGROUND_COLOR_ATOM_NAME, FALSE); compiz_shadow_info_atom = XInternAtom (xdisplay, "_COMPIZ_NET_CM_SHADOW_PROPERTIES", FALSE); compiz_shadow_color_atom = XInternAtom (xdisplay, "_COMPIZ_NET_CM_SHADOW_COLOR", FALSE); toolkit_action_atom = XInternAtom (xdisplay, "_COMPIZ_TOOLKIT_ACTION", FALSE); toolkit_action_window_menu_atom = XInternAtom (xdisplay, "_COMPIZ_TOOLKIT_ACTION_WINDOW_MENU", FALSE); toolkit_action_force_quit_dialog_atom = XInternAtom (xdisplay, "_COMPIZ_TOOLKIT_ACTION_FORCE_QUIT_DIALOG", FALSE); net_wm_state_atom = XInternAtom (xdisplay,"_NET_WM_STATE", 0); net_wm_state_modal_atom = XInternAtom (xdisplay, "_NET_WM_STATE_MODAL", 0); decor_request_atom = XInternAtom (xdisplay, "_COMPIZ_DECOR_REQUEST", 0); decor_pending_atom = XInternAtom (xdisplay, "_COMPIZ_DECOR_PENDING", 0); decor_delete_pixmap_atom = XInternAtom (xdisplay, "_COMPIZ_DECOR_DELETE_PIXMAP", 0); status = decor_acquire_dm_session (xdisplay, gdk_screen_get_number (gdkscreen), "gwd", replace, &dm_sn_timestamp); if (status != DECOR_ACQUIRE_STATUS_SUCCESS) { if (status == DECOR_ACQUIRE_STATUS_FAILED) { fprintf (stderr, "%s: Could not acquire decoration manager " "selection on screen %d display \"%s\"\n", program_name, gdk_screen_get_number (gdkscreen), DisplayString (xdisplay)); } else if (status == DECOR_ACQUIRE_STATUS_OTHER_DM_RUNNING) { fprintf (stderr, "%s: Screen %d on display \"%s\" already " "has a decoration manager; try using the " "--replace option to replace the current " "decoration manager.\n", program_name, gdk_screen_get_number (gdkscreen), DisplayString (xdisplay)); } return 1; } screen = wnck_screen_get_default (); initialize_decorations (); notified = gwd_settings_notified_impl_new (screen); if (!notified) return 1; writable = GWD_SETTINGS_WRITABLE_INTERFACE (gwd_settings_impl_new (option_blur_type != BLUR_TYPE_NONE ? &option_blur_type : NULL, option_meta_theme ? &option_meta_theme : NULL, notified)); if (!writable) { g_object_unref (notified); return 1; } settings = GWD_SETTINGS_INTERFACE (writable); gwd_settings_writable_freeze_updates (writable); if (!init_settings (writable, screen)) { g_object_unref (writable); fprintf (stderr, "%s: Failed to get necessary gtk settings\n", argv[0]); return 1; } for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { if (cursor[i][j].shape != XC_left_ptr) cursor[i][j].cursor = XCreateFontCursor (xdisplay, cursor[i][j].shape); } } xformat_rgba = XRenderFindStandardFormat (xdisplay, PictStandardARGB32); xformat_rgb = XRenderFindStandardFormat (xdisplay, PictStandardRGB24); frame_table = g_hash_table_new (NULL, NULL); destroyed_pixmaps_table = g_hash_table_new (NULL, NULL); if (!create_tooltip_window ()) { g_object_unref (writable); free (settings); fprintf (stderr, "%s, Couldn't create tooltip window\n", argv[0]); return 1; } wnck_set_client_type (WNCK_CLIENT_TYPE_PAGER); gdk_window_add_filter (NULL, selection_event_filter_func, NULL); if (!minimal) { GdkWindow *root = create_foreign_window (gdk_x11_get_default_root_xwindow ()); gdk_window_add_filter (NULL, event_filter_func, NULL); XQueryTree (xdisplay, gdk_x11_get_default_root_xwindow (), &root_ret, &parent_ret, &children, &nchildren); for (i = 0; i < nchildren; i++) { GdkWindow *toplevel = create_foreign_window (children[i]); /* Need property notify on all windows */ gdk_window_set_events (toplevel, gdk_window_get_events (toplevel) | GDK_PROPERTY_CHANGE_MASK); } /* Need MapNotify on new windows */ gdk_window_set_events (root, gdk_window_get_events (root) | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK | GDK_VISIBILITY_NOTIFY_MASK | GDK_SUBSTRUCTURE_MASK); connect_screen (screen); } decor_set_dm_check_hint (xdisplay, gdk_screen_get_number (gdkscreen), WINDOW_DECORATION_TYPE_PIXMAP | WINDOW_DECORATION_TYPE_WINDOW); /* Update the decorations based on the settings */ gwd_settings_writable_thaw_updates (writable); /* Keep the default, bare and switcher decorations around * since otherwise they will be spuriously recreated */ bare_p = gwd_get_decor_frame ("bare"); switcher_p = gwd_get_decor_frame ("switcher"); update_default_decorations (gdkscreen); gtk_main (); win = windows = wnck_screen_get_windows (screen); while (win != NULL) { WnckWindow *w = (WnckWindow *) win->data; window_closed (screen, w); win = g_list_next (win); } g_list_free (windows); if (tip_label) gtk_widget_destroy (GTK_WIDGET (tip_label)); if (tip_window) gtk_widget_destroy (GTK_WIDGET (tip_window)); gwd_decor_frame_unref (bare_p); gwd_decor_frame_unref (switcher_p); fini_settings (); return 0; }
int main(int argc, char **argv) { #if WIN32 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD(2, 2); err = WSAStartup(wVersionRequested, &wsaData); #endif dbg("%s\n", argv[0]); b_contrib = strstr(argv[0], "ts-contribute")!=NULL; if (b_contrib) dbg("b_contrib\n"); set_is_chs(); load_setttings(); init_TableDir(); b_pinyin = is_pinyin_kbm(); gtk_init (&argc, &argv); load_gtab_list(TRUE); char gcin_dir[512]; get_gcin_dir(gcin_dir); if (argc < 2) { #if UNIX chdir(gcin_dir); #else _chdir(gcin_dir); #endif } #if GCIN_i18n_message bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); #endif get_gcin_user_fname(DOWNLOADED_PHRASES, downloaded_file_src); strcat(downloaded_file_src, ".src"); pinmd = &inmd[default_input_method]; if (pinmd->method_type == method_type_TSIN) { dbg("is tsin\n"); pho_load(); if (b_contrib) { load_tsin_contrib(); } else { if (argc > 1) load_tsin_db_ex(&tsin_hand, argv[1], FALSE, FALSE, FALSE); else load_tsin_db(); } ph_key_sz = 2; } else if (pinmd->filename) { if (b_contrib) p_err("Currently %s only supports tsin", argv[0]); dbg("gtab filename %s\n", pinmd->filename); init_gtab(default_input_method); is_gtab = TRUE; init_tsin_table_fname(pinmd, gtab_tsin_fname); load_tsin_db0(gtab_tsin_fname, TRUE); } else p_err("Your default input method %s doesn't use phrase database", pinmd->cname); dbg("ph_key_sz: %d\n", ph_key_sz); #if UNIX dpy = GDK_DISPLAY(); #endif load_ts_phrase(); mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(mainwin), GTK_WIN_POS_CENTER); g_signal_connect (G_OBJECT (mainwin), "key-press-event", G_CALLBACK (key_press_event), NULL); gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE); // gtk_window_set_default_size(GTK_WINDOW (mainwin), 640, 520); set_window_gcin_icon(mainwin); vbox_top = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER(mainwin), vbox_top); GtkWidget *hbox_page = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_page, TRUE, FALSE, 0); GtkWidget *align_page = gtk_alignment_new(0, 0, 1.0, 1.0); gtk_box_pack_start (GTK_BOX (hbox_page), align_page, TRUE, TRUE, 0); GtkWidget *vbox_page = gtk_vbox_new (TRUE, 0); gtk_container_add (GTK_CONTAINER(align_page), vbox_page); scroll_bar = gtk_vscrollbar_new( GTK_ADJUSTMENT(gtk_adjustment_new(tsN - PAGE_LEN,0, tsN, 1,PAGE_LEN,PAGE_LEN))); gtk_box_pack_start (GTK_BOX (hbox_page), scroll_bar, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(scroll_bar), "change-value", G_CALLBACK(cb_scroll_bar), NULL); int i; for(i=0; i<PAGE_LEN; i++) { GtkWidget *hbox; hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_page), hbox, TRUE, TRUE, 0); button_check[i] = gtk_check_button_new(); gtk_box_pack_start (GTK_BOX (hbox), button_check[i], FALSE, FALSE, 0); labels[i]=gtk_label_new(NULL); GtkWidget *align = gtk_alignment_new (0, 0, 0, 0); gtk_container_add(GTK_CONTAINER(align), labels[i]); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0); } hbox_buttons = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_buttons, FALSE, FALSE, 0); GtkWidget *button_delete = b_contrib ? gtk_button_new_with_label(_(_L("私密詞不上載"))):gtk_button_new_from_stock (GTK_STOCK_DELETE); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_delete, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_delete), "clicked", G_CALLBACK (cb_button_delete), NULL); GtkWidget *button_find = gtk_button_new_from_stock (GTK_STOCK_FIND); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_find, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_find), "clicked", G_CALLBACK (cb_button_find), NULL); #if 0 GtkWidget *button_edit = gtk_button_new_from_stock (GTK_STOCK_EDIT); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_edit, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_edit), "clicked", G_CALLBACK (cb_button_edit), NULL); #endif GtkWidget *button_save = b_contrib ? gtk_button_new_with_label(_(_L("上載詞"))) :gtk_button_new_from_stock (GTK_STOCK_SAVE); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_save, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_save), "clicked", G_CALLBACK (cb_button_save), NULL); GtkWidget *button_quit = gtk_button_new_from_stock (GTK_STOCK_QUIT); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_quit, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_quit), "clicked", G_CALLBACK (do_exit), NULL); if (!b_contrib && !is_gtab) { GtkWidget *button_download = gtk_button_new_with_label(_(_L("下載共享詞庫"))); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_download, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_download), "clicked", G_CALLBACK (cb_button_download), NULL); } g_signal_connect (G_OBJECT (mainwin), "delete_event", G_CALLBACK (do_exit), NULL); gtk_widget_realize (mainwin); gtk_widget_show_all(mainwin); // load_ts_phrase(); disp_page(); #if 0 GdkWindow *gdkwin=gtk_widget_get_window(mainwin); gdk_window_set_events(gdkwin, GDK_BUTTON_PRESS_MASK|GDK_SCROLL_MASK| gdk_window_get_events(gdkwin)); #endif gtk_main(); return 0; }
static void gs_theme_window_real_realize (GtkWidget *widget) { GdkWindow *window; Window remote_xwindow; GtkRequisition requisition; GtkAllocation allocation; const char *preview_xid; int x; int y; int width; int height; int event_mask; event_mask = 0; window = NULL; preview_xid = g_getenv ("XSCREENSAVER_WINDOW"); if (preview_xid != NULL) { char *end; remote_xwindow = (Window) strtoul (preview_xid, &end, 0); if ((remote_xwindow != 0) && (end != NULL) && ((*end == ' ') || (*end == '\0')) && ((remote_xwindow < G_MAXULONG) || (errno != ERANGE))) { window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), remote_xwindow); if (window != NULL) { /* This is a kludge; we need to set the same * flags gs-window-x11.c does, to ensure they * don't get unset by gtk_window_map() later. */ gtk_window_set_decorated (GTK_WINDOW (widget), FALSE); gtk_window_set_skip_taskbar_hint (GTK_WINDOW (widget), TRUE); gtk_window_set_skip_pager_hint (GTK_WINDOW (widget), TRUE); gtk_window_set_keep_above (GTK_WINDOW (widget), TRUE); gtk_window_fullscreen (GTK_WINDOW (widget)); event_mask = GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK; gtk_widget_set_events (widget, gtk_widget_get_events (widget) | event_mask); } } } if (window == NULL) { GtkWidgetClass *parent_class; parent_class = GTK_WIDGET_CLASS (gs_theme_window_parent_class); if (parent_class->realize != NULL) parent_class->realize (widget); return; } gtk_style_context_set_background (gtk_widget_get_style_context (widget), window); gdk_window_set_decorations (window, (GdkWMDecoration) 0); gdk_window_set_events (window, gdk_window_get_events (window) | event_mask); gtk_widget_set_window (widget, window); gdk_window_set_user_data (window, widget); gtk_widget_set_realized (widget, TRUE); gdk_window_get_geometry (window, &x, &y, &width, &height); if (width < MIN_SIZE || height < MIN_SIZE) { g_critical ("This window is way too small to use"); exit (1); } gtk_widget_get_preferred_size (widget, &requisition, NULL); allocation.x = x; allocation.y = y; allocation.width = width; allocation.height = height; gtk_widget_size_allocate (widget, &allocation); gtk_window_resize (GTK_WINDOW (widget), width, height); }
gboolean gdk_input_other_event (GdkDisplay *display, GdkEvent *event, MSG *msg, GdkWindow *window) { GdkDeviceManagerWin32 *device_manager; GdkDeviceWintab *source_device = NULL; GdkDeviceGrabInfo *last_grab; GdkEventMask masktest; guint key_state; POINT pt; PACKET packet; gint root_x, root_y; gint num_axes; gint x, y; guint translated_buttons, button_diff, button_mask; /* Translation from tablet button state to GDK button state for * buttons 1-3 - swap button 2 and 3. */ static guint button_map[8] = {0, 1, 4, 5, 2, 3, 6, 7}; if (event->any.window != wintab_window) { g_warning ("gdk_input_other_event: not wintab_window?"); return FALSE; } G_GNUC_BEGIN_IGNORE_DEPRECATIONS; device_manager = GDK_DEVICE_MANAGER_WIN32 (gdk_display_get_device_manager (display)); G_GNUC_END_IGNORE_DEPRECATIONS; window = gdk_device_get_window_at_position (device_manager->core_pointer, &x, &y); if (window == NULL) window = gdk_get_default_root_window (); g_object_ref (window); GDK_NOTE (EVENTS_OR_INPUT, g_print ("gdk_input_other_event: window=%p %+d%+d\n", GDK_WINDOW_HWND (window), x, y)); if (msg->message == WT_PACKET || msg->message == WT_CSRCHANGE) { if (!(*p_WTPacket) ((HCTX) msg->lParam, msg->wParam, &packet)) return FALSE; } switch (msg->message) { case WT_PACKET: /* Don't produce any button or motion events while a window is being * moved or resized, see bug #151090. */ if (_modal_operation_in_progress) { GDK_NOTE (EVENTS_OR_INPUT, g_print ("... ignored when moving/sizing\n")); return FALSE; } if ((source_device = gdk_device_manager_find_wintab_device (device_manager, (HCTX) msg->lParam, packet.pkCursor)) == NULL) return FALSE; if (gdk_device_get_mode (GDK_DEVICE (source_device)) == GDK_MODE_DISABLED) return FALSE; last_grab = _gdk_display_get_last_device_grab (display, GDK_DEVICE (source_device)); if (last_grab && last_grab->window) { g_object_unref (window); window = g_object_ref (last_grab->window); } if (window == gdk_get_default_root_window ()) { GDK_NOTE (EVENTS_OR_INPUT, g_print ("... is root\n")); return FALSE; } num_axes = 0; if (source_device->pktdata & PK_X) source_device->last_axis_data[num_axes++] = packet.pkX; if (source_device->pktdata & PK_Y) source_device->last_axis_data[num_axes++] = packet.pkY; if (source_device->pktdata & PK_NORMAL_PRESSURE) source_device->last_axis_data[num_axes++] = packet.pkNormalPressure; if (source_device->pktdata & PK_ORIENTATION) { decode_tilt (source_device->last_axis_data + num_axes, source_device->orientation_axes, &packet); num_axes += 2; } translated_buttons = button_map[packet.pkButtons & 0x07] | (packet.pkButtons & ~0x07); if (translated_buttons != source_device->button_state) { /* At least one button has changed state so produce a button event * If more than one button has changed state (unlikely), * just care about the first and act on the next the next time * we get a packet */ button_diff = translated_buttons ^ source_device->button_state; /* Gdk buttons are numbered 1.. */ event->button.button = 1; for (button_mask = 1; button_mask != 0x80000000; button_mask <<= 1, event->button.button++) { if (button_diff & button_mask) { /* Found a button that has changed state */ break; } } if (!(translated_buttons & button_mask)) { event->any.type = GDK_BUTTON_RELEASE; masktest = GDK_BUTTON_RELEASE_MASK; } else { event->any.type = GDK_BUTTON_PRESS; masktest = GDK_BUTTON_PRESS_MASK; } source_device->button_state ^= button_mask; } else { event->any.type = GDK_MOTION_NOTIFY; masktest = GDK_POINTER_MOTION_MASK; if (source_device->button_state & (1 << 0)) masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK; if (source_device->button_state & (1 << 1)) masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON2_MOTION_MASK; if (source_device->button_state & (1 << 2)) masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON3_MOTION_MASK; } /* Now we can check if the window wants the event, and * propagate if necessary. */ while ((gdk_window_get_device_events (window, GDK_DEVICE (source_device)) & masktest) == 0 && (gdk_device_get_device_type (GDK_DEVICE (source_device)) == GDK_DEVICE_TYPE_SLAVE && (gdk_window_get_events (window) & masktest) == 0)) { GDK_NOTE (EVENTS_OR_INPUT, g_print ("... not selected\n")); if (window->parent == gdk_get_default_root_window () || window->parent == NULL) return FALSE; pt.x = x; pt.y = y; ClientToScreen (GDK_WINDOW_HWND (window), &pt); g_object_unref (window); window = window->parent; g_object_ref (window); ScreenToClient (GDK_WINDOW_HWND (window), &pt); x = pt.x; y = pt.y; GDK_NOTE (EVENTS_OR_INPUT, g_print ("... propagating to %p %+d%+d\n", GDK_WINDOW_HWND (window), x, y)); } event->any.window = window; key_state = get_modifier_key_state (); if (event->any.type == GDK_BUTTON_PRESS || event->any.type == GDK_BUTTON_RELEASE) { event->button.time = _gdk_win32_get_next_tick (msg->time); if (source_device->sends_core) gdk_event_set_device (event, device_manager->core_pointer); gdk_event_set_source_device (event, GDK_DEVICE (source_device)); gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer)); event->button.axes = g_new (gdouble, num_axes); gdk_window_get_origin (window, &root_x, &root_y); _gdk_device_wintab_translate_axes (source_device, window, event->button.axes, &event->button.x, &event->button.y); event->button.x_root = event->button.x + root_x; event->button.y_root = event->button.y + root_y; event->button.state = key_state | ((source_device->button_state << 8) & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK | GDK_BUTTON4_MASK | GDK_BUTTON5_MASK)); GDK_NOTE (EVENTS_OR_INPUT, g_print ("WINTAB button %s:%d %g,%g\n", (event->button.type == GDK_BUTTON_PRESS ? "press" : "release"), event->button.button, event->button.x, event->button.y)); } else { event->motion.time = _gdk_win32_get_next_tick (msg->time); event->motion.is_hint = FALSE; gdk_event_set_device (event, device_manager->core_pointer); gdk_event_set_source_device (event, GDK_DEVICE (source_device)); gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer)); event->motion.axes = g_new (gdouble, num_axes); gdk_window_get_origin (window, &root_x, &root_y); _gdk_device_wintab_translate_axes (source_device, window, event->motion.axes, &event->motion.x, &event->motion.y); event->motion.x_root = event->motion.x + root_x; event->motion.y_root = event->motion.y + root_y; event->motion.state = key_state | ((source_device->button_state << 8) & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK | GDK_BUTTON4_MASK | GDK_BUTTON5_MASK)); GDK_NOTE (EVENTS_OR_INPUT, g_print ("WINTAB motion: %g,%g\n", event->motion.x, event->motion.y)); } return TRUE; case WT_CSRCHANGE: if ((source_device = gdk_device_manager_find_wintab_device (device_manager, (HCTX) msg->lParam, packet.pkCursor)) == NULL) return FALSE; if (gdk_device_get_mode (GDK_DEVICE (source_device)) == GDK_MODE_DISABLED) return FALSE; if (source_device->sends_core) { _gdk_device_virtual_set_active (device_manager->core_pointer, GDK_DEVICE (source_device)); _gdk_input_ignore_core = TRUE; } return FALSE; case WT_PROXIMITY: if (LOWORD (msg->lParam) == 0) { _gdk_input_ignore_core = FALSE; _gdk_device_virtual_set_active (device_manager->core_pointer, device_manager->system_pointer); } return FALSE; } return FALSE; }
static VALUE rg_events(VALUE self) { return GDKEVENTMASK2RVAL(gdk_window_get_events(_SELF(self))); }