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