/*
* Override GtkContainer's focus movement so the user can
* explicitly specify the tab order.
*/
static gint columns_focus(GtkContainer *container, GtkDirectionType dir)
{
Columns *cols;
GList *pos;
GtkWidget *focuschild;
g_return_val_if_fail(container != NULL, FALSE);
g_return_val_if_fail(IS_COLUMNS(container), FALSE);
cols = COLUMNS(container);
if (!GTK_WIDGET_DRAWABLE(cols) ||
!GTK_WIDGET_IS_SENSITIVE(cols))
return FALSE;
if (!GTK_WIDGET_CAN_FOCUS(container) &&
(dir == GTK_DIR_TAB_FORWARD || dir == GTK_DIR_TAB_BACKWARD)) {
focuschild = container->focus_child;
gtk_container_set_focus_child(container, NULL);
if (dir == GTK_DIR_TAB_FORWARD)
pos = cols->taborder;
else
pos = g_list_last(cols->taborder);
while (pos) {
GtkWidget *child = pos->data;
if (focuschild) {
if (focuschild == child) {
focuschild = NULL; /* now we can start looking in here */
if (GTK_WIDGET_DRAWABLE(child) &&
GTK_IS_CONTAINER(child) &&
!GTK_WIDGET_HAS_FOCUS(child)) {
if (gtk_container_focus(GTK_CONTAINER(child), dir))
return TRUE;
}
}
} else if (GTK_WIDGET_DRAWABLE(child)) {
if (GTK_IS_CONTAINER(child)) {
if (gtk_container_focus(GTK_CONTAINER(child), dir))
return TRUE;
} else if (GTK_WIDGET_CAN_FOCUS(child)) {
gtk_widget_grab_focus(child);
return TRUE;
}
}
if (dir == GTK_DIR_TAB_FORWARD)
pos = pos->next;
else
pos = pos->prev;
}
return FALSE;
} else
return columns_inherited_focus(container, dir);
}
static gboolean
gimp_container_grid_view_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GimpContainerGridView *view = GIMP_CONTAINER_GRID_VIEW (widget);
if (GTK_WIDGET_CAN_FOCUS (widget) && ! GTK_WIDGET_HAS_FOCUS (widget))
{
gtk_widget_grab_focus (GTK_WIDGET (widget));
return TRUE;
}
switch (direction)
{
case GTK_DIR_UP:
return gimp_container_grid_view_move_by (view, 0, -1);
case GTK_DIR_DOWN:
return gimp_container_grid_view_move_by (view, 0, 1);
case GTK_DIR_LEFT:
return gimp_container_grid_view_move_by (view, -1, 0);
case GTK_DIR_RIGHT:
return gimp_container_grid_view_move_by (view, 1, 0);
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_TAB_BACKWARD:
break;
}
return FALSE;
}
/** Give focus to the first focusable widget found in `widget'.
* @param widget Some (possibly composite) widget.
*/
static void
properties_give_focus(GtkWidget *widget, gpointer data)
{
if (GTK_WIDGET_CAN_FOCUS(widget)) {
gtk_widget_grab_focus(widget);
} else {
if (GTK_IS_CONTAINER(widget)) {
gtk_container_foreach(GTK_CONTAINER(widget), properties_give_focus, data);
}
}
}
static void gtk_sdl_init_func(GtkSDL *sdl)
{
/* puts ("before sdl init"); */
GTK_WIDGET_SET_FLAGS(sdl, GTK_CAN_FOCUS);
if ( GTK_WIDGET_CAN_FOCUS(sdl) ) {
gtk_widget_grab_focus( GTK_WIDGET(sdl) );
}
gtk_widget_set_events( GTK_WIDGET(sdl), GDK_KEY_PRESS_MASK);
/* puts ("after sdl init"); */
}
static gboolean
gimp_palette_view_button_press (GtkWidget *widget,
GdkEventButton *bevent)
{
GimpPaletteView *view = GIMP_PALETTE_VIEW (widget);
GimpPaletteEntry *entry;
if (GTK_WIDGET_CAN_FOCUS (widget) && ! GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
entry = gimp_palette_view_find_entry (view, bevent->x, bevent->y);
view->dnd_entry = entry;
if (! entry || bevent->button == 2)
return FALSE;
if (bevent->type == GDK_BUTTON_PRESS)
g_signal_emit (view, view_signals[ENTRY_CLICKED], 0,
entry, bevent->state);
switch (bevent->button)
{
case 1:
if (bevent->type == GDK_BUTTON_PRESS)
{
gimp_palette_view_select_entry (view, entry);
}
else if (bevent->type == GDK_2BUTTON_PRESS && entry == view->selected)
{
g_signal_emit (view, view_signals[ENTRY_ACTIVATED], 0, entry);
}
break;
case 3:
if (bevent->type == GDK_BUTTON_PRESS)
{
if (entry != view->selected)
gimp_palette_view_select_entry (view, entry);
g_signal_emit (view, view_signals[ENTRY_CONTEXT], 0, entry);
}
break;
default:
break;
}
return FALSE;
}
static gboolean
gimp_container_grid_view_item_selected (GtkWidget *widget,
GdkEventButton *bevent,
gpointer data)
{
if (bevent->type == GDK_BUTTON_PRESS && bevent->button == 1)
{
if (GTK_WIDGET_CAN_FOCUS (data) && ! GTK_WIDGET_HAS_FOCUS (data))
gtk_widget_grab_focus (GTK_WIDGET (data));
gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data),
GIMP_VIEW (widget)->viewable);
}
return FALSE;
}
static AtkStateSet*
goo_canvas_item_accessible_ref_state_set (AtkObject *accessible)
{
GooCanvasItem *item;
GooCanvas *canvas;
AtkStateSet *state_set;
GObject *object;
gboolean can_focus = FALSE;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), NULL);
state_set = ATK_OBJECT_CLASS (goo_canvas_item_accessible_parent_class)->ref_state_set (accessible);
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));
if (!object)
{
atk_state_set_add_state (state_set, ATK_STATE_DEFUNCT);
return state_set;
}
item = GOO_CANVAS_ITEM (object);
canvas = goo_canvas_item_get_canvas (item);
if (!canvas)
return state_set;
if (goo_canvas_item_is_visible (item))
{
atk_state_set_add_state (state_set, ATK_STATE_VISIBLE);
if (goo_canvas_item_accessible_is_item_on_screen (item))
atk_state_set_add_state (state_set, ATK_STATE_SHOWING);
}
g_object_get (item, "can-focus", &can_focus, NULL);
if (GTK_WIDGET_CAN_FOCUS (GTK_WIDGET (canvas)) && can_focus)
{
atk_state_set_add_state (state_set, ATK_STATE_FOCUSABLE);
if (GTK_WIDGET_HAS_FOCUS (canvas)
&& canvas->focused_item == item)
atk_state_set_add_state (state_set, ATK_STATE_FOCUSED);
}
return state_set;
}
JNIEXPORT jboolean JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_gtkWidgetCanFocus
(JNIEnv *env, jobject obj)
{
void *ptr;
jboolean retval;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
retval = GTK_WIDGET_CAN_FOCUS((GTK_WIDGET (ptr)));
gdk_threads_leave ();
return retval;
}
static void
gb_label_get_focus_targets (GtkWidget * widget,
GList ** focus_targets)
{
if (GTK_WIDGET_CAN_FOCUS (widget) && GB_IS_GB_WIDGET (widget))
{
*focus_targets = g_list_insert_sorted (*focus_targets,
(gchar*) gtk_widget_get_name (widget),
g_str_equal);
}
if (GTK_IS_CONTAINER (widget))
{
gtk_container_forall (GTK_CONTAINER (widget),
(GtkCallback) gb_label_get_focus_targets,
focus_targets);
}
}
/* Set focus to a widget */
int
clip_GTK_WIDGETSETFOCUS(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
CHECKCWID(cwid,GTK_IS_WIDGET);
if (GTK_IS_WINDOW(cwid->widget) && cwid->widget->window)
{
gdk_window_raise(cwid->widget->window);
_clip_retl(cm, TRUE);
}
else
{
if (GTK_WIDGET_CAN_FOCUS(cwid->widget))
{
gtk_window_set_focus(GTK_WINDOW(gtk_widget_get_toplevel(cwid->widget)), cwid->widget);
_clip_retl(cm, TRUE);
}
else
_clip_retl(cm, FALSE);
}
return 0;
err:
return 1;
}
/** Give focus to the first focusable widget found in `widget'.
* @param widget Some (possibly composite) widget.
*/
static void
properties_give_focus(GtkWidget *widget, gpointer data)
{
#if GTK_CHECK_VERSION(2,20,0)
if (gtk_widget_get_can_focus(widget)) {
#else
if (GTK_WIDGET_CAN_FOCUS(widget)) {
#endif
gtk_widget_grab_focus(widget);
} else {
if (GTK_IS_CONTAINER(widget)) {
gtk_container_foreach(GTK_CONTAINER(widget), properties_give_focus, data);
}
}
}
static void
clear_dialog_globals()
{
if (object_part != NULL) {
gtk_container_remove(GTK_CONTAINER(dialog_vbox), object_part);
object_part = NULL;
}
g_list_free(current_objects);
current_objects = NULL;
current_dia = NULL;
}
void
object_properties_show(Diagram *dia, DiaObject *obj)
{
GList *tmp = NULL;
tmp = g_list_append(tmp, obj);
object_list_properties_show(dia, tmp);
g_list_free(tmp);
}
/**
* e_canvas_item_grab_focus:
* @item: A canvas item.
* @widget_too: Whether or not to grab the widget-level focus too
*
* Makes the specified item take the keyboard focus, so all keyboard
* events will be sent to it. If the canvas widget itself did not have
* the focus and @widget_too is %TRUE, it grabs that focus as well.
**/
void
e_canvas_item_grab_focus (GnomeCanvasItem *item, gboolean widget_too)
{
GnomeCanvasItem *focused_item;
GdkEvent ev;
g_return_if_fail (item != NULL);
g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
g_return_if_fail (GTK_WIDGET_CAN_FOCUS (GTK_WIDGET (item->canvas)));
focused_item = item->canvas->focused_item;
if (focused_item) {
ev.focus_change.type = GDK_FOCUS_CHANGE;
ev.focus_change.window = GTK_LAYOUT (item->canvas)->bin_window;
ev.focus_change.send_event = FALSE;
ev.focus_change.in = FALSE;
emit_event (item->canvas, &ev);
}
item->canvas->focused_item = item;
if (widget_too && !GTK_WIDGET_HAS_FOCUS (GTK_WIDGET(item->canvas))) {
gtk_widget_grab_focus (GTK_WIDGET (item->canvas));
}
if (item) {
ev.focus_change.type = GDK_FOCUS_CHANGE;
ev.focus_change.window = GTK_LAYOUT (item->canvas)->bin_window;
ev.focus_change.send_event = FALSE;
ev.focus_change.in = TRUE;
emit_event (item->canvas, &ev);
}
}
bool ChromeClient::canTakeFocus(FocusDirection)
{
return GTK_WIDGET_CAN_FOCUS(m_webView);
}
AtkRelationSet*
gail_label_ref_relation_set (AtkObject *obj)
{
GtkWidget *widget;
AtkRelationSet *relation_set;
g_return_val_if_fail (GAIL_IS_LABEL (obj), NULL);
widget = GTK_ACCESSIBLE (obj)->widget;
if (widget == NULL)
/*
* State is defunct
*/
return NULL;
relation_set = ATK_OBJECT_CLASS (parent_class)->ref_relation_set (obj);
if (!atk_relation_set_contains (relation_set, ATK_RELATION_LABEL_FOR))
{
/*
* Get the mnemonic widget
*
* The relation set is not updated if the mnemonic widget is changed
*/
GtkWidget *mnemonic_widget = GTK_LABEL (widget)->mnemonic_widget;
if (mnemonic_widget)
{
AtkObject *accessible_array[1];
AtkRelation* relation;
if (!GTK_WIDGET_CAN_FOCUS (mnemonic_widget))
{
/*
* Handle the case where a GtkFileChooserButton is specified as the
* mnemonic widget. use the combobox which is a child of the
* GtkFileChooserButton as the mnemonic widget. See bug #359843.
*/
if (GTK_IS_BOX (mnemonic_widget))
{
GList *list, *tmpl;
list = gtk_container_get_children (GTK_CONTAINER (mnemonic_widget));
if (g_list_length (list) == 2)
{
tmpl = g_list_last (list);
if (GTK_IS_COMBO_BOX(tmpl->data))
{
mnemonic_widget = GTK_WIDGET(tmpl->data);
}
}
g_list_free (list);
}
/*
* Handle the case where a GnomeIconEntry is specified as the
* mnemonic widget. use the button which is a grandchild of the
* GnomeIconEntry as the mnemonic widget. See bug #133967.
*/
else if (GTK_IS_BOX (mnemonic_widget))
{
GList *list;
list = gtk_container_get_children (GTK_CONTAINER (mnemonic_widget));
if (g_list_length (list) == 1)
{
if (GTK_IS_ALIGNMENT (list->data))
{
GtkWidget *temp_widget;
temp_widget = GTK_BIN (list->data)->child;
if (GTK_IS_BUTTON (temp_widget))
mnemonic_widget = temp_widget;
}
else if (GTK_IS_HBOX (list->data))
{
GtkWidget *temp_widget;
temp_widget = GTK_WIDGET (list->data);
g_list_free (list);
list = gtk_container_get_children (GTK_CONTAINER (temp_widget));
if (GTK_IS_COMBO (list->data))
{
mnemonic_widget = GTK_WIDGET (list->data);
}
}
}
g_list_free (list);
}
}
accessible_array[0] = gtk_widget_get_accessible (mnemonic_widget);
relation = atk_relation_new (accessible_array, 1,
ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relation_set, relation);
/*
* Unref the relation so that it is not leaked.
*/
g_object_unref (relation);
}
}
return relation_set;
}
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
bool xWidgetInternal::isFocusable()
{
return GTK_WIDGET_CAN_FOCUS(getGtkWidget());
}
static void
hildon_find_toolbar_init (HildonFindToolbar *self)
{
GtkToolItem *label_container;
GtkToolItem *entry_combo_box_container;
GtkAlignment *alignment;
HildonFindToolbarPrivate *priv = HILDON_FIND_TOOLBAR_GET_PRIVATE (self);
g_assert (priv);
/* Create the label */
priv->label = gtk_label_new (_("ecdg_ti_find_toolbar_label"));
gtk_misc_set_padding (GTK_MISC (priv->label), FIND_LABEL_XPADDING,
FIND_LABEL_YPADDING);
label_container = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (label_container),
priv->label);
gtk_widget_show_all (GTK_WIDGET (label_container));
gtk_toolbar_insert (GTK_TOOLBAR (self), label_container, -1);
/* ComboBoxEntry for search prefix string / history list */
priv->entry_combo_box = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new ());
#ifdef MAEMO_GTK
g_signal_connect (hildon_find_toolbar_get_entry(priv),
"invalid_input",
G_CALLBACK(hildon_find_toolbar_emit_invalid_input), self);
#endif
entry_combo_box_container = gtk_tool_item_new ();
alignment = GTK_ALIGNMENT (gtk_alignment_new (0, 0.5, 1, 0));
gtk_tool_item_set_expand (entry_combo_box_container, TRUE);
gtk_container_add (GTK_CONTAINER (alignment),
GTK_WIDGET (priv->entry_combo_box));
gtk_container_add (GTK_CONTAINER (entry_combo_box_container),
GTK_WIDGET (alignment));
gtk_widget_show_all(GTK_WIDGET (entry_combo_box_container));
gtk_toolbar_insert (GTK_TOOLBAR (self), entry_combo_box_container, -1);
g_signal_connect (hildon_find_toolbar_get_entry (priv),
"activate",
G_CALLBACK(hildon_find_toolbar_entry_activate), self);
/* Find button */
priv->find_button = gtk_tool_button_new (
gtk_image_new_from_icon_name ("qgn_toolb_browser_gobutton",
HILDON_ICON_SIZE_TOOLBAR),
"Find");
g_signal_connect (priv->find_button, "clicked",
G_CALLBACK(hildon_find_toolbar_emit_search), self);
gtk_widget_show_all( GTK_WIDGET(priv->find_button));
gtk_toolbar_insert ( GTK_TOOLBAR(self), priv->find_button, -1);
gtk_widget_set_size_request (GTK_WIDGET (priv->find_button), 72, -1);
if ( GTK_WIDGET_CAN_FOCUS( GTK_BIN(priv->find_button)->child) )
GTK_WIDGET_UNSET_FLAGS(
GTK_BIN(priv->find_button)->child, GTK_CAN_FOCUS);
/* Separator */
priv->separator = gtk_separator_tool_item_new();
gtk_widget_show(GTK_WIDGET(priv->separator));
gtk_toolbar_insert (GTK_TOOLBAR(self), priv->separator, -1);
/* Close button */
priv->close_button = gtk_tool_button_new (
gtk_image_new_from_icon_name ("qgn_toolb_gene_close",
HILDON_ICON_SIZE_TOOLBAR),
"Close");
gtk_widget_set_size_request (GTK_WIDGET (priv->close_button), 72, -1);
g_signal_connect(priv->close_button, "clicked",
G_CALLBACK(hildon_find_toolbar_emit_close), self);
gtk_widget_show_all(GTK_WIDGET(priv->close_button));
gtk_toolbar_insert (GTK_TOOLBAR(self), priv->close_button, -1);
if ( GTK_WIDGET_CAN_FOCUS( GTK_BIN(priv->close_button)->child) )
GTK_WIDGET_UNSET_FLAGS(
GTK_BIN(priv->close_button)->child, GTK_CAN_FOCUS);
}
static gboolean
gimp_palette_view_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GimpPaletteView *view = GIMP_PALETTE_VIEW (widget);
GimpPalette *palette;
palette = GIMP_PALETTE (GIMP_VIEW (view)->renderer->viewable);
if (GTK_WIDGET_CAN_FOCUS (widget) && ! GTK_WIDGET_HAS_FOCUS (widget))
{
gtk_widget_grab_focus (widget);
if (! view->selected && palette->colors)
gimp_palette_view_select_entry (view, palette->colors->data);
return TRUE;
}
if (view->selected)
{
GimpViewRendererPalette *renderer;
gint skip = 0;
renderer = GIMP_VIEW_RENDERER_PALETTE (GIMP_VIEW (view)->renderer);
switch (direction)
{
case GTK_DIR_UP:
skip = -renderer->columns;
break;
case GTK_DIR_DOWN:
skip = renderer->columns;
break;
case GTK_DIR_LEFT:
skip = -1;
break;
case GTK_DIR_RIGHT:
skip = 1;
break;
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_TAB_BACKWARD:
return FALSE;
}
if (skip != 0)
{
GimpPaletteEntry *entry;
gint position;
position = view->selected->position + skip;
entry = g_list_nth_data (palette->colors, position);
if (entry)
gimp_palette_view_select_entry (view, entry);
}
return TRUE;
}
return FALSE;
}
