void DragAndDropHandler::startDrag(Ref<SelectionData>&& selection, DragOperation dragOperation, RefPtr<ShareableBitmap>&& dragImage)
{
#if GTK_CHECK_VERSION(3, 16, 0)
m_draggingSelectionData = WTFMove(selection);
GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForSelectionData(*m_draggingSelectionData);
#else
RefPtr<SelectionData> selectionData = WTFMove(selection);
GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForSelectionData(*selectionData);
#endif
GUniquePtr<GdkEvent> currentEvent(gtk_get_current_event());
GdkDragContext* context = gtk_drag_begin(m_page.viewWidget(), targetList.get(), dragOperationToGdkDragActions(dragOperation),
GDK_BUTTON_PRIMARY, currentEvent.get());
#if GTK_CHECK_VERSION(3, 16, 0)
// WebCore::EventHandler does not support more than one DnD operation at the same time for
// a given page, so we should cancel any previous operation whose context we might have
// stored, should we receive a new startDrag event before finishing a previous DnD operation.
if (m_dragContext)
gtk_drag_cancel(m_dragContext.get());
m_dragContext = context;
#else
// We don't have gtk_drag_cancel() in GTK+ < 3.16, so we use the old code.
// See https://bugs.webkit.org/show_bug.cgi?id=138468
m_draggingSelectionDataMap.set(context, WTFMove(selectionData));
#endif
if (dragImage) {
RefPtr<cairo_surface_t> image(dragImage->createCairoSurface());
// Use the center of the drag image as hotspot.
cairo_surface_set_device_offset(image.get(), -cairo_image_surface_get_width(image.get()) / 2, -cairo_image_surface_get_height(image.get()) / 2);
gtk_drag_set_icon_surface(context, image.get());
} else
gtk_drag_set_icon_default(context);
}
void PopupMenuGtk::show(const IntRect& rect, FrameView* view, int index)
{
ASSERT(client());
if (!m_popup) {
m_popup = GtkPopupMenu::create();
g_signal_connect(m_popup->platformMenu(), "unmap", G_CALLBACK(PopupMenuGtk::menuUnmapped), this);
} else
m_popup->clear();
const int size = client()->listSize();
for (int i = 0; i < size; ++i) {
if (client()->itemIsSeparator(i))
m_popup->appendSeparator();
else {
GRefPtr<GtkAction> action = adoptGRef(createGtkActionForMenuItem(i));
m_popup->appendItem(action.get());
}
}
IntPoint menuPosition = convertWidgetPointToScreenPoint(GTK_WIDGET(view->hostWindow()->platformPageClient()), view->contentsToWindow(rect.location()));
menuPosition.move(0, rect.height());
GOwnPtr<GdkEvent> currentEvent(gtk_get_current_event());
m_popup->popUp(rect.size(), menuPosition, size, index, currentEvent.get());
// GTK can refuse to actually open the menu when mouse grabs fails.
// Ensure WebCore does not go into some pesky state.
if (!gtk_widget_get_visible(m_popup->platformMenu()))
client()->popupDidHide();
}
static gboolean
panel_popup_menu_left (PanelToplevel *toplevel,
guint button,
guint32 activate_time)
{
PanelWidget *panel_widget;
GtkWidget *menu;
PanelData *panel_data;
GdkEvent *current_event;
panel_widget = panel_toplevel_get_panel_widget (toplevel);
panel_data = g_object_get_data (G_OBJECT (toplevel), "PanelData");
current_event = gtk_get_current_event ();
if (current_event->type == GDK_BUTTON_PRESS)
panel_data->insertion_pos = panel_widget_get_cursorloc (panel_widget);
else
panel_data->insertion_pos = -1;
menu = make_popup_panel_menu (panel_widget);
//gtk_widget_set_usize(GTK_WINDOW (menu),10,10);
if (!menu)
return FALSE;
gtk_menu_set_screen (GTK_MENU (menu),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, activate_time);
gtk_menu_popdown (GTK_MENU (menu));
return FALSE;
}
static gboolean
panel_popup_menu (PanelToplevel *toplevel,
guint button,
guint32 activate_time)
{
PanelWidget *panel_widget;
GtkWidget *menu;
PanelData *panel_data;
GdkEvent *current_event;
panel_widget = panel_toplevel_get_panel_widget (toplevel);
panel_data = g_object_get_data (G_OBJECT (toplevel), "PanelData");
current_event = gtk_get_current_event ();
if (current_event->type == GDK_BUTTON_PRESS)
panel_data->insert_pack_type = panel_widget_get_insert_pack_type_at_cursor (panel_widget);
else
panel_data->insert_pack_type = PANEL_OBJECT_PACK_START;
menu = make_popup_panel_menu (panel_widget);
if (!menu)
return FALSE;
gtk_menu_set_screen (GTK_MENU (menu),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, activate_time);
return TRUE;
}
/**
* ephy_node_view_popup:
* @view: an #EphyNodeView widget
* @menu: a #GtkMenu to be shown
*
* Triggers the popup of @menu in @view.
**/
void
ephy_node_view_popup (EphyNodeView *view, GtkWidget *menu)
{
GdkEvent *event;
event = gtk_get_current_event ();
if (event)
{
if (event->type == GDK_KEY_PRESS)
{
GdkEventKey *key = (GdkEventKey *) event;
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
ephy_gui_menu_position_tree_selection,
view, 0, key->time);
gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE);
}
else if (event->type == GDK_BUTTON_PRESS)
{
GdkEventButton *button = (GdkEventButton *) event;
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL,
NULL, button->button, button->time);
}
gdk_event_free (event);
}
}
/**
* WebKitWebView::populate-popup:
* @web_view: the object on which the signal is emitted
* @menu: the context menu
*
* When a context menu is about to be displayed this signal is emitted.
*
* Add menu items to #menu to extend the context menu.
*/
static void
liferea_webkit_on_menu (WebKitWebView *view, GtkMenu *menu)
{
LifereaHtmlView *htmlview;
gchar *imageUri = NULL;
gchar *linkUri = NULL;
WebKitHitTestResult* hitResult;
WebKitHitTestResultContext context;
GdkEvent *event;
event = gtk_get_current_event ();
hitResult = webkit_web_view_get_hit_test_result (view, (GdkEventButton *)event);
g_object_get (hitResult, "context", &context, NULL);
if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK)
g_object_get (hitResult, "link-uri", &linkUri, NULL);
if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE)
g_object_get (hitResult, "image-uri", &imageUri, NULL);
if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA)
g_object_get (hitResult, "media-uri", &linkUri, NULL); /* treat media as normal link */
htmlview = g_object_get_data (G_OBJECT (view), "htmlview");
liferea_htmlview_prepare_context_menu (htmlview, menu, linkUri, imageUri);
}
static void
gtk_menu_button_clicked (GtkButton *button)
{
GtkMenuButton *menu_button = GTK_MENU_BUTTON (button);
GtkMenuButtonPrivate *priv = menu_button->priv;
gboolean active = TRUE;
if (priv->menu && !gtk_widget_get_visible (priv->menu))
{
GdkEvent *event;
event = gtk_get_current_event ();
popup_menu (menu_button,
(event && event->type != GDK_BUTTON_RELEASE) ?
(GdkEventButton *) event : NULL);
if (!event ||
event->type == GDK_KEY_PRESS ||
event->type == GDK_KEY_RELEASE)
gtk_menu_shell_select_first (GTK_MENU_SHELL (priv->menu), FALSE);
if (event)
gdk_event_free (event);
}
else if (priv->popover && !gtk_widget_get_visible (priv->popover))
gtk_widget_show (priv->popover);
else
active = FALSE;
GTK_BUTTON_CLASS (gtk_menu_button_parent_class)->clicked (button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), active);
gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (button));
}
void
ephy_gui_get_current_event (GdkEventType *otype,
guint *ostate,
guint *obutton)
{
GdkEvent *event;
GdkEventType type = GDK_NOTHING;
guint state = 0, button = (guint) - 1;
event = gtk_get_current_event ();
if (event != NULL) {
type = event->type;
if (type == GDK_KEY_PRESS ||
type == GDK_KEY_RELEASE) {
state = event->key.state;
} else if (type == GDK_BUTTON_PRESS ||
type == GDK_BUTTON_RELEASE ||
type == GDK_2BUTTON_PRESS ||
type == GDK_3BUTTON_PRESS) {
button = event->button.button;
state = event->button.state;
}
gdk_event_free (event);
}
if (otype)
*otype = type;
if (ostate)
*ostate = state & gtk_accelerator_get_default_mod_mask ();
if (obutton)
*obutton = button;
}
static gboolean
ephy_removable_pixbuf_renderer_activate (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GdkRectangle icon_area;
GdkEventButton *ev = (GdkEventButton *) gtk_get_current_event();
EphyRemovablePixbufRendererPrivate *priv = EPHY_REMOVABLE_PIXBUF_RENDERER (cell)->priv;
if (priv->policy == EPHY_REMOVABLE_PIXBUF_RENDER_NEVER)
return FALSE;
get_icon_rectangle (widget, cell, cell_area, priv->close_icon, &icon_area);
if (icon_area.x <= ev->x && ev->x <= icon_area.x + icon_area.width &&
icon_area.y <= ev->y && ev->y <= icon_area.y + icon_area.height) {
g_signal_emit (cell, signals [DELETE_CLICKED], 0, path);
return TRUE;
}
return FALSE;
}
static void
day_selected_cb (GtkCalendar *calendar,
gpointer user_data)
{
cairo_rectangle_int_t rect;
GtkAllocation allocation;
GtkWidget *popover;
GdkEvent *event;
event = gtk_get_current_event ();
if (event->type != GDK_BUTTON_PRESS)
return;
gdk_window_coords_to_parent (event->button.window,
event->button.x, event->button.y,
&event->button.x, &event->button.y);
gtk_widget_get_allocation (GTK_WIDGET (calendar), &allocation);
rect.x = event->button.x - allocation.x;
rect.y = event->button.y - allocation.y;
rect.width = rect.height = 1;
popover = create_popover (GTK_WIDGET (calendar),
gtk_entry_new (),
GTK_POS_BOTTOM);
gtk_popover_set_pointing_to (GTK_POPOVER (popover), &rect);
gtk_widget_show (popover);
gdk_event_free (event);
}
static void
hippo_status_icon_activate(GtkStatusIcon *gtk_icon)
{
HippoStatusIcon *icon = HIPPO_STATUS_ICON(gtk_icon);
GdkEvent *event;
guint button;
guint32 time;
event = gtk_get_current_event();
if (event != NULL && event->type == GDK_BUTTON_PRESS)
button = event->button.button;
else
button = 1;
if (button == 1) {
HippoConnection *connection;
connection = hippo_data_cache_get_connection(icon->cache);
if (!hippo_connection_get_connected(connection)) {
HippoPlatform *platform;
platform = hippo_connection_get_platform(connection);
hippo_platform_show_disconnected_window(platform, connection);
} else {
/* the UI has to exist since we (the tray icon) are part of it */
hippo_stack_manager_show_browser(hippo_stack_manager_get(icon->cache), TRUE);
}
} else if (button == 3) {
time = gtk_get_current_event_time();
hippo_status_icon_popup_menu(gtk_icon, button, time);
}
}
void PopupMenuGtk::show(const IntRect& rect, FrameView* view, int index)
{
ASSERT(client());
if (!m_popup) {
m_popup = GtkPopupMenu::create();
g_signal_connect(m_popup->platformMenu(), "unmap", G_CALLBACK(PopupMenuGtk::menuUnmapped), this);
} else
m_popup->clear();
const int size = client()->listSize();
for (int i = 0; i < size; ++i) {
if (client()->itemIsSeparator(i))
m_popup->appendSeparator();
else {
GRefPtr<GtkAction> action = adoptGRef(createGtkActionForMenuItem(i));
m_popup->appendItem(action.get());
}
}
IntPoint menuPosition = convertWidgetPointToScreenPoint(GTK_WIDGET(view->hostWindow()->platformPageClient()), view->contentsToWindow(rect.location()));
menuPosition.move(0, rect.height());
m_popup->popUp(rect.size(), menuPosition, size, index, gtk_get_current_event());
}
static void
next_button_clicked (GtkWidget *button,
SoliPrintPreview *preview)
{
GdkEvent *event;
gint page;
gint n_pages = get_n_pages (preview);
event = gtk_get_current_event ();
if (event->button.state & GDK_SHIFT_MASK)
{
page = n_pages - 1;
}
else
{
page = preview->cur_page + preview->n_columns;
}
goto_page (preview, MIN (page, n_pages - 1));
gtk_widget_grab_focus (GTK_WIDGET (preview->layout));
gdk_event_free (event);
}
static gboolean
touch_release_in_button (GtkButton *button)
{
GtkButtonPrivate *priv;
gint width, height;
GdkEvent *event;
gdouble x, y;
priv = button->priv;
event = gtk_get_current_event ();
if (!event)
return FALSE;
if (event->type != GDK_TOUCH_END ||
event->touch.window != priv->event_window)
{
gdk_event_free (event);
return FALSE;
}
gdk_event_get_coords (event, &x, &y);
width = gdk_window_get_width (priv->event_window);
height = gdk_window_get_height (priv->event_window);
gdk_event_free (event);
if (x >= 0 && x <= width &&
y >= 0 && y <= height)
return TRUE;
return FALSE;
}
bool TextInputGTK::FilterKeyPress()
{
if (mContext) {
GdkEvent *keyEvent = gtk_get_current_event();
bool result = gtk_im_context_filter_keypress( mContext, reinterpret_cast<GdkEventKey *>(keyEvent) );
gdk_event_free( keyEvent );
return result;
}
return false;
}
/**
* Hack: Whenever the *user* wants the focus on the embed there's always going
* to be an associated GdkEvent (click on embed, enter on location entry, etc...)
* If the event doesn't exist (none being processed at the moment) we'll assume
* it's Mozilla trying to steal the focus after done loading the page. In that
* case stop the focus from moving anywhere.
*
* Yet another attempt to fix http://bugzilla.gnome.org/show_bug.cgi?id=72125
* and work around https://bugzilla.mozilla.org/show_bug.cgi?id=210373
*/
static void
mozilla_embed_child_grab_focus_cb (GtkWidget *widget, MozillaEmbed *embed)
{
GdkEvent *event;
GtkWidget *focused, *toplevel;
event = gtk_get_current_event ();
if (event)
{
gdk_event_free (event);
return;
}
/* Find the GtkWidget that currently has focus, and if it
* is the MozContainer, find the corresponding MozillaEmbed */
toplevel = gtk_widget_get_toplevel (widget);
focused = gtk_window_get_focus (GTK_WINDOW (toplevel));
if (focused && !strcmp ("MozContainer", G_OBJECT_TYPE_NAME (focused)))
{
focused = gtk_widget_get_parent (focused);
}
if (focused && GTK_WIDGET (embed) != focused)
{
g_signal_stop_emission_by_name (widget, "grab-focus");
/* Focus was trying to move, so deactivate embed which
* attempted to grab it */
if (embed->priv->focus_timeout)
{
g_source_remove (embed->priv->focus_timeout);
}
embed->priv->focus_timeout =
g_timeout_add (0, deactivate_focus_timeout_cb, embed);
if (MOZILLA_IS_EMBED (focused))
{
MozillaEmbed *membed = MOZILLA_EMBED (focused);
if (membed->priv->focus_timeout)
{
g_source_remove (membed->priv->focus_timeout);
}
/* And if the old widget was a mozille embed,
* let it grab the focus back again */
membed->priv->focus_timeout =
g_timeout_add (0, activate_focus_timeout_cb, membed);
}
}
}
/**
* ppg_ruler_draw:
* @ruler: (in): A #PpgRuler.
* @cr: (in): A #cairo_t to draw to.
*
* Handle the "draw" event for the widget. Blit the background and position
* arrow to the surface.
*
* Returns: FALSE always.
* Side effects: None.
*/
static gboolean
ppg_ruler_draw (GtkWidget *widget,
cairo_t *cr)
{
PpgRuler *ruler = (PpgRuler *)widget;
PpgRulerPrivate *priv;
GtkAllocation alloc;
gboolean ret;
gint x;
gint y;
g_return_val_if_fail(PPG_IS_RULER(ruler), FALSE);
#if GTK_CHECK_VERSION(2, 91, 0)
ret = GTK_WIDGET_CLASS(ppg_ruler_parent_class)->draw(widget, cr);
#else
ret = GTK_WIDGET_CLASS(ppg_ruler_parent_class)->
expose_event(widget, (GdkEventExpose *)gtk_get_current_event());
#endif
priv = ruler->priv;
gtk_widget_get_allocation(widget, &alloc);
/*
* Render the contents immediately if needed.
*/
if (priv->dirty) {
ppg_ruler_draw_arrow(ruler);
ppg_ruler_draw_ruler(ruler);
priv->dirty = FALSE;
}
/*
* Blit the background to the surface.
*/
cairo_rectangle(cr, 0, 0, alloc.width, alloc.height);
cairo_set_source_surface(cr, priv->ruler, 0, 0);
cairo_fill(cr);
/*
* Blit the arrow to the surface.
*/
x = (gint)(((priv->pos - priv->lower) /
(priv->upper - priv->lower) *
alloc.width) - (ARROW_SIZE / 2.0));
y = alloc.height - ARROW_SIZE - 1;
cairo_set_source_surface(cr, priv->arrow, x, y);
cairo_rectangle(cr, x, y, ARROW_SIZE, ARROW_SIZE);
cairo_fill(cr);
return ret;
}
static void menuitem_activate_handler(GtkMenuItem *menu_item)
{
printf("menuitem_activate_handler\n");
if (in_handler_flag == 0)
{
in_handler_flag = 1;
if (GTK_IS_CHECK_MENU_ITEM(menu_item))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), !(GTK_CHECK_MENU_ITEM(menu_item)->active));
GdkEvent* event = gtk_get_current_event();
if (!event || event->key.type != GDK_KEY_RELEASE) // We only look for key presses, otherwise every shortcut fires twice
SendMessage2ToClean (CcWmCOMMAND, GTK_WIDGET(menu_item), GetModifiers ());
in_handler_flag = 0;
}
}
static gboolean
should_open_in_new_tab (void)
{
/* FIXME this is duplicated */
GdkEvent *event;
event = gtk_get_current_event ();
if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) {
return event->button.button == 2;
}
gdk_event_free (event);
return FALSE;
}
void C4EditCursor::OnObjselect(GtkWidget* widget, gpointer data)
{
bool IsShiftDown = false;
GdkEvent* event = gtk_get_current_event();
if(event)
{
if(event->type == GDK_BUTTON_PRESS)
IsShiftDown = ( ((GdkEventButton*)event)->state & MK_SHIFT) != 0;
else if(event->type == GDK_KEY_PRESS)
IsShiftDown = ( ((GdkEventKey*)event)->state & MK_SHIFT) != 0;
gdk_event_free(event);
}
static_cast<ObjselItemDt*>(data)->EditCursor->DoContextObjsel(static_cast<ObjselItemDt*>(data)->Object, !IsShiftDown);
static_cast<ObjselItemDt*>(data)->EditCursor->ObjselectDelItems();
}
/* Track pop up menu. */
void EvalCcRqTRACKPOPMENU (CrossCallInfo *pcci) /* popupmenu,framePtr; BOOL result. */
{
printf("EvalCcRqTRACKPOPMENU\n");
if (GTK_IS_MENU(pcci->p1))
{
GtkWidget *popup_menu = GTK_WIDGET(pcci->p1);
GtkWidget *frame = GTK_WIDGET(pcci->p2);
GdkEvent *event = gtk_get_current_event();
gtk_menu_popup(GTK_MENU(popup_menu),NULL,NULL,NULL,NULL,
(event->type == GDK_BUTTON_PRESS) ?
((GdkEventButton *) event)->button : 0,
gdk_event_get_time(event));
}
MakeReturn1Cci (pcci,(int64_t)gtk_true());
}
void DragAndDropHandler::startDrag(const DragData& dragData, PassRefPtr<ShareableBitmap> dragImage)
{
RefPtr<DataObjectGtk> dataObject = adoptRef(dragData.platformData());
GRefPtr<GtkTargetList> targetList = adoptGRef(PasteboardHelper::defaultPasteboardHelper()->targetListForDataObject(dataObject.get()));
GUniquePtr<GdkEvent> currentEvent(gtk_get_current_event());
GdkDragContext* context = gtk_drag_begin(m_page.viewWidget(), targetList.get(), dragOperationToGdkDragActions(dragData.draggingSourceOperationMask()),
GDK_BUTTON_PRIMARY, currentEvent.get());
m_draggingDataObjects.set(context, dataObject.get());
if (dragImage) {
RefPtr<cairo_surface_t> image(dragImage->createCairoSurface());
m_dragIcon.setImage(image.get());
m_dragIcon.useForDrag(context);
} else
gtk_drag_set_icon_default(context);
}
void XAP_UnixCustomWidget::_fe::expose(XAP_UnixCustomWidget *self, GdkEventExpose *ev)
#endif
{
#if GTK_CHECK_VERSION(3,0,0)
GdkEventExpose *ev = reinterpret_cast<GdkEventExpose *>(gtk_get_current_event());
#endif
UT_Rect r(
ev->area.x,
ev->area.y,
ev->area.width,
ev->area.height
);
#if GTK_CHECK_VERSION(3,0,0)
self->m_cr = cr;
#endif
self->draw(&r);
}
void
compzillaWindow::SendKeyEvent (int eventType, nsIDOMKeyEvent *keyEv)
{
GdkEvent *gdkev = gtk_get_current_event ();
// Build up the XEvent we will send
XEvent xev = { 0 };
xev.xkey.type = eventType;
xev.xkey.serial = 0;
xev.xkey.display = mDisplay;
xev.xkey.window = mWindow;
xev.xkey.root = mAttr.root;
xev.xkey.time = gdkev->key.time;
xev.xkey.state = gdkev->key.state;
xev.xkey.keycode = gdkev->key.hardware_keycode;
xev.xkey.same_screen = True;
// Figure out who to send to
long xevMask;
switch (eventType) {
case _KeyPress:
xevMask = KeyPressMask;
break;
case KeyRelease:
xevMask = KeyReleaseMask;
break;
default:
NS_NOTREACHED ("Unknown eventType");
return;
}
SPEW_EVENT ("SendKeyEvent: %s%s win=%p, child=%p, state=%p, keycode=%u, "
"timestamp=%d\n",
eventType == _KeyPress ? "PRESS" : "",
eventType == KeyRelease ? "RELEASE" : "",
mWindow, mWindow, gdkev->key.state, gdkev->key.hardware_keycode,
gdkev->key.time);
XSendEvent (mDisplay, mWindow, True, xevMask, &xev);
keyEv->StopPropagation ();
keyEv->PreventDefault ();
}
/* Pulled from gtkcombobox.c */
static gboolean
popup_grab_on_window (GdkWindow *window,
GdkDevice *keyboard,
GdkDevice *pointer,
guint32 activate_time)
{
#if GTK_CHECK_VERSION(3,20,0)
GdkDisplay *display = gdk_display_get_default ();
GdkSeat *seat = gdk_display_get_default_seat (display);
GdkEvent *event = gtk_get_current_event ();
if (keyboard && gdk_seat_grab (seat, window, GDK_SEAT_CAPABILITY_KEYBOARD, TRUE, NULL,
event, NULL, NULL) != GDK_GRAB_SUCCESS )
#else
if (keyboard && gdk_device_grab (keyboard, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, activate_time) != GDK_GRAB_SUCCESS)
#endif
return FALSE;
#if GTK_CHECK_VERSION(3,20,0)
if (pointer && gdk_seat_grab (seat, window, GDK_SEAT_CAPABILITY_POINTER, TRUE, NULL,
event, NULL, NULL) != GDK_GRAB_SUCCESS )
#else
if (pointer && gdk_device_grab (pointer, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, activate_time) != GDK_GRAB_SUCCESS)
#endif
{
if (keyboard)
#if GTK_CHECK_VERSION(3,20,0)
gdk_seat_ungrab (seat);
#else
gdk_device_ungrab (keyboard, activate_time);
#endif
return FALSE;
}
return TRUE;
}
gboolean
nemo_event_should_open_in_new_tab (void)
{
GdkEvent *event;
event = gtk_get_current_event ();
if (event == NULL) {
return FALSE;
}
if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) {
return event->button.button == 2;
}
gdk_event_free (event);
return FALSE;
}
void DragClient::startDrag(DragImageRef image, const IntPoint& dragImageOrigin, const IntPoint& eventPos, Clipboard* clipboard, Frame* frame, bool linkDrag)
{
WebKitWebView* webView = webkit_web_frame_get_web_view(kit(frame));
RefPtr<DataObjectGtk> dataObject = clipboard->pasteboard().dataObject();
GRefPtr<GtkTargetList> targetList = adoptGRef(PasteboardHelper::defaultPasteboardHelper()->targetListForDataObject(dataObject.get()));
GOwnPtr<GdkEvent> currentEvent(gtk_get_current_event());
GdkDragContext* context = gtk_drag_begin(GTK_WIDGET(m_webView), targetList.get(), dragOperationToGdkDragActions(clipboard->sourceOperation()), 1, currentEvent.get());
webView->priv->dragAndDropHelper.startedDrag(context, dataObject.get());
// A drag starting should prevent a double-click from happening. This might
// happen if a drag is followed very quickly by another click (like in the DRT).
webView->priv->clickCounter.reset();
if (image) {
m_dragIcon.setImage(image);
m_dragIcon.useForDrag(context, IntPoint(eventPos - dragImageOrigin));
} else
gtk_drag_set_icon_default(context);
}
static void
ide_terminal_do_popup (IdeTerminal *self,
const GdkEvent *event)
{
PopupInfo *popup_info;
GtkClipboard *clipboard;
g_assert (IDE_IS_TERMINAL (self));
popup_info = g_slice_new0 (PopupInfo);
popup_info->event = event ? gdk_event_copy (event) : gtk_get_current_event ();
popup_info->terminal = g_object_ref (self);
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (self), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_contents (clipboard,
gdk_atom_intern_static_string ("TARGETS"),
popup_targets_received,
popup_info);
}
gint Meaning::_wordclick
(GtkTreeSelection *sel, gpointer data)
throw(std::bad_alloc)
{
Meaning *m = static_cast<Meaning*>(data);
GtkTreeView *tv = gtk_tree_selection_get_tree_view(sel);
GtkTreeModel *model = gtk_tree_view_get_model(tv);
m->d_display._handleSelection(GTK_WIDGET(tv));
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (sel, &model, &iter))
{
char* text;
gtk_tree_model_get (model, 0, &text, -1);
GdkEvent *e = gtk_get_current_event ();
m->d_display._handleClick((e->type == GDK_2BUTTON_PRESS), text);
}
return 0;
}
void
nautilus_pop_up_context_menu (GtkWidget *parent,
GMenu *menu,
GdkEventButton *button_event)
{
GtkWidget *gtk_menu;
g_return_if_fail (G_IS_MENU (menu));
g_return_if_fail (GTK_IS_WIDGET (parent));
gtk_menu = gtk_menu_new_from_model (G_MENU_MODEL (menu));
gtk_menu_attach_to_widget (GTK_MENU (gtk_menu), parent, NULL);
gtk_menu_popup_at_pointer (GTK_MENU (gtk_menu),
button_event ? (GdkEvent *) button_event :
gtk_get_current_event ());
g_object_ref_sink (gtk_menu);
g_object_unref (gtk_menu);
}
