static CeditNotebook *
find_notebook_at_pointer (gint abs_x, gint abs_y)
{
GdkWindow *win_at_pointer;
GdkWindow *toplevel_win;
gpointer toplevel = NULL;
gint x, y;
/* FIXME multi-head */
win_at_pointer = gdk_window_at_pointer (&x, &y);
if (win_at_pointer == NULL)
{
/* We are outside all windows of the same application */
return NULL;
}
toplevel_win = gdk_window_get_toplevel (win_at_pointer);
/* get the GtkWidget which owns the toplevel GdkWindow */
gdk_window_get_user_data (toplevel_win, &toplevel);
/* toplevel should be an CeditWindow */
if ((toplevel != NULL) &&
CEDIT_IS_WINDOW (toplevel))
{
return CEDIT_NOTEBOOK (_cedit_window_get_notebook
(CEDIT_WINDOW (toplevel)));
}
/* We are outside all windows containing a notebook */
return NULL;
}
static void tooltip_trigger(void)
{
GdkDisplay *display = gdk_display_get_default();
#if GTK_CHECK_VERSION(3, 0, 0)
GdkDeviceManager *manager = gdk_display_get_device_manager(display);
GdkDevice *device = gdk_device_manager_get_client_pointer(manager);
GdkWindow *window = gdk_device_get_window_at_position(device, NULL, NULL);
#else
GdkWindow *window = gdk_display_get_window_at_pointer(display, NULL, NULL);
#endif
GeanyDocument *doc = document_get_current();
if (doc && window)
{
GtkWidget *event_widget;
gdk_window_get_user_data(window, (void **) &event_widget);
/* if you know a better working way, do not hesistate to tell me */
if (event_widget &&
gtk_widget_is_ancestor(event_widget, GTK_WIDGET(doc->editor->sci)))
{
gtk_tooltip_trigger_tooltip_query(display);
}
}
}
nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() {
if(!mGtkSocket) {
GdkWindow *win = gdk_window_lookup((XID)window);
mGtkSocket = gtk_socket_new();
//attach the socket to the container widget
gtk_widget_set_parent_window(mGtkSocket, win);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mGtkSocket, "plug_removed",
G_CALLBACK(plug_removed_cb), NULL);
gpointer user_data = NULL;
gdk_window_get_user_data(win, &user_data);
GtkContainer *container = GTK_CONTAINER(user_data);
gtk_container_add(container, mGtkSocket);
gtk_widget_realize(mGtkSocket);
// Resize before we show
SetAllocation();
gtk_widget_show(mGtkSocket);
gdk_flush();
window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mGtkSocket));
}
return NS_OK;
}
static void
createPixmap(PluginInstance *This)
{
int err = 0;
if (nullPluginGdkPixmap == 0)
{
GtkStyle *style;
GdkBitmap *mask;
GdkWindow *gdk_window = getGdkWindow(This);
if (gdk_window)
{
GtkWidget *widget;
#ifndef MOZ_WIDGET_GTK2
widget = (GtkWidget *)gdk_window->user_data;
#else
gpointer user_data = NULL;
gdk_window_get_user_data( gdk_window, &user_data);
widget = GTK_WIDGET(user_data);
#endif
style = gtk_widget_get_style(widget);
nullPluginGdkPixmap = gdk_pixmap_create_from_xpm_d(gdk_window , &mask,
&style->bg[GTK_STATE_NORMAL], npnul320_xpm);
#ifdef MOZ_X11
/* Pixmap is created on original X session but used by new session */
XSync(GDK_DISPLAY(), False);
#endif
}
}
}
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */
static NautilusNotebook *
find_notebook_at_pointer (gint abs_x, gint abs_y)
{
GdkWindow *win_at_pointer, *toplevel_win;
gpointer toplevel = NULL;
gint x, y;
/* FIXME multi-head */
win_at_pointer = gdk_window_at_pointer (&x, &y);
if (win_at_pointer == NULL)
{
/* We are outside all windows containing a notebook */
return NULL;
}
toplevel_win = gdk_window_get_toplevel (win_at_pointer);
/* get the GtkWidget which owns the toplevel GdkWindow */
gdk_window_get_user_data (toplevel_win, &toplevel);
/* toplevel should be an NautilusWindow */
if (toplevel != NULL && NAUTILUS_IS_NAVIGATION_WINDOW (toplevel))
{
return NAUTILUS_NOTEBOOK (NAUTILUS_NAVIGATION_WINDOW (toplevel)->notebook);
}
return NULL;
}
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */
static EphyNotebook *
find_notebook_at_pointer (gint abs_x, gint abs_y)
{
GdkWindow *win_at_pointer, *toplevel_win;
gpointer toplevel = NULL;
gint x, y;
/* FIXME multi-head */
win_at_pointer = gdk_window_at_pointer (&x, &y);
if (win_at_pointer == NULL)
{
/* We are outside all windows containing a notebook */
return NULL;
}
toplevel_win = gdk_window_get_toplevel (win_at_pointer);
/* get the GtkWidget which owns the toplevel GdkWindow */
gdk_window_get_user_data (toplevel_win, &toplevel);
/* toplevel should be an EphyWindow */
if (toplevel != NULL && EPHY_IS_WINDOW (toplevel))
{
return EPHY_NOTEBOOK (ephy_window_get_notebook
(EPHY_WINDOW (toplevel)));
}
return NULL;
}
static void
gtk_tooltip_set_last_window (GtkTooltip *tooltip,
GdkWindow *window)
{
GtkWidget *window_widget = NULL;
if (tooltip->last_window == window)
return;
if (tooltip->last_window)
g_object_remove_weak_pointer (G_OBJECT (tooltip->last_window),
(gpointer *) &tooltip->last_window);
tooltip->last_window = window;
if (window)
g_object_add_weak_pointer (G_OBJECT (tooltip->last_window),
(gpointer *) &tooltip->last_window);
if (window)
gdk_window_get_user_data (window, (gpointer *) &window_widget);
if (window_widget)
window_widget = gtk_widget_get_toplevel (window_widget);
if (window_widget &&
window_widget != tooltip->window &&
gtk_widget_is_toplevel (window_widget) &&
GTK_IS_WINDOW (window_widget))
gtk_window_set_transient_for (GTK_WINDOW (tooltip->window),
GTK_WINDOW (window_widget));
else
gtk_window_set_transient_for (GTK_WINDOW (tooltip->window), NULL);
}
static void
test_widget_windows (gpointer data)
{
GType type = GPOINTER_TO_SIZE (data);
GtkWidget* window = gtk_test_create_widget (GTK_TYPE_WINDOW, NULL);
GtkWidget* widget = gtk_test_create_widget (type, NULL);
GList * windows;
gtk_container_add (GTK_CONTAINER (window), widget);
gtk_widget_show_all (window);
windows = g_list_prepend (NULL, gtk_widget_get_window (window));
while (windows)
{
gpointer user_data = NULL;
GList * children = gdk_window_get_children (windows->data);
if (!gdk_window_is_visible (windows->data))
{
g_error ("the GdkWindow %p wasn't shown in map()", windows->data);
}
gdk_window_get_user_data (windows->data, &user_data);
if (!user_data)
{
/* at some point provide a better message (e.g. with the window tree and the data) */
g_error ("the GdkWindow %p doesn't have user data set", windows->data);
}
windows = g_list_delete_link (windows, windows);
windows = g_list_concat (windows, children);
}
}
static VALUE
gdkwin_get_user_data(VALUE self)
{
GObject *data = NULL;
gdk_window_get_user_data(_SELF(self), (gpointer)&data);
return GOBJ2RVAL(data);
}
void
_fcitx_im_context_set_capacity(FcitxIMContext* fcitxcontext, gboolean force)
{
if (fcitx_client_is_valid(fcitxcontext->client)) {
FcitxCapacityFlags flags = fcitxcontext->capacity & ~(CAPACITY_PREEDIT | CAPACITY_FORMATTED_PREEDIT | CAPACITY_PASSWORD);
if (fcitxcontext->use_preedit)
flags |= CAPACITY_PREEDIT | CAPACITY_FORMATTED_PREEDIT;
if (fcitxcontext->client_window != NULL) {
GtkWidget *widget;
gdk_window_get_user_data (fcitxcontext->client_window,
(gpointer *)&widget);
if (GTK_IS_ENTRY (widget) &&
!gtk_entry_get_visibility (GTK_ENTRY (widget))) {
flags |= CAPACITY_PASSWORD;
}
}
gboolean update = FALSE;
if (G_UNLIKELY(fcitxcontext->capacity != flags)) {
fcitxcontext->capacity = flags;
update = TRUE;
}
if (G_UNLIKELY(update || force))
fcitx_client_set_capacity(fcitxcontext->client, fcitxcontext->capacity);
}
}
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */
static NautilusNotebook *
find_notebook_at_pointer (gint abs_x, gint abs_y)
{
GdkDeviceManager *manager;
GdkDevice *pointer;
GdkWindow *win_at_pointer, *toplevel_win;
gpointer toplevel = NULL;
gint x, y;
/* FIXME multi-head */
manager = gdk_display_get_device_manager (gdk_display_get_default ());
pointer = gdk_device_manager_get_client_pointer (manager);
win_at_pointer = gdk_device_get_window_at_position (pointer, &x, &y);
if (win_at_pointer == NULL)
{
/* We are outside all windows containing a notebook */
return NULL;
}
toplevel_win = gdk_window_get_toplevel (win_at_pointer);
/* get the GtkWidget which owns the toplevel GdkWindow */
gdk_window_get_user_data (toplevel_win, &toplevel);
/* toplevel should be an NautilusWindow */
if (toplevel != NULL && NAUTILUS_IS_WINDOW (toplevel))
{
return NAUTILUS_NOTEBOOK (NAUTILUS_WINDOW (toplevel)->details->notebook);
}
return NULL;
}
static guint
get_selection_anchor_point (FcitxIMContext *fcitxcontext,
guint cursor_pos,
guint surrounding_text_len)
{
GtkWidget *widget;
if (fcitxcontext->client_window == NULL) {
return cursor_pos;
}
gdk_window_get_user_data (fcitxcontext->client_window, (gpointer *)&widget);
if (!GTK_IS_TEXT_VIEW (widget)) {
return cursor_pos;
}
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
if (!gtk_text_buffer_get_has_selection (buffer)) {
return cursor_pos;
}
GtkTextIter start_iter, end_iter, cursor_iter;
if (!gtk_text_buffer_get_selection_bounds (buffer, &start_iter, &end_iter)) {
return cursor_pos;
}
gtk_text_buffer_get_iter_at_mark (buffer,
&cursor_iter,
gtk_text_buffer_get_insert (buffer));
guint start_index = gtk_text_iter_get_offset (&start_iter);
guint end_index = gtk_text_iter_get_offset (&end_iter);
guint cursor_index = gtk_text_iter_get_offset (&cursor_iter);
guint anchor;
if (start_index == cursor_index) {
anchor = end_index;
} else if (end_index == cursor_index) {
anchor = start_index;
} else {
return cursor_pos;
}
// Change absolute index to relative position.
guint relative_origin = cursor_index - cursor_pos;
if (anchor < relative_origin) {
return cursor_pos;
}
anchor -= relative_origin;
if (anchor > surrounding_text_len) {
return cursor_pos;
}
return anchor;
}
nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
GdkWindow *parent_win = gdk_window_lookup((XID)window);
mSocketWidget = gtk_socket_new();
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mSocketWidget, "plug_removed",
G_CALLBACK(plug_removed_cb), NULL);
g_signal_connect(mSocketWidget, "unrealize",
G_CALLBACK(socket_unrealize_cb), NULL);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
gpointer user_data = NULL;
gdk_window_get_user_data(parent_win, &user_data);
GtkContainer *container = GTK_CONTAINER(user_data);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// The GtkSocket has a visible window, but the plugin's XEmbed plug will
// cover this window. Normally GtkSockets let the X server paint their
// background and this would happen immediately (before the plug is
// created). Setting the background to None prevents the server from
// painting this window, avoiding flicker.
gdk_window_set_back_pixmap(mSocketWidget->window, NULL, FALSE);
// Resize before we show
SetAllocation();
gtk_widget_show(mSocketWidget);
gdk_flush();
window = (void*)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));
// Fill out the ws_info structure.
// (The windowless case is done in nsObjectFrame.cpp.)
GdkWindow *gdkWindow = gdk_window_lookup((XID)window);
if(!gdkWindow)
return NS_ERROR_FAILURE;
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
mWsInfo.depth = gdkVisual->depth;
return NS_OK;
}
NS_IMETHODIMP Icon::Init(nsIDOMWindow *aWindow, const nsString& aTitle)
{
nsresult rv;
nsCOMPtr<nsIBaseWindow> baseWindow;
rv = GetBaseWindow(aWindow, getter_AddRefs(baseWindow));
NS_ENSURE_SUCCESS(rv, rv);
nativeWindow native = 0;
rv = baseWindow->GetParentNativeWindow(&native);
NS_ENSURE_SUCCESS(rv, rv);
// Get the window
mGdkWindow = gdk_window_get_toplevel(reinterpret_cast<GdkWindow*>(native));
if (!mGdkWindow) {
return NS_ERROR_UNEXPECTED;
}
// Get the widget and gtk window
GtkWidget *widget;
gdk_window_get_user_data(mGdkWindow, reinterpret_cast<gpointer*>(&widget));
widget = gtk_widget_get_toplevel(widget);
mGtkWindow = reinterpret_cast<GtkWindow*>(widget);
// Set up tray icon
mStatusIcon = gtk_status_icon_new();
// Get the window icon and set it
GdkPixbuf *buf = gtk_window_get_icon(mGtkWindow);
if (buf) {
gtk_status_icon_set_from_pixbuf(mStatusIcon, buf);
} else {
const gchar *iconname = gtk_window_get_icon_name(mGtkWindow);
if (iconname)
gtk_status_icon_set_from_icon_name(mStatusIcon, iconname);
}
// Get and set the title
if (aTitle.IsEmpty()) {
gtk_status_icon_set_tooltip_text(mStatusIcon, gtk_window_get_title(mGtkWindow));
gtk_widget_add_events(widget, GDK_PROPERTY_CHANGE_MASK);
propertyEventId = g_signal_connect(mGtkWindow, "property-notify-event", G_CALLBACK(gtkPropertyEvent), this);
}
else {
NS_ConvertUTF16toUTF8 titleUTF8(aTitle);
gtk_status_icon_set_tooltip_text(mStatusIcon, reinterpret_cast<const char*>(titleUTF8.get()));
propertyEventId = 0;
}
// Add signals
g_signal_connect(G_OBJECT(mStatusIcon), "button-press-event", G_CALLBACK(gtkButtonEvent), this);
g_signal_connect(G_OBJECT(mStatusIcon), "button-release-event", G_CALLBACK(gtkButtonEvent), this);
// Make visible
gtk_status_icon_set_visible(mStatusIcon, 1);
return NS_OK;
}
static GSList*
test_find_widget_input_windows (GtkWidget *widget,
gboolean input_only)
{
GList *node, *children;
GSList *matches = NULL;
gpointer udata;
gdk_window_get_user_data (widget->window, &udata);
if (udata == widget && (!input_only || (GDK_IS_WINDOW (widget->window) && GDK_WINDOW_OBJECT (widget->window)->input_only)))
matches = g_slist_prepend (matches, widget->window);
children = gdk_window_get_children (gtk_widget_get_parent_window (widget));
for (node = children; node; node = node->next)
{
gdk_window_get_user_data (node->data, &udata);
if (udata == widget && (!input_only || (GDK_IS_WINDOW (node->data) && GDK_WINDOW_OBJECT (node->data)->input_only)))
matches = g_slist_prepend (matches, node->data);
}
return g_slist_reverse (matches);
}
GtkWidget*
gtk_xtbin_new (GdkWindow *parent_window, String * f)
{
GtkXtBin *xtbin;
gpointer user_data;
assert(parent_window != NULL);
xtbin = g_object_new (GTK_TYPE_XTBIN, NULL);
if (!xtbin)
return (GtkWidget*)NULL;
if (f)
fallback = f;
/* Initialize the Xt toolkit */
xtbin->parent_window = parent_window;
xt_client_init(&(xtbin->xtclient),
GDK_VISUAL_XVISUAL(gdk_rgb_get_visual()),
GDK_COLORMAP_XCOLORMAP(gdk_rgb_get_colormap()),
gdk_rgb_get_visual()->depth);
if (!xtbin->xtclient.xtdisplay) {
/* If XtOpenDisplay failed, we can't go any further.
* Bail out.
*/
#ifdef DEBUG_XTBIN
printf("gtk_xtbin_init: XtOpenDisplay() returned NULL.\n");
#endif
g_free (xtbin);
return (GtkWidget *)NULL;
}
/* Launch X event loop */
xt_client_xloop_create();
/* Build the hierachy */
xtbin->xtdisplay = xtbin->xtclient.xtdisplay;
gtk_widget_set_parent_window(GTK_WIDGET(xtbin), parent_window);
gdk_window_get_user_data(xtbin->parent_window, &user_data);
if (user_data)
gtk_container_add(GTK_CONTAINER(user_data), GTK_WIDGET(xtbin));
/* This GtkSocket has a visible window, but the Xt plug will cover this
* window. Normally GtkSockets let the X server paint their background and
* this would happen immediately (before the plug is mapped). Setting the
* background to None prevents the server from painting this window,
* avoiding flicker.
*/
gtk_widget_realize(GTK_WIDGET(xtbin));
gdk_window_set_back_pixmap(GTK_WIDGET(xtbin)->window, NULL, FALSE);
return GTK_WIDGET (xtbin);
}
static gboolean
cb_treeview_motion (GtkWidget *widget,
GdkEventMotion *event,
StfDialogData *pagedata)
{
int x = (int)event->x;
int col, dx;
RenderData_t *renderdata = pagedata->fixed.renderdata;
int old_ruler_x = pagedata->fixed.ruler_x;
int colstart, colend, colwidth;
gpointer user;
pagedata->fixed.ruler_x = -1;
/* We get events from the buttons too. Translate x. */
gdk_window_get_user_data (event->window, &user);
if (GTK_IS_BUTTON (user)) {
int ewx;
gdk_window_get_position (event->window, &ewx, NULL);
x += ewx;
}
stf_preview_find_column (renderdata, x, &col, &dx);
colstart = (col == 0)
? 0
: stf_parse_options_fixed_splitpositions_nth (pagedata->parseoptions, col - 1);
colend = stf_parse_options_fixed_splitpositions_nth (pagedata->parseoptions, col);
colwidth = (colend == -1) ? G_MAXINT : colend - colstart;
if (col >= 0 && col < renderdata->colcount) {
int ci = calc_char_index (renderdata, col, &dx);
if (ci <= colwidth) {
int padx;
GtkCellRenderer *cell =
stf_preview_get_cell_renderer (renderdata, col);
gtk_cell_renderer_get_padding (cell, &padx, NULL);
pagedata->fixed.ruler_x = x - dx + padx;
}
}
gdk_event_request_motions (event);
if (pagedata->fixed.ruler_x == old_ruler_x)
return FALSE;
queue_redraw (widget, old_ruler_x);
queue_redraw (widget, pagedata->fixed.ruler_x);
return FALSE;
}
/* Finds the toplevel window under the mouse pointer, if any.
*/
static GtkWidget *
find_toplevel_at_pointer (GdkDisplay *display)
{
GdkWindow *pointer_window;
GtkWidget *widget = NULL;
pointer_window = gdk_display_get_window_at_pointer (display, NULL, NULL);
/* The user data field of a GdkWindow is used to store a pointer
* to the widget that created it.
*/
if (pointer_window)
gdk_window_get_user_data (pointer_window, (gpointer*) &widget);
return widget ? gtk_widget_get_toplevel (widget) : NULL;
}
gboolean
meta_ui_window_is_widget (MetaUI *ui,
Window xwindow)
{
GdkWindow *window;
window = gdk_xid_table_lookup (xwindow);
if (window)
{
void *user_data = NULL;
gdk_window_get_user_data (window, &user_data);
return user_data != NULL && user_data != ui->frames;
}
else
return FALSE;
}
static void
nullify_widget_pointers (gpointer data, GObject *widget)
{
MozDrawingarea *drawingarea = data;
#ifdef DEBUG
gpointer user_data;
/* This function may get called twice before widget is destroyed,
so the user_data may have already been nullified. */
gdk_window_get_user_data(drawingarea->inner_window, &user_data);
if (user_data && widget && user_data != widget)
g_critical("user_data does not match widget");
#endif
gdk_window_set_user_data(drawingarea->inner_window, NULL);
gdk_window_set_user_data(drawingarea->clip_window, NULL);
}
static void tooltip_trigger(void)
{
GdkDisplay *display = gdk_display_get_default();
GdkWindow *window = gdk_display_get_window_at_pointer(display, NULL, NULL);
GeanyDocument *doc = document_get_current();
if (doc && window)
{
GtkWidget *event_widget;
gdk_window_get_user_data(window, (void **) &event_widget);
/* if you know a better working way, do not hesistate to tell me */
if (event_widget &&
gtk_widget_is_ancestor(event_widget, GTK_WIDGET(doc->editor->sci)))
{
gtk_tooltip_trigger_tooltip_query(display);
}
}
}
gboolean
meta_ui_window_is_widget (MetaUI *ui,
Window xwindow)
{
GdkWindow *window;
GdkDisplay *display;
display = gdk_x11_lookup_xdisplay (ui->xdisplay);
window = gdk_x11_window_lookup_for_display (display, xwindow);
if (window)
{
void *user_data = NULL;
gdk_window_get_user_data (window, &user_data);
return user_data != NULL && user_data != ui->frames;
}
else
return FALSE;
}
static void
recreate_hits (GtkWidget* widget,
gpointer user_data)
{
GdkEventMotion* event;
gpointer container;
GList **hits;
gdouble x;
gdouble y;
gint x_i;
gint y_i;
hits = user_data;
event = (*hits)->data;
x = event->x;
y = event->y;
gdk_window_get_user_data (event->window, &container);
gtk_widget_translate_coordinates (container,
widget,
x - GTK_WIDGET (container)->allocation.x, y - GTK_WIDGET (container)->allocation.y,
&x_i,
&y_i);
event->x = x_i + widget->allocation.x;
event->y = y_i + widget->allocation.y;
if (progress_shaped_test_hit (PROGRESS_SHAPED (widget), event))
{
if (G_UNLIKELY ((*hits)->next))
{
*hits = g_list_insert_before (*hits, (*hits)->next, g_object_ref (widget));
}
else
{
*hits = g_list_append (*hits, g_object_ref (widget));
}
}
event->x = x;
event->y = y;
}
static gboolean gcal_month_view_button_release (GtkWidget *widget,
GdkEventButton *event)
{
GcalMonthViewPrivate *priv;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
gint x, y;
gint released;
priv = GCAL_MONTH_VIEW (widget)->priv;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_style_context_get_padding (context, state, &padding);
x = event->x;
y = event->y;
if (event->window != priv->event_window)
{
gpointer source_widget;
gdk_window_get_user_data (event->window, &source_widget);
gtk_widget_translate_coordinates (GTK_WIDGET (source_widget),
widget,
event->x,
event->y,
&x,
&y);
}
x = x - padding.left;
y = y - ( padding.top + priv->header_font_size );
released = 7 * ( (gint ) ( y / priv->vertical_step )) + ((gint) ( x / priv->horizontal_step ));
if (priv->clicked_cell == released)
{
priv->selected_cell = priv->clicked_cell;
priv->clicked_cell = -1;
gtk_widget_queue_draw (widget);
}
return TRUE;
}
/**
* glade_app_do_event:
* @event: the event to process.
*
* This function has to be called in an event handler for widget selection to work.
* See gdk_event_handler_set()
*
* Returns: true if the event was handled.
*/
gboolean
glade_app_do_event (GdkEvent *event)
{
GdkWindow *window = event->any.window;
GtkWidget *layout;
gpointer widget;
if (window == NULL) return FALSE;
gdk_window_get_user_data (window, &widget);
/* As a slight optimization we could replace gtk_widget_get_ancestor()
* with a custom function that only iterates trought parents with windows.
*/
if (widget && IS_GLADE_WIDGET_EVENT (event->type) &&
(layout = gtk_widget_get_ancestor (widget, GLADE_TYPE_DESIGN_LAYOUT)))
return _glade_design_layout_do_event (GLADE_DESIGN_LAYOUT (layout), event);
return FALSE;
}
/* Finds the toplevel window under the mouse pointer, if any.
*/
static GtkWidget *
find_toplevel_at_pointer (GdkDisplay *display)
{
GdkWindow *pointer_window;
GtkWidget *widget = NULL;
pointer_window = gdk_device_get_window_at_position (gtk_get_current_event_device (),
NULL, NULL);
/* The user data field of a GdkWindow is used to store a pointer
* to the widget that created it.
*/
if (pointer_window)
{
gpointer widget_ptr;
gdk_window_get_user_data (pointer_window, &widget_ptr);
widget = widget_ptr;
}
return widget ? gtk_widget_get_toplevel (widget) : NULL;
}
void
moz_drawingarea_finalize (GObject *object)
{
MozDrawingarea *drawingarea;
gpointer user_data;
g_return_if_fail(IS_MOZ_DRAWINGAREA(object));
drawingarea = MOZ_DRAWINGAREA(object);
gdk_window_get_user_data(drawingarea->inner_window, &user_data);
if (user_data) {
g_object_weak_unref(user_data, nullify_widget_pointers, drawingarea);
nullify_widget_pointers(drawingarea, NULL);
}
gdk_window_destroy(drawingarea->inner_window);
gdk_window_destroy(drawingarea->clip_window);
(* parent_class->finalize) (object);
}
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */
static CajaNotebook *
find_notebook_at_pointer (gint abs_x, gint abs_y)
{
#if GTK_CHECK_VERSION(3, 0, 0)
GdkDeviceManager *manager;
GdkDevice *pointer;
#endif
GdkWindow *win_at_pointer, *toplevel_win;
gpointer toplevel = NULL;
gint x, y;
/* FIXME multi-head */
#if GTK_CHECK_VERSION(3, 0, 0)
manager = gdk_display_get_device_manager (gdk_display_get_default ());
pointer = gdk_device_manager_get_client_pointer (manager);
win_at_pointer = gdk_device_get_window_at_position (pointer, &x, &y);
#else
win_at_pointer = gdk_window_at_pointer (&x, &y);
#endif
if (win_at_pointer == NULL)
{
/* We are outside all windows containing a notebook */
return NULL;
}
toplevel_win = gdk_window_get_toplevel (win_at_pointer);
/* get the GtkWidget which owns the toplevel GdkWindow */
gdk_window_get_user_data (toplevel_win, &toplevel);
/* toplevel should be an CajaWindow */
if (toplevel != NULL && CAJA_IS_NAVIGATION_WINDOW (toplevel))
{
return CAJA_NOTEBOOK (CAJA_NAVIGATION_WINDOW_PANE (CAJA_WINDOW (toplevel)->details->active_pane)->notebook);
}
return NULL;
}
static Bool
checkEventProc(Display *display, XEvent *event, XPointer arg)
{
checkEventContext *context = (checkEventContext *) arg;
if (event->xany.type == SelectionNotify ||
(event->xany.type == PropertyNotify &&
event->xproperty.atom == context->selAtom)) {
GdkWindow *cbWindow = gdk_window_lookup(event->xany.window);
if (cbWindow) {
GtkWidget *cbWidget = NULL;
gdk_window_get_user_data(cbWindow, (gpointer *)&cbWidget);
if (cbWidget && GTK_IS_WIDGET(cbWidget)) {
context->cbWidget = cbWidget;
return True;
}
}
}
return False;
}
// XXXdholbert -- this function is duplicated in nsPrintDialogGTK.cpp
// and needs to be unified in some generic utility class.
static GtkWindow *
get_gtk_window_for_nsiwidget(nsIWidget *widget)
{
// Get native GdkWindow
GdkWindow *gdk_win = GDK_WINDOW(widget->GetNativeData(NS_NATIVE_WIDGET));
if (!gdk_win)
return NULL;
// Get the container
gpointer user_data = NULL;
gdk_window_get_user_data(gdk_win, &user_data);
if (!user_data)
return NULL;
// Make sure its really a container
MozContainer *parent_container = MOZ_CONTAINER(user_data);
if (!parent_container)
return NULL;
// Get its toplevel
return GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(parent_container)));
}
