/* * 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; }