static void
hildon_caption_set_focus (GtkWindow *window,
GtkWidget *widget,
GtkWidget *caption)
{
HildonCaptionPrivate *priv = HILDON_CAPTION_GET_PRIVATE (caption);
/* check if ancestor gone */
if (! widget)
{
return;
}
/* Try to find caption among the ancestors of widget */
if (gtk_widget_is_ancestor (widget, caption))
{
priv->is_focused = TRUE;
gtk_widget_queue_draw (caption);
return;
}
if (priv->is_focused == TRUE)
{
/* Caption wasn't found, so cannot focus */
priv->is_focused = FALSE;
gtk_widget_queue_draw (caption);
}
}
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);
}
}
}
void
ViewAutoDrawer_Close(ViewAutoDrawer *that) // IN
{
GtkWindow *window;
GtkWidget *focus;
GtkWidget *toplevel;
g_return_if_fail(VIEW_IS_AUTODRAWER(that));
toplevel = gtk_widget_get_toplevel(GTK_WIDGET(that));
if (!toplevel || !gtk_widget_is_toplevel(toplevel)) {
// The autoDrawer cannot function properly without a toplevel.
return;
}
window = GTK_WINDOW(toplevel);
focus = gtk_window_get_focus(window);
if (focus && gtk_widget_is_ancestor(focus, that->priv->evBox)) {
gtk_window_set_focus(window, NULL);
}
that->priv->forceClosing = TRUE;
that->priv->closeConnection =
g_timeout_add(ViewDrawer_GetCloseTime(&that->parent) +
that->priv->delayValue,
(GSourceFunc)ViewAutoDrawerOnCloseDelay, that);
/* This change happens programmatically. Always react to it immediately. */
ViewAutoDrawerUpdate(that, TRUE);
}
static void
removeEventHandler(BalloonEval *beval)
{
/* LINTED: avoid warning: dubious operation on enum */
# if GTK_CHECK_VERSION(3,0,0)
g_signal_handlers_disconnect_by_func(G_OBJECT(beval->target),
FUNC2GENERIC(target_event_cb),
beval);
# else
gtk_signal_disconnect_by_func((GtkObject*)(beval->target),
GTK_SIGNAL_FUNC(target_event_cb),
beval);
# endif
if (gtk_socket_id == 0 && gui.mainwin != NULL
&& gtk_widget_is_ancestor(beval->target, gui.mainwin))
{
/* LINTED: avoid warning: dubious operation on enum */
# if GTK_CHECK_VERSION(3,0,0)
g_signal_handlers_disconnect_by_func(G_OBJECT(gui.mainwin),
FUNC2GENERIC(mainwin_event_cb),
beval);
# else
gtk_signal_disconnect_by_func((GtkObject*)(gui.mainwin),
GTK_SIGNAL_FUNC(mainwin_event_cb),
beval);
# endif
}
}
static void
addEventHandler(GtkWidget *target, BalloonEval *beval)
{
/*
* Connect to the generic "event" signal instead of the individual
* signals for each event type, because the former is emitted earlier.
* This allows us to catch events independently of the signal handlers
* in gui_gtk_x11.c.
*/
g_signal_connect(G_OBJECT(target), "event",
G_CALLBACK(target_event_cb),
beval);
/*
* Nasty: Key press events go to the main window thus the drawing area
* will never see them. This means we have to connect to the main window
* as well in order to catch those events.
*/
if (gtk_socket_id == 0 && gui.mainwin != NULL
&& gtk_widget_is_ancestor(target, gui.mainwin))
{
g_signal_connect(G_OBJECT(gui.mainwin), "event",
G_CALLBACK(mainwin_event_cb),
beval);
}
}
static gboolean
gstyle_slidein_event_box_key_pressed_cb (GstyleSlidein *self,
GdkEventKey *event,
GtkWidget *widget)
{
GtkWidget *focus;
g_assert (GSTYLE_IS_SLIDEIN (self));
g_assert (event != NULL);
g_assert (GTK_IS_WIDGET (widget));
focus = gtk_window_get_focus (GTK_WINDOW (gtk_widget_get_toplevel (widget)));
if (focus == NULL)
return GDK_EVENT_PROPAGATE;
if (event->keyval == GDK_KEY_Escape && !GTK_IS_ENTRY (focus))
{
gstyle_slidein_reveal_slide (self, FALSE);
return GDK_EVENT_STOP;
}
if (gtk_widget_is_ancestor (focus, widget))
return gtk_widget_event (focus, (GdkEvent*) event);
return GDK_EVENT_PROPAGATE;
}
/* This is called when the grab is broken for
* either the dock, or the scale itself */
static void
gtk_scale_button_grab_notify (GtkScaleButton *button,
gboolean was_grabbed)
{
GdkDisplay *display;
GtkScaleButtonPrivate *priv;
if (was_grabbed != FALSE)
return;
priv = button->priv;
if (!GTK_WIDGET_HAS_GRAB (priv->dock))
return;
if (gtk_widget_is_ancestor (gtk_grab_get_current (), priv->dock))
return;
display = gtk_widget_get_display (priv->dock);
gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
gtk_grab_remove (priv->dock);
/* hide again */
gtk_widget_hide (priv->dock);
priv->timeout = FALSE;
}
static void
gcal_year_view_size_allocate (GtkWidget *widget,
GtkAllocation *alloc)
{
GcalYearViewPrivate *priv = GCAL_YEAR_VIEW (widget)->priv;
GtkStyleContext *context;
gint padding_left;
context = gtk_widget_get_style_context (widget);
gtk_style_context_save (context);
gtk_style_context_add_class (context, "year-navigator");
gtk_style_context_get (context, gtk_widget_get_state_flags (widget), "padding-left", &padding_left, NULL);
gtk_style_context_restore (context);
priv->popover_mode = (alloc->width < NAVIGATOR_CELL_WIDTH * 4 + padding_left * 8 + SIDEBAR_PREFERRED_WIDTH);
if (priv->popover_mode && !gtk_widget_is_ancestor (priv->events_sidebar, priv->popover))
{
g_object_ref (priv->sidebar);
gtk_container_remove (GTK_CONTAINER (widget), priv->sidebar);
gtk_container_add (GTK_CONTAINER (priv->popover), priv->sidebar);
g_object_unref (priv->sidebar);
gtk_widget_show_all (priv->sidebar);
popover_closed_cb (GCAL_YEAR_VIEW (widget), GTK_POPOVER (priv->popover));
}
else if (!priv->popover_mode && gtk_widget_is_ancestor (priv->events_sidebar, priv->popover))
{
g_object_ref (priv->sidebar);
gtk_container_remove (GTK_CONTAINER (priv->popover), priv->sidebar);
gtk_box_pack_end (GTK_BOX (widget), priv->sidebar, FALSE, TRUE, 0);
g_object_unref (priv->sidebar);
gtk_widget_show (priv->sidebar);
g_signal_handlers_block_by_func (priv->popover, popover_closed_cb, widget);
gtk_widget_hide (priv->popover);
g_signal_handlers_unblock_by_func (priv->popover, popover_closed_cb, widget);
}
GTK_WIDGET_CLASS (gcal_year_view_parent_class)->size_allocate (widget, alloc);
}
static void
gb_search_box_workbench_set_focus (GbSearchBox *self,
GtkWidget *focus,
GbWorkbench *workbench)
{
g_return_if_fail (GB_IS_SEARCH_BOX (self));
g_return_if_fail (!focus || GTK_IS_WIDGET (focus));
g_return_if_fail (GB_IS_WORKBENCH (workbench));
if (!focus ||
(!gtk_widget_is_ancestor (focus, GTK_WIDGET (self)) &&
!gtk_widget_is_ancestor (focus, GTK_WIDGET (self->popover))))
{
gtk_entry_set_text (GTK_ENTRY (self->entry), "");
}
else
{
gb_search_box_popover_set_visible (self, TRUE);
}
}
static void
gimp_popup_grab_notify (GtkWidget *widget,
gboolean was_grabbed)
{
if (was_grabbed)
return;
/* ignore grabs on one of our children, like a scrollbar */
if (gtk_widget_is_ancestor (gtk_grab_get_current (), widget))
return;
g_signal_emit (widget, popup_signals[CANCEL], 0);
}
static void
removeEventHandler(BalloonEval *beval)
{
g_signal_handlers_disconnect_by_func(G_OBJECT(beval->target),
FUNC2GENERIC(target_event_cb),
beval);
if (gtk_socket_id == 0 && gui.mainwin != NULL
&& gtk_widget_is_ancestor(beval->target, gui.mainwin))
{
g_signal_handlers_disconnect_by_func(G_OBJECT(gui.mainwin),
FUNC2GENERIC(mainwin_event_cb),
beval);
}
}
gboolean
widget_is_tab_label(GtkWidget *page, GtkWidget * widget)
{
GtkWidget * real_widget = widget;
g_return_val_if_fail(GTK_IS_WIDGET(widget), FALSE);
widget = gtk_notebook_get_menu_label(GTK_NOTEBOOK(page->parent), page);
if (!(widget))
widget = gtk_notebook_get_tab_label(GTK_NOTEBOOK(page->parent), page);
if ((real_widget) && (widget) && (real_widget != widget) && (!(gtk_widget_is_ancestor(real_widget, widget))))
return FALSE;
return TRUE;
}
static void
ide_frame_close_page_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdePage *page = (IdePage *)object;
g_autoptr(IdeFrame) self = user_data;
g_autoptr(GError) error = NULL;
GtkWidget *toplevel;
GtkWidget *focus;
gboolean had_focus = FALSE;
g_assert (IDE_IS_PAGE (page));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (IDE_IS_FRAME (self));
if (!ide_page_agree_to_close_finish (page, result, &error))
{
g_message ("%s", error->message);
return;
}
/* Keep track of whether or not the widget had focus (which
* would happen if we were activated from a keybinding.
*/
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (page));
if (GTK_IS_WINDOW (toplevel) &&
NULL != (focus = gtk_window_get_focus (GTK_WINDOW (toplevel))) &&
(focus == GTK_WIDGET (page) ||
gtk_widget_is_ancestor (focus, GTK_WIDGET (page))))
had_focus = TRUE;
/* Now we can destroy the child */
gtk_widget_destroy (GTK_WIDGET (page));
/* We don't want to leave the widget focus in an indeterminate
* state so we immediately focus the next child in the stack.
* But only do so if we had focus previously.
*/
if (had_focus)
{
IdePage *visible_child = ide_frame_get_visible_child (self);
if (visible_child != NULL)
gtk_widget_grab_focus (GTK_WIDGET (visible_child));
}
}
static void
removeEventHandler(BalloonEval *beval)
{
/* LINTED: avoid warning: dubious operation on enum */
gtk_signal_disconnect_by_func((GtkObject*)(beval->target),
GTK_SIGNAL_FUNC(target_event_cb),
beval);
if (gtk_socket_id == 0 && gui.mainwin != NULL
&& gtk_widget_is_ancestor(beval->target, gui.mainwin))
{
/* LINTED: avoid warning: dubious operation on enum */
gtk_signal_disconnect_by_func((GtkObject*)(gui.mainwin),
GTK_SIGNAL_FUNC(mainwin_event_cb),
beval);
}
}
/**
* gtk_menu_button_set_align_widget:
* @menu_button: a #GtkMenuButton
* @align_widget: (allow-none): a #GtkWidget
*
* Sets the #GtkWidget to use to line the menu with when popped up.
* Note that the @align_widget must contain the #GtkMenuButton itself.
*
* Setting it to %NULL means that the menu will be aligned with the
* button itself.
*
* Note that this property is only used with menus currently,
* and not for popovers.
*
* Since: 3.6
*/
void
gtk_menu_button_set_align_widget (GtkMenuButton *menu_button,
GtkWidget *align_widget)
{
GtkMenuButtonPrivate *priv;
g_return_if_fail (GTK_IS_MENU_BUTTON (menu_button));
g_return_if_fail (align_widget == NULL || gtk_widget_is_ancestor (GTK_WIDGET (menu_button), align_widget));
priv = menu_button->priv;
if (priv->align_widget == align_widget)
return;
set_align_widget_pointer (menu_button, align_widget);
g_object_notify (G_OBJECT (menu_button), "align-widget");
}
/*! \brief Creates a library dialog.
* \par Function Description
* This function create the library dialog if it is not already created.
* It does not show the dialog, use ghid_library_window_show for that.
*
*/
void
ghid_library_window_create (GHidPort * out)
{
GtkWidget *current_tab, *entry_filter;
GtkNotebook *notebook;
if (library_window)
return;
library_window = (GtkWidget *)g_object_new (GHID_TYPE_LIBRARY_WINDOW, NULL);
g_signal_connect (library_window,
"response",
G_CALLBACK (library_window_callback_response), NULL);
g_signal_connect (G_OBJECT (library_window), "configure_event",
G_CALLBACK (library_window_configure_event_cb), NULL);
gtk_window_set_default_size (GTK_WINDOW (library_window),
ghidgui->library_window_width,
ghidgui->library_window_height);
gtk_window_set_title (GTK_WINDOW (library_window), _("PCB Library"));
gtk_window_set_wmclass (GTK_WINDOW (library_window), "PCB_Library",
"PCB");
gtk_widget_realize (library_window);
if (Settings.AutoPlace)
gtk_widget_set_uposition (GTK_WIDGET (library_window), 10, 10);
gtk_editable_select_region (GTK_EDITABLE
(GHID_LIBRARY_WINDOW (library_window)->
entry_filter), 0, -1);
/* Set the focus to the filter entry only if it is in the current
displayed tab */
notebook = GTK_NOTEBOOK (GHID_LIBRARY_WINDOW (library_window)->viewtabs);
current_tab = gtk_notebook_get_nth_page (notebook,
gtk_notebook_get_current_page
(notebook));
entry_filter =
GTK_WIDGET (GHID_LIBRARY_WINDOW (library_window)->entry_filter);
if (gtk_widget_is_ancestor (entry_filter, current_tab))
{
gtk_widget_grab_focus (entry_filter);
}
}
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);
}
}
}
static gboolean
on_notebook_scroll_event_null_cb (GtkWidget *widget, GdkEventScroll *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkWidget* child;
GtkWidget* originator;
if (!gtk_notebook_get_current_page (notebook))
return FALSE;
child = gtk_notebook_get_nth_page (notebook, gtk_notebook_get_current_page (notebook));
originator = gtk_get_event_widget ((GdkEvent *)event);
/* ignore scroll events from the content of the page */
if (!originator || gtk_widget_is_ancestor (originator, child))
return FALSE;
return TRUE;
}
static void
addEventHandler(GtkWidget *target, BalloonEval *beval)
{
/*
* Connect to the generic "event" signal instead of the individual
* signals for each event type, because the former is emitted earlier.
* This allows us to catch events independently of the signal handlers
* in gui_gtk_x11.c.
*/
# if GTK_CHECK_VERSION(3,0,0)
g_signal_connect(G_OBJECT(target), "event",
G_CALLBACK(target_event_cb),
beval);
# else
/* Should use GTK_OBJECT() here, but that causes a lint warning... */
gtk_signal_connect((GtkObject*)(target), "event",
GTK_SIGNAL_FUNC(target_event_cb),
beval);
# endif
/*
* Nasty: Key press events go to the main window thus the drawing area
* will never see them. This means we have to connect to the main window
* as well in order to catch those events.
*/
if (gtk_socket_id == 0 && gui.mainwin != NULL
&& gtk_widget_is_ancestor(target, gui.mainwin))
{
# if GTK_CHECK_VERSION(3,0,0)
g_signal_connect(G_OBJECT(gui.mainwin), "event",
G_CALLBACK(mainwin_event_cb),
beval);
# else
gtk_signal_connect((GtkObject*)(gui.mainwin), "event",
GTK_SIGNAL_FUNC(mainwin_event_cb),
beval);
# endif
}
}
gboolean
tab_label_is_current_page(GtkWidget *page, GtkWidget * widget)
{
gint current_num = 0;
GtkWidget *current_page = NULL;
GtkWidget *current_label = NULL;
current_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(page->parent));
if (current_num ==-1)
return FALSE;
current_page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(page->parent), current_num);
if (!(current_page))
return FALSE;
current_label = gtk_notebook_get_tab_label(GTK_NOTEBOOK(page->parent), current_page);
if ((current_label == NULL) || (current_label != widget) && (!gtk_widget_is_ancestor(widget, current_label)))
return FALSE;
return TRUE;
}
/* Tab scrolling was removed from GtkNotebook in gtk 3, so reimplement it here */
static gboolean
scroll_event_cb (GtkWidget *widget,
GdkEventScroll *event,
gpointer user_data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkWidget *child, *event_widget, *action_widget;
if ((event->state & gtk_accelerator_get_default_mod_mask ()) != 0)
return FALSE;
child = gtk_notebook_get_nth_page (notebook, gtk_notebook_get_current_page (notebook));
if (child == NULL)
return FALSE;
event_widget = gtk_get_event_widget ((GdkEvent *) event);
/* Ignore scroll events from the content of the page */
if (event_widget == NULL ||
event_widget == child ||
gtk_widget_is_ancestor (event_widget, child))
return FALSE;
/* And also from the action widgets */
action_widget = gtk_notebook_get_action_widget (notebook, GTK_PACK_START);
if (event_widget == action_widget ||
(action_widget != NULL && gtk_widget_is_ancestor (event_widget, action_widget)))
return FALSE;
action_widget = gtk_notebook_get_action_widget (notebook, GTK_PACK_END);
if (event_widget == action_widget ||
(action_widget != NULL && gtk_widget_is_ancestor (event_widget, action_widget)))
return FALSE;
switch (event->direction) {
case GDK_SCROLL_RIGHT:
case GDK_SCROLL_DOWN:
gtk_notebook_next_page (notebook);
return TRUE;
case GDK_SCROLL_LEFT:
case GDK_SCROLL_UP:
gtk_notebook_prev_page (notebook);
return TRUE;
case GDK_SCROLL_SMOOTH:
switch (gtk_notebook_get_tab_pos (notebook)) {
case GTK_POS_LEFT:
case GTK_POS_RIGHT:
if (event->delta_y > 0)
gtk_notebook_next_page (notebook);
else if (event->delta_y < 0)
gtk_notebook_prev_page (notebook);
break;
case GTK_POS_TOP:
case GTK_POS_BOTTOM:
if (event->delta_x > 0)
gtk_notebook_next_page (notebook);
else if (event->delta_x < 0)
gtk_notebook_prev_page (notebook);
break;
}
return TRUE;
}
return FALSE;
}
static VALUE
rg_ancestor_p(VALUE self, VALUE ancestor)
{
return CBOOL2RVAL(gtk_widget_is_ancestor(_SELF(self), _SELF(ancestor)));
}
static void
ViewAutoDrawerUpdate(ViewAutoDrawer *that, // IN
gboolean immediate) // IN
{
ViewAutoDrawerPrivate *priv = that->priv;
GtkWidget *toplevel = gtk_widget_get_toplevel(GTK_WIDGET(that));
GtkWindow *window;
GtkAllocation allocation;
if (!toplevel || !gtk_widget_is_toplevel(toplevel)) {
// The autoDrawer cannot function properly without a toplevel.
return;
}
window = GTK_WINDOW(toplevel);
/*
* We decide to open the drawer by OR'ing several conditions. Evaluating a
* condition can have the side-effect of setting 'immediate' to TRUE, so we
* cannot stop evaluating the conditions after we have found one to be TRUE.
*/
priv->opened = FALSE;
/* Is the AutoDrawer pinned? */
if (priv->pinned) {
immediate = TRUE;
priv->opened = TRUE;
}
/* Is the mouse cursor inside the event box? */
{
int x;
int y;
gtk_widget_get_pointer(priv->evBox, &x, &y);
gtk_widget_get_allocation(priv->evBox, &allocation);
g_assert(gtk_container_get_border_width( GTK_CONTAINER(priv->evBox))
== 0);
if ( (guint)x < (guint)allocation.width
&& (guint)y < (guint)allocation.height) {
priv->opened = TRUE;
}
}
/* If there is a focused widget, is it inside the event box? */
{
GtkWidget *focus;
focus = gtk_window_get_focus(window);
if (focus && gtk_widget_is_ancestor(focus, priv->evBox)) {
/*
* Override the default 'immediate' to make sure the 'over' widget
* immediately appears along with the widget the focused widget.
*/
immediate = TRUE;
priv->opened = TRUE;
}
}
/* If input is grabbed, is it on behalf of a widget inside the event box? */
if (!priv->inputUngrabbed) {
GtkWidget *grabbed = NULL;
if (gtk_window_has_group (window)) {
GtkWindowGroup *group = gtk_window_get_group (window);
grabbed = gtk_window_group_get_current_grab (group);
}
if (!grabbed) {
grabbed = gtk_grab_get_current();
}
if (grabbed && GTK_IS_MENU(grabbed)) {
/*
* With cascading menus, the deepest menu owns the grab. Traverse the
* menu hierarchy up until we reach the attach widget for the whole
* hierarchy.
*/
for (;;) {
GtkWidget *menuAttach;
GtkWidget *menuItemParent;
menuAttach = gtk_menu_get_attach_widget(GTK_MENU(grabbed));
if (!menuAttach) {
/*
* It is unfortunately not mandatory for a menu to have a proper
* attach widget set.
*/
break;
}
grabbed = menuAttach;
if (!GTK_IS_MENU_ITEM(grabbed)) {
break;
}
menuItemParent = gtk_widget_get_parent(grabbed);
g_return_if_fail(menuItemParent);
if (!GTK_IS_MENU(menuItemParent)) {
break;
}
grabbed = menuItemParent;
}
}
if (grabbed && gtk_widget_is_ancestor(grabbed, priv->evBox)) {
/*
* Override the default 'immediate' to make sure the 'over' widget
* immediately appears along with the widget the grab happens on
* behalf of.
*/
immediate = TRUE;
priv->opened = TRUE;
}
}
if (priv->delayConnection) {
g_source_remove(priv->delayConnection);
}
if (priv->forceClosing) {
ViewAutoDrawerEnforce(that, TRUE);
} else if (immediate) {
ViewAutoDrawerEnforce(that, FALSE);
} else {
priv->delayConnection = g_timeout_add(priv->delayValue,
(GSourceFunc)ViewAutoDrawerOnEnforceDelay, that);
}
}
static gboolean window_keypress_cb (GtkWidget * widget, GdkEventKey * event, void * unused)
{
switch (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK))
{
case 0:;
GtkWidget * focused = gtk_window_get_focus ((GtkWindow *) window);
/* escape key returns focus to playlist */
if (event->keyval == GDK_KEY_Escape)
{
if (! focused || ! gtk_widget_is_ancestor (focused, (GtkWidget *) UI_PLAYLIST_NOTEBOOK))
gtk_widget_grab_focus (playlist_get_treeview (aud_playlist_get_active ()));
return FALSE;
}
/* single-key shortcuts; must not interfere with text entry */
if (focused && GTK_IS_ENTRY (focused))
return FALSE;
switch (event->keyval)
{
case 'z':
aud_drct_pl_prev ();
return TRUE;
case 'x':
aud_drct_play ();
return TRUE;
case 'c':
case ' ':
aud_drct_pause ();
return TRUE;
case 'v':
aud_drct_stop ();
return TRUE;
case 'b':
aud_drct_pl_next ();
return TRUE;
case GDK_KEY_Left:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () - 5000);
return TRUE;
case GDK_KEY_Right:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () + 5000);
return TRUE;
}
return FALSE;
case GDK_CONTROL_MASK:
switch (event->keyval)
{
case GDK_KEY_ISO_Left_Tab:
case GDK_KEY_Tab:
aud_playlist_set_active ((aud_playlist_get_active () + 1) %
aud_playlist_count ());
break;
default:
return FALSE;
}
break;
case (GDK_CONTROL_MASK | GDK_SHIFT_MASK):
switch (event->keyval)
{
case GDK_KEY_ISO_Left_Tab:
case GDK_KEY_Tab:
aud_playlist_set_active (aud_playlist_get_active () ?
aud_playlist_get_active () - 1 : aud_playlist_count () - 1);
break;
default:
return FALSE;
}
break;
case GDK_MOD1_MASK:
switch (event->keyval)
{
case GDK_KEY_Left:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () - 5000);
break;
case GDK_KEY_Right:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () + 5000);
break;
default:
return FALSE;
}
default:
return FALSE;
}
return TRUE;
}