gboolean
keypress(GtkWidget* w, GdkEventKey *ev, Client *c) {
guint i, focus;
gboolean processed = FALSE;
if(ev->type != GDK_KEY_PRESS)
return FALSE;
if(GTK_WIDGET_HAS_FOCUS(c->searchbar))
focus = SearchBar;
else if(GTK_WIDGET_HAS_FOCUS(c->uribar))
focus = UriBar;
else
focus = Browser;
updatewinid(c);
for(i = 0; i < LENGTH(keys); i++) {
if(focus & keys[i].focus
&& gdk_keyval_to_lower(ev->keyval) == keys[i].keyval
&& CLEANMASK(ev->state) == keys[i].mod
&& keys[i].func) {
keys[i].func(c, &(keys[i].arg));
processed = TRUE;
}
}
return processed;
}
static void
send_focus_event (MateIconTextItem *iti, gboolean in)
{
MateIconTextItemPrivate *priv;
GtkWidget *widget;
gboolean has_focus;
GdkEvent fake_event;
g_return_if_fail (in == FALSE || in == TRUE);
priv = iti->_priv;
if (priv->entry == NULL) {
g_assert (!in);
return;
}
widget = GTK_WIDGET (priv->entry);
has_focus = GTK_WIDGET_HAS_FOCUS (widget);
if (has_focus == in) {
return;
}
memset (&fake_event, 0, sizeof (fake_event));
fake_event.focus_change.type = GDK_FOCUS_CHANGE;
fake_event.focus_change.window = widget->window;
fake_event.focus_change.in = in;
gtk_widget_event (widget, &fake_event);
/* FIXME: this is failing */
#if 0
g_return_if_fail (GTK_WIDGET_HAS_FOCUS (widget) == in);
#endif
}
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;
}
/*
we get here when the entry in a cell is changed (typed a digit), we
copy it to the entry above the sheet.
*/
static void
show_entry(GtkWidget *widget, Register_Window *rw)
{
char *text;
GtkSheet *sheet;
GtkWidget * sheet_entry;
gint row, col;
if(widget==NULL|| rw==NULL)
{
printf("Warning show_entry(%x,%x)\n",(unsigned int)widget,(unsigned int)rw);
return;
}
if(!GTK_WIDGET_HAS_FOCUS(widget)) return;
sheet=GTK_SHEET(rw->register_sheet);
sheet_entry = gtk_sheet_get_entry(sheet);
row=sheet->active_cell.row; col=sheet->active_cell.col;
if(gpsim_get_register_name(gp->pic_id,rw->type, rw->row_to_address[row]+col))
{
if((text=gtk_entry_get_text (GTK_ENTRY(sheet_entry))))
gtk_entry_set_text(GTK_ENTRY(rw->entry), text);
}
}
/* Kreslicí funkce spoleèná pro gtk_ev_draw() a gtk_ev_expose(), která kreslí
* hlavní okno widgetu */
static void gtk_ev_paint(GtkEv *ev, GdkRectangle *area)
{
GtkWidget *widget;
g_return_if_fail(ev);
g_return_if_fail(area);
widget = GTK_WIDGET(ev);
if(!GTK_WIDGET_DRAWABLE(widget))
return; /* Not visible and mapped */
gdk_window_clear_area(widget->window, area->x, area->y, area->width,
area->height);
gdk_gc_set_clip_rectangle(widget->style->black_gc, area);
/* Èerný rámeèek kolem vnitøního okna */
gdk_draw_rectangle(widget->window, widget->style->black_gc, FALSE,
ev->ev_win_rect.x-1, ev->ev_win_rect.y-1,
ev->ev_win_rect.width+2, ev->ev_win_rect.height+2);
gdk_gc_set_clip_rectangle(widget->style->black_gc, NULL);
/* Text (seznam zachycených událostí) */
if(ev->list) {
GdkRectangle intersect;
if(gdk_rectangle_intersect(&ev->list_rect, area, &intersect)) {
static const gint space = 2;
gint line, step, first_baseline;
GList *p;
GdkFont *font = gtk_style_get_font(widget->style);
step = font->ascent + font->descent + space;
first_baseline = ev->list_rect.y + font->ascent + space;
line = 0;
for(p = ev->list; p; p = g_list_next(p)) {
gchar **pev = p->data;
gint i;
for(i = 0; pev[i]; i++) {
gtk_paint_string(widget->style, widget->window,
widget->state, &intersect, widget,
(char *) "ev", ev->list_rect.x,
first_baseline + line*step, pev[i]);
line++;
}
if(first_baseline + line*step - 2*step >
intersect.y + intersect.height)
break;
}
}
}
/* Grafické zvýraznìní, kdy¾ má okno focus */
if(GTK_WIDGET_HAS_FOCUS(widget))
gtk_paint_focus(widget->style, widget->window, GTK_WIDGET_STATE(widget),
area, widget, (char *) "ev", 0, 0, -1, -1);
}
static void vdlist_scroll_to_row(ViewDir *vd, FileData *fd, gfloat y_align)
{
GtkTreeIter iter;
#if GTK_CHECK_VERSION(2,20,0)
if (gtk_widget_get_realized(vd->view) && vd_find_row(vd, fd, &iter))
#else
if (GTK_WIDGET_REALIZED(vd->view) && vd_find_row(vd, fd, &iter))
#endif
{
GtkTreeModel *store;
GtkTreePath *tpath;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
tpath = gtk_tree_model_get_path(store, &iter);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(vd->view), tpath, NULL, TRUE, y_align, 0.0);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
gtk_tree_path_free(tpath);
#if GTK_CHECK_VERSION(2,20,0)
if (!gtk_widget_has_focus(vd->view)) gtk_widget_grab_focus(vd->view);
#else
if (!GTK_WIDGET_HAS_FOCUS(vd->view)) gtk_widget_grab_focus(vd->view);
#endif
}
}
static gboolean
transparent_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
{
GtkWidget *focus_child = NULL;
gint border_width, x, y, width, height;
gboolean retval = FALSE;
gdk_window_clear_area (widget->window, event->area.x, event->area.y,
event->area.width, event->area.height);
if (GTK_WIDGET_CLASS (parent_class)->expose_event)
retval = GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
if (GTK_CONTAINER (widget)->focus_child)
focus_child = GTK_CONTAINER (GTK_CONTAINER (widget)->focus_child)->focus_child;
if (focus_child && GTK_WIDGET_HAS_FOCUS (focus_child))
{
border_width = GTK_CONTAINER (widget)->border_width;
x = widget->allocation.x + border_width;
y = widget->allocation.y + border_width;
width = widget->allocation.width - 2 * border_width;
height = widget->allocation.height - 2 * border_width;
gtk_paint_focus (widget->style, widget->window,
GTK_WIDGET_STATE (widget),
&event->area, widget, "tray_icon",
x, y, width, height);
}
return retval;
}
/* This should only be called when toggle_button->draw_indicator
* is true.
*/
static void
gtk_check_item_paint (GtkWidget *widget,
GdkRectangle *area)
{
GtkCheckItem *check_item;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CHECK_ITEM (widget));
check_item = GTK_CHECK_ITEM (widget);
if (GTK_WIDGET_DRAWABLE (widget))
{
gint border_width;
gtk_check_item_draw_indicator (check_item, area);
border_width = GTK_CONTAINER (widget)->border_width;
if (GTK_WIDGET_HAS_FOCUS (widget))
gtk_paint_focus (widget->style, widget->window,
NULL, widget, "checkitem",
border_width + widget->allocation.x,
border_width + widget->allocation.y,
widget->allocation.width - 2 * border_width - 1,
widget->allocation.height - 2 * border_width - 1);
}
}
static void
clearlooks_set_widget_parameters (GtkWidget *widget,
const GtkStyle *style,
GtkStateType state_type,
WidgetParameters *params)
{
params->style_functions = &(clearlooks_style_class->style_functions[CLEARLOOKS_STYLE (style)->style]);
params->active = (state_type == GTK_STATE_ACTIVE);
params->prelight = (state_type == GTK_STATE_PRELIGHT);
params->disabled = (state_type == GTK_STATE_INSENSITIVE);
params->state_type = (ClearlooksStateType)state_type;
params->corners = CR_CORNER_ALL;
params->ltr = ge_widget_is_ltr ((GtkWidget*)widget);
params->focus = widget && GTK_WIDGET_HAS_FOCUS (widget);
params->is_default = widget && GE_WIDGET_HAS_DEFAULT (widget);
params->enable_glow = FALSE;
params->radius = CLEARLOOKS_STYLE (style)->radius;
if (!params->active && widget && GE_IS_TOGGLE_BUTTON (widget))
params->active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
params->xthickness = style->xthickness;
params->ythickness = style->ythickness;
/* This is used in GtkEntry to fake transparency. The reason to do this
* is that the entry has it's entire background filled with base[STATE].
* This is not a very good solution as it will eg. fail if one changes
* the background color of a notebook. */
params->parentbg = CLEARLOOKS_STYLE (style)->colors.bg[state_type];
clearlooks_get_parent_bg (widget, ¶ms->parentbg);
}
/*
* 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);
}
const char *
autouri(Client *c) {
if(GTK_WIDGET_HAS_FOCUS(c->uribar))
return gtk_entry_get_text(GTK_ENTRY(c->uribar));
else if(c->linkhover)
return c->linkhover;
return NULL;
}
gboolean nsgtk_widget_has_focus(GtkWidget *widget)
{
#if GTK_CHECK_VERSION(2,20,0)
return gtk_widget_has_focus(widget);
#else
return GTK_WIDGET_HAS_FOCUS(widget);
#endif
}
static gboolean
is_user_searching (void)
{
if (GTK_WIDGET_HAS_FOCUS(search_entry))
return TRUE;
return FALSE;
}
/**
* gva_main_search_entry_notify_cb:
* @entry: the search entry
* @pspec: a #GParamSpec
*
* Handler for #GObject::notify signals to the search entry.
*
* Hides the search interface when the search entry loses input focus.
**/
void
gva_main_search_entry_notify_cb (GtkEntry *entry,
GParamSpec *pspec)
{
if (g_str_equal (pspec->name, "has-focus"))
if (!GTK_WIDGET_HAS_FOCUS (GTK_ENTRY (entry)))
gtk_widget_hide (GVA_WIDGET_MAIN_SEARCH_HBOX);
}
void cl_draw_combobox_entry (GtkStyle *style, GdkWindow *window,
GtkStateType state_type, GtkShadowType shadow_type,
GdkRectangle *area,
GtkWidget *widget, const gchar *detail,
gint x, gint y, gint width, gint height)
{
CLRectangle r;
gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
gboolean has_focus = GTK_WIDGET_HAS_FOCUS (widget);
int cl = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND,
cr = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
GdkGC *bg_gc = cl_get_window_bg_gc(widget);
if (rtl)
{
if (!has_focus)
{
x -= 1;
width +=1;
}
}
else
{
width += 2;
if (has_focus) width--; /* this gives us a 2px focus line at the right side. */
}
cl_rectangle_set_entry (&r, style, state_type,
cl, cr, cl, cr,
has_focus);
gdk_gc_set_clip_rectangle (bg_gc, area);
gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
gdk_gc_set_clip_rectangle (bg_gc, NULL);
/* Draw "sunken" look when border thickness is more than 2 pixels. */
if (style->xthickness > 2 && style->ythickness > 2)
{
cl_draw_inset (style, window, widget, area, x, y, width, height,
cl, cr, cl, cr);
y++;
x++;
width-=2;
height-=2;
}
cl_rectangle_set_clip_rectangle (&r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
cl_draw_shadow (window, widget, style, x, y, width, height, &r);
cl_rectangle_reset_clip_rectangle (&r);
}
static void
cell_renderer_caption_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
GtkCellRendererState flags)
{
(* GTK_CELL_RENDERER_CLASS (cell_renderer_caption_parent_class)->render)
(cell, window, widget, background_area, cell_area, expose_area, flags);
if ((flags & (GTK_CELL_RENDERER_SELECTED|GTK_CELL_RENDERER_PRELIT)) != 0)
{
cairo_t *cr;
int radius = 5;
int x, y, w, h;
GtkStateType state;
x = background_area->x;
y = background_area->y;
w = background_area->width;
h = background_area->height;
/* sometimes width is -1 - not sure what to do here */
if (w == -1)
return;
if ((flags & GTK_CELL_RENDERER_SELECTED) != 0)
{
if (GTK_WIDGET_HAS_FOCUS (widget))
state = GTK_STATE_SELECTED;
else
state = GTK_STATE_ACTIVE;
}
else
state = GTK_STATE_PRELIGHT;
/* add rounded corners to the selection indicator */
cr = gdk_cairo_create (GDK_DRAWABLE (window));
gdk_cairo_set_source_color (cr, &widget->style->base[GTK_STATE_NORMAL]);
cairo_rectangle (cr, x, y, w, h);
cairo_arc (cr, x + radius, y + radius, radius, M_PI, M_PI * 1.5);
cairo_arc (cr, x + w - radius, y + radius, radius, M_PI * 1.5, 0);
cairo_arc (cr, x + w - radius, y + h - radius, radius, 0, M_PI * 0.5);
cairo_arc (cr, x + radius, y + h - radius, radius, M_PI * 0.5, M_PI);
cairo_close_path (cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_fill (cr);
cairo_destroy (cr);
}
}
static gboolean
mouse_capplet_check_button_button_press (GtkWidget *widget, GdkEventButton *event)
{
if (event->type == GDK_BUTTON_PRESS) {
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
gtk_button_pressed (GTK_BUTTON (widget));
}
return TRUE;
}
static void
tile_leave (GtkButton * widget)
{
if (GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_set_state (GTK_WIDGET (widget), TILE_STATE_FOCUSED);
else
gtk_widget_set_state (GTK_WIDGET (widget), GTK_STATE_NORMAL);
TILE (widget)->entered = FALSE;
}
/* Returns .T. if widget has a focus */
int
clip_GTK_WIDGETHASFOCUS(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
CHECKCWID(cwid,GTK_IS_WIDGET);
_clip_retl(cm, GTK_WIDGET_HAS_FOCUS(cwid->widget));
return 0;
err:
return 1;
}
void quick_search_clear_entry(QuickSearch *qsearch)
{
qsearch->entry_entered = FALSE;
if (GTK_WIDGET_HAS_FOCUS(qsearch->entry))
entry_focus_in(qsearch->entry, NULL, qsearch);
else
entry_focus_out(qsearch->entry, NULL, qsearch);
gtk_label_set_text(GTK_LABEL(qsearch->status_label), "");
gtk_widget_hide(qsearch->clear_btn);
}
static gint bar_pane_gps_event(GtkWidget *bar, GdkEvent *event)
{
PaneGPSData *pgd;
pgd = g_object_get_data(G_OBJECT(bar), "pane_data");
if (!pgd) return FALSE;
if (GTK_WIDGET_HAS_FOCUS(pgd->widget)) return gtk_widget_event(GTK_WIDGET(pgd->widget), event);
return FALSE;
}
static int
gth_empty_list_button_press (GtkWidget *widget,
GdkEventButton *event)
{
GthEmptyList *self = (GthEmptyList*) widget;
if (event->window == self->priv->bin_window)
if (! GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
return FALSE;
}
/* Button press event handler for the image view */
static gboolean
image_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
{
ImageView *view;
ImageViewPrivate *priv;
GdkCursor *cursor;
view = IMAGE_VIEW (widget);
priv = view->priv;
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
if (priv->dragging)
return FALSE;
switch (event->button) {
case 1:
cursor = cursor_get (widget, CURSOR_HAND_CLOSED);
gdk_window_set_cursor (widget->window, cursor);
gdk_cursor_unref (cursor);
priv->dragging = TRUE;
priv->drag_anchor_x = event->x;
priv->drag_anchor_y = event->y;
priv->drag_ofs_x = priv->xofs;
priv->drag_ofs_y = priv->yofs;
return TRUE;
case 4:
image_view_set_zoom (view,
priv->zoomx * IMAGE_VIEW_ZOOM_MULTIPLIER,
priv->zoomy * IMAGE_VIEW_ZOOM_MULTIPLIER,
TRUE, event->x, event->y);
return TRUE;
case 5:
image_view_set_zoom (view,
priv->zoomx / IMAGE_VIEW_ZOOM_MULTIPLIER,
priv->zoomy / IMAGE_VIEW_ZOOM_MULTIPLIER,
TRUE, event->x, event->y);
return TRUE;
default:
break;
}
return FALSE;
}
static gboolean
bst_canvas_link_child_event (GnomeCanvasItem *item,
GdkEvent *event)
{
BstCanvasLink *clink;
GtkWidget *widget = GTK_WIDGET (item->canvas);
gboolean handled = FALSE;
clink = BST_CANVAS_LINK (item);
switch (event->type)
{
case GDK_ENTER_NOTIFY:
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
handled = TRUE;
break;
case GDK_LEAVE_NOTIFY:
handled = TRUE;
break;
case GDK_KEY_PRESS:
switch (event->key.keyval)
{
case 'L':
gnome_canvas_item_lower (item, 1);
GNOME_CANVAS_NOTIFY (item);
break;
case 'l':
gnome_canvas_item_lower_to_bottom (item);
GNOME_CANVAS_NOTIFY (item);
break;
case 'R':
gnome_canvas_item_raise (item, 1);
GNOME_CANVAS_NOTIFY (item);
break;
case 'r':
gnome_canvas_item_raise_to_top (item);
GNOME_CANVAS_NOTIFY (item);
break;
}
handled = TRUE;
break;
case GDK_KEY_RELEASE:
handled = TRUE;
break;
default:
break;
}
return handled;
}
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 int
clist_get_focus_row(GtkCList *clist)
{
g_return_val_if_fail(clist, -1);
if (
GTK_WIDGET_HAS_FOCUS(GTK_WIDGET(clist))
&& clist->focus_row >= 0
&& clist->focus_row < clist->rows
) {
return clist->focus_row;
}
return -1;
}
gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event)
{
PaneKeywordsData *pkd;
pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
if (!pkd) return FALSE;
#if GTK_CHECK_VERSION(2,20,0)
if (gtk_widget_has_focus(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
#else
if (GTK_WIDGET_HAS_FOCUS(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
#endif
return FALSE;
}
static void entry_grab_focus(GtkWidget *entry, GdkEventKey *event)
{
int pos;
if (!GTK_WIDGET_HAS_FOCUS(entry) &&
(event->state & (GDK_CONTROL_MASK|GDK_MOD1_MASK)) == 0) {
/* normal key pressed, change focus to entry field -
the whole text is selected after grab_focus so we need
to unselect it so that the text isn't replaced with the
next key press */
pos = gtk_editable_get_position(GTK_EDITABLE(entry));
gtk_widget_grab_focus(entry);
gtk_editable_select_region(GTK_EDITABLE(entry), pos, pos);
}
}
static gboolean blink_cursor(gpointer ptr)
{
if(!cursor_blink)
return FALSE;
if(cMode & CURSOR_MODE_ENABLED)
{
if(GTK_WIDGET_HAS_FOCUS(terminal))
cMode ^= CURSOR_MODE_SHOW;
else
cMode |= CURSOR_MODE_SHOW;
gtk_widget_queue_draw_area(terminal,rCursor.x,rCursor.y,rCursor.width,rCursor.height);
}
return TRUE;
}
static gboolean
thunar_text_renderer_entry_menu_popdown_timer (gpointer user_data)
{
ThunarTextRenderer *text_renderer = THUNAR_TEXT_RENDERER (user_data);
GDK_THREADS_ENTER ();
/* check if we still have the keyboard focus */
if (G_UNLIKELY (!GTK_WIDGET_HAS_FOCUS (text_renderer->entry)))
thunar_text_renderer_editing_done (GTK_CELL_EDITABLE (text_renderer->entry), text_renderer);
GDK_THREADS_LEAVE ();
return FALSE;
}
