static gboolean
contacts_edit_focus_out (GtkWidget *widget, GdkEventFocus *event,
gpointer user_data)
{
GtkWidget *ebox = user_data;
gtk_widget_set_state (ebox, GTK_STATE_NORMAL);
return FALSE;
}
static void
cb_state_change (GtkWidget *widget, G_GNUC_UNUSED GtkStateType old_state, GOComboBox *combo_box)
{
GtkStateType const new_state = gtk_widget_get_state (widget);
if (combo_box->priv->display_widget)
gtk_widget_set_state (combo_box->priv->display_widget,
new_state);
}
/**
* gdl_dock_tablabel_activate:
* @tablabel: A #GdlDockTablabel widget
*
* Set the widget in "activated" state.
*
* Deprecated: 3.6:
*/
void
gdl_dock_tablabel_activate (GdlDockTablabel *tablabel)
{
g_return_if_fail (tablabel != NULL);
tablabel->active = TRUE;
gtk_widget_set_state (GTK_WIDGET (tablabel), GTK_STATE_NORMAL);
}
static void _each_highlightd(GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer userdata)
{
ListIterator itr = NULL;
grid_button_t *grid_button = NULL;
int *node_inx = NULL;
int color_inx;
int j=0;
GdkColor color;
grid_foreach_t *grid_foreach = userdata;
gtk_tree_model_get(model, iter, grid_foreach->node_inx_id,
&node_inx, -1);
gtk_tree_model_get(model, iter, grid_foreach->color_inx_id,
&color_inx, -1);
if (!node_inx)
return;
if (color_inx > sview_colors_cnt) {
g_print("hey the color_inx from %d was set to %d > %d\n",
grid_foreach->color_inx_id, color_inx,
sview_colors_cnt);
color_inx %= sview_colors_cnt;
}
gdk_color_parse(sview_colors[color_inx], &color);
itr = list_iterator_create(grid_foreach->button_list);
while ((grid_button = list_next(itr))) {
/*For multiple selections, need to retain all selected.
*(previously this assumed only one selected).
*/
if ((node_inx[j] < 0)
|| (grid_button->inx < node_inx[j])
|| (grid_button->inx > node_inx[j+1]))
continue;
(void)_change_button_color(grid_button, color_inx,
sview_colors[color_inx],
color, 0, 0);
if (GTK_WIDGET_STATE(grid_button->button) != GTK_STATE_NORMAL)
gtk_widget_set_state(grid_button->button,
GTK_STATE_NORMAL);
if (grid_button->inx == node_inx[j+1])
j+=2;
}
list_iterator_destroy(itr);
return;
}
/**
* gdl_dock_tablabel_deactivate:
* @tablabel: A #GdlDockTablabel widget
*
* Set the widget in "deactivated" state.
*
* Deprecated: 3.6:
*/
void
gdl_dock_tablabel_deactivate (GdlDockTablabel *tablabel)
{
g_return_if_fail (tablabel != NULL);
tablabel->active = FALSE;
/* yeah, i know it contradictive */
gtk_widget_set_state (GTK_WIDGET (tablabel), GTK_STATE_ACTIVE);
}
static gboolean _gradient_slider_leave_notify_event(GtkWidget *widget, GdkEventCrossing *event)
{
GtkDarktableGradientSlider *gslider=DTGTK_GRADIENT_SLIDER(widget);
gtk_widget_set_state(widget,GTK_STATE_NORMAL);
gslider->is_entered = FALSE;
gtk_widget_draw(widget,NULL);
DTGTK_GRADIENT_SLIDER(widget)->prev_x_root=event->x_root;
return FALSE;
}
static gboolean
hildon_time_picker_event_box_focus_out (GtkWidget *widget,
GdkEvent *event,
gpointer unused)
{
/* Draw the widget in normal state */
gtk_widget_set_state( widget, GTK_STATE_NORMAL );
return FALSE;
}
static gboolean
hildon_time_picker_event_box_focus_in (GtkWidget *widget,
GdkEvent *event,
gpointer unused)
{
/* Draw the widget in selected state so focus shows clearly. */
gtk_widget_set_state (widget, GTK_STATE_SELECTED);
return FALSE;
}
static gboolean eek_preview_leave_cb( GtkWidget* widget, GdkEventCrossing* event )
{
if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
EekPreview* preview = EEK_PREVIEW(widget);
preview->_within = FALSE;
gtk_widget_set_state( widget, GTK_STATE_NORMAL );
}
return FALSE;
}
static gboolean eek_preview_enter_cb( GtkWidget* widget, GdkEventCrossing* event )
{
if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
EekPreview* preview = EEK_PREVIEW(widget);
preview->_within = TRUE;
gtk_widget_set_state( widget, preview->_hot ? GTK_STATE_ACTIVE : GTK_STATE_PRELIGHT );
}
return FALSE;
}
static void
SetState(
GtkWidget *widget,
GtkStateType state)
{
if (state != GTK_STATE_INSENSITIVE)
gtk_widget_set_sensitive(widget,TRUE);
gtk_widget_set_state(widget,state);
}
/* desktopicon_set_selected */
void desktopicon_set_selected(DesktopIcon * desktopicon, gboolean selected)
{
#ifdef DEBUG
fprintf(stderr, "DEBUG: %p is %s\n", (void*)desktopicon,
selected ? "selected" : "deselected");
#endif
desktopicon->selected = selected;
gtk_widget_set_state(desktopicon->event, selected
? GTK_STATE_SELECTED : GTK_STATE_NORMAL);
}
static void
lyric_show_viewport_update_current_widget(LyricShowViewport *lsv)
{
if((!lsv->priv->is_pressed) && lsv->priv->current_widget)
{
GtkAllocation alc0,alc1;
const gchar *color_string = "blue";
#if GTK_CHECK_VERSION(3,2,0)
GdkRGBA color = {0};
gdk_rgba_parse(&color,color_string);
#else
GdkColor color = {0};
gdk_color_parse(color_string,&color);
#endif
if(lsv->priv->pre_widget &&
GTK_IS_WIDGET(lsv->priv->pre_widget) &&
lsv->priv->current_widget !=lsv->priv->pre_widget)
{
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_override_color(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,NULL);
gtk_widget_set_state_flags(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,FALSE);
#else
gtk_widget_modify_fg(lsv->priv->pre_widget,GTK_STATE_ACTIVE,NULL);
gtk_widget_set_state(lsv->priv->pre_widget,GTK_STATE_NORMAL);
#endif
}
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_override_color(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,&color);
gtk_widget_set_state_flags(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,FALSE);
#else
gtk_widget_modify_fg(lsv->priv->current_widget,GTK_STATE_ACTIVE,&color);
gtk_widget_set_state(lsv->priv->current_widget,GTK_STATE_ACTIVE);
#endif
gtk_widget_get_allocation(lsv->priv->current_widget,&alc0);
gtk_widget_get_allocation(lsv->priv->lyricbox,&alc1);
lsv->priv->pos = (alc0.y - alc1.y)+alc0.height/2.0;
gtk_widget_queue_resize(GTK_WIDGET(lsv));
}
}
/**
* gtk_expander_set_label_widget:
* @expander: a #GtkExpander
* @label_widget: (allow-none): the new label widget
*
* Set the label widget for the expander. This is the widget
* that will appear embedded alongside the expander arrow.
*
* Since: 2.4
**/
void
gtk_expander_set_label_widget (GtkExpander *expander,
GtkWidget *label_widget)
{
GtkExpanderPrivate *priv;
GtkWidget *widget;
g_return_if_fail (GTK_IS_EXPANDER (expander));
g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
g_return_if_fail (label_widget == NULL || label_widget->parent == NULL);
priv = expander->priv;
if (priv->label_widget == label_widget)
return;
if (priv->label_widget)
{
gtk_widget_set_state (priv->label_widget, GTK_STATE_NORMAL);
gtk_widget_unparent (priv->label_widget);
}
priv->label_widget = label_widget;
widget = GTK_WIDGET (expander);
if (label_widget)
{
priv->label_widget = label_widget;
gtk_widget_set_parent (label_widget, widget);
if (priv->prelight)
gtk_widget_set_state (label_widget, GTK_STATE_PRELIGHT);
}
if (gtk_widget_get_visible (widget))
gtk_widget_queue_resize (widget);
g_object_freeze_notify (G_OBJECT (expander));
g_object_notify (G_OBJECT (expander), "label-widget");
g_object_notify (G_OBJECT (expander), "label");
g_object_thaw_notify (G_OBJECT (expander));
}
/*! \brief Multi track sequence view button_press_event callback.
*
* \sa new_sequence_view
*
* \param w A pointer of calling widget
* \param event A pointer of the current event
* \param user_data A pointer of the current \c sequence_view_t
* \return Always \c FALSE to propagate the event.
*/
static gboolean seqv_mouse_press_event ( GtkWidget *w, GdkEventButton *event, gpointer user_data )
{
sequence_view_t *v = (sequence_view_t*) user_data;
multitracker_t *mt = v->backlink;
if(event->type == GDK_BUTTON_PRESS)
{
if( !gvr_track_test( mt->preview , v->num ) )
return FALSE;
int last_selected = mt->selected;
mt->selected = v->num;
vj_gui_disable();
// hostname, port_num from gvr
char *host = gvr_track_get_hostname( mt->preview, v->num );
int port = gvr_track_get_portnum ( mt->preview, v->num );
if(!host || port <= 0 )
{
vj_gui_enable();
return FALSE;
}
vj_gui_cb( 0, host, port );
gvr_set_master( mt->preview, v->num );
if(!gvr_track_configure( mt->preview, v->num, mt->pw,mt->ph) )
{
veejay_msg(0, "Unable to configure preview %d x %d",mt->pw , mt->ph );
}
veejay_msg(VEEJAY_MSG_INFO, "Set master to track %d", mt->master_track );
mt->master_track = v->num;
if( last_selected >= 0 && last_selected < MAX_TRACKS )
gtk_widget_set_state (mt->view[last_selected]->event_box, GTK_STATE_NORMAL);
gtk_widget_set_state (w, GTK_STATE_SELECTED);
vj_gui_enable();
}
return FALSE;
}
/*
This type indicates the current state of a widget.
GTK_STATE_NORMAL The state during normal operation.
GTK_STATE_ACTIVE The widget is currently active, such as a
GTK_STATE_PRELIGHT The mouse pointer is over the widget.
GTK_STATE_SELECTED
GTK_STATE_INSENSITIVE The state of the widget can not be altered by the user.
Its appearance will usually indicate this.
*/
int
clip_GTK_WIDGETSETSTATE(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
gint state = _clip_parni(cm,2);
CHECKOPT(2,NUMERIC_t);
CHECKCWID(cwid,GTK_IS_WIDGET);
gtk_widget_set_state(cwid->widget,state);
return 0;
err:
return 1;
}
static gboolean _mouseoff_node(GtkWidget *widget, GdkEventButton *event,
grid_button_t *grid_button)
{
gboolean rc = false;
if (grid_button->last_state == GTK_STATE_ACTIVE) {
gtk_widget_set_state(grid_button->button, GTK_STATE_ACTIVE);
rc = true;
//g_print("off of %s\n", grid_button->node_name);
}
return rc;
}
static void set_qual(GtkWidget *widget, gpointer data)
{
struct v4l2_jpegcompression jc;
memset(&jc, 0, sizeof jc);
jc.quality = gtk_range_get_value(GTK_RANGE(widget));
if (ioctl(fd, VIDIOC_S_JPEGCOMP, &jc) < 0) {
fprintf(stderr, "set JPEG quality error %d, %s\n",
errno, strerror(errno));
gtk_widget_set_state(widget, GTK_STATE_INSENSITIVE);
}
}
static gboolean
qtcMenuShellMotion(GtkWidget *widget, GdkEventMotion *event, void *data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
if (GTK_IS_MENU_SHELL(widget)) {
int pointer_x, pointer_y;
GdkModifierType pointer_mask;
gdk_window_get_pointer(gtk_widget_get_window(widget), &pointer_x,
&pointer_y, &pointer_mask);
if (GTK_IS_CONTAINER(widget)) {
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child;child = g_list_next(child)) {
if ((child->data) && GTK_IS_WIDGET(child->data) &&
(gtk_widget_get_state(GTK_WIDGET(child->data)) !=
GTK_STATE_INSENSITIVE)) {
QtcRect alloc =
qtcWidgetGetAllocation(GTK_WIDGET(child->data));
if ((pointer_x >= alloc.x) && (pointer_y >= alloc.y) &&
(pointer_x < (alloc.x + alloc.width)) &&
(pointer_y < (alloc.y + alloc.height))) {
gtk_widget_set_state(GTK_WIDGET(child->data),
GTK_STATE_PRELIGHT);
} else {
gtk_widget_set_state(GTK_WIDGET(child->data),
GTK_STATE_NORMAL);
}
}
}
if (children) {
g_list_free(children);
}
}
}
return false;
}
void plugin_blink(void)
{
if (pref_visual_beep_length)
{
if (blink_id)
g_source_remove(blink_id);
else
gtk_widget_set_state(debug_statusbar, GTK_STATE_SELECTED);
blink_id = plugin_timeout_add(geany_plugin, pref_visual_beep_length * 10,
plugin_unblink, NULL);
}
}
gboolean met_en_prelight ( GtkWidget *event_box,
GdkEventMotion *event,
gpointer pointeur )
{
if ( pointeur == NULL )
gtk_widget_set_state ( GTK_WIDGET ( GTK_BIN (event_box)->child ), GTK_STATE_PRELIGHT );
else
{
GSList *list = ( GSList* ) pointeur;
while (list )
{
GtkWidget *widget;
widget = list -> data;
gtk_widget_set_state ( GTK_WIDGET ( GTK_BIN ( widget )->child ), GTK_STATE_PRELIGHT );
list = list -> next;
}
}
return FALSE;
}
bool RenderThemeGtk::paintButton(RenderObject* object, const PaintInfo& info, const IntRect& rect)
{
if (info.context->paintingDisabled())
return false;
GtkWidget* widget = gtkButton();
IntRect buttonRect(IntPoint(), rect.size());
IntRect focusRect(buttonRect);
GtkStateType state = getGtkStateType(object);
gtk_widget_set_state(widget, state);
gtk_widget_set_direction(widget, gtkTextDirection(object->style()->direction()));
if (isFocused(object)) {
if (isEnabled(object)) {
#if !GTK_CHECK_VERSION(2, 22, 0)
GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
#endif
g_object_set(widget, "has-focus", TRUE, NULL);
}
gboolean interiorFocus = 0, focusWidth = 0, focusPadding = 0;
gtk_widget_style_get(widget,
"interior-focus", &interiorFocus,
"focus-line-width", &focusWidth,
"focus-padding", &focusPadding, NULL);
// If we are using exterior focus, we shrink the button rect down before
// drawing. If we are using interior focus we shrink the focus rect. This
// approach originates from the Mozilla theme drawing code (gtk2drawing.c).
if (interiorFocus) {
GtkStyle* style = gtk_widget_get_style(widget);
focusRect.inflateX(-style->xthickness - focusPadding);
focusRect.inflateY(-style->ythickness - focusPadding);
} else {
buttonRect.inflateX(-focusWidth - focusPadding);
buttonRect.inflateY(-focusPadding - focusPadding);
}
}
WidgetRenderingContext widgetContext(info.context, rect);
GtkShadowType shadowType = state == GTK_STATE_ACTIVE ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
widgetContext.gtkPaintBox(buttonRect, widget, state, shadowType, "button");
if (isFocused(object))
widgetContext.gtkPaintFocus(focusRect, widget, state, "button");
#if !GTK_CHECK_VERSION(2, 22, 0)
GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
#endif
g_object_set(widget, "has-focus", FALSE, NULL);
return false;
}
/*
*show_hint
* Show a new menu hint in the statusbar, and set widget state to prelight
*/
static gboolean show_hint(GtkWidget *widget, GdkEventCrossing *event, gpointer user_data)
{
MainWindow *main_window = (MainWindow *) user_data;
gtk_widget_set_state (widget, GTK_STATE_PRELIGHT);
const gchar *message = (const gchar *) g_hash_table_lookup (main_window->pmenu_hints, widget);
if (!message)
{
gphpedit_debug_message (DEBUG_MAIN_WINDOW,"%s", "Error menu hint is Null, skipping");
return FALSE;
}
main_window->context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR(main_window->appbar), message);
main_window->message_id= gtk_statusbar_push (GTK_STATUSBAR(main_window->appbar), main_window->context_id, message);
return FALSE;
}
static void
vnr_message_area_initialize(VnrMessageArea * msg_area)
{
msg_area->with_button = FALSE;
msg_area->hbox = gtk_hbox_new(FALSE, 7);
gtk_container_add(GTK_CONTAINER (msg_area), msg_area->hbox);
gtk_container_set_border_width(GTK_CONTAINER (msg_area->hbox), 7);
msg_area->image = gtk_image_new();
gtk_box_pack_start (GTK_BOX (msg_area->hbox), msg_area->image,
FALSE, FALSE, 0);
msg_area->message = gtk_label_new (NULL);
gtk_label_set_line_wrap(GTK_LABEL (msg_area->message), TRUE);
gtk_label_set_selectable(GTK_LABEL(msg_area->message), TRUE);
gtk_box_pack_start (GTK_BOX (msg_area->hbox), msg_area->message,
FALSE, FALSE, 0);
msg_area->button_box = gtk_vbutton_box_new();
gtk_box_pack_end(GTK_BOX (msg_area->hbox), msg_area->button_box,
FALSE, FALSE, 0);
msg_area->user_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(msg_area->button_box),
msg_area->user_button);
msg_area->cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(msg_area->cancel_button, "clicked",
G_CALLBACK(cancel_button_cb), msg_area);
gtk_container_add(GTK_CONTAINER(msg_area->button_box),
msg_area->cancel_button);
gtk_widget_hide_all(msg_area->hbox);
gtk_widget_set_state(GTK_WIDGET(msg_area), GTK_STATE_SELECTED);
gtk_widget_set_state(msg_area->button_box, GTK_STATE_NORMAL);
msg_area->initialized = TRUE;
}
static gboolean on_flash_status(gpointer data)
{
CN_LOGPRINTF("entry");
GtkWidget *status;
static int delay = 0;
g_return_val_if_fail((data != NULL), FALSE);
GtkProfileEntry* profileEntry = GTK_PROFILE_ENTRY(data);
if (profileEntry->statusFlashing)
{
if (--delay < 0)
{
status = GTK_WIDGET(profileEntry->status);
if (GTK_WIDGET_STATE(status) == GTK_STATE_NORMAL)
{
gtk_widget_set_state(status, GTK_STATE_ACTIVE);
delay = 0;
}
else
{
gtk_widget_set_state(status, GTK_STATE_NORMAL);
delay = 3;
}
display_update_request_screen_refresh(TEXT_ENTRY_CHANGED_LEVEL,
WAVEFORM_TYPING);
}
return TRUE;
}
else
{
return FALSE;
}
}
static void accessx_status_applet_notify_xkb_device(AccessxStatusApplet* sapplet, XkbExtensionDeviceNotifyEvent* event)
{
if (event->reason == XkbXI_IndicatorStateMask)
{
if (event->led_state &= ALT_GRAPH_LED_MASK)
{
gtk_widget_set_sensitive(sapplet->alt_graph_indicator, TRUE);
gtk_widget_set_state(sapplet->alt_graph_indicator, GTK_STATE_NORMAL);
}
else
{
gtk_widget_set_sensitive(sapplet->alt_graph_indicator, FALSE);
}
}
}
void gtk_profile_entry_set_status_flashing(GtkProfileEntry *profileEntry,
gboolean flashing)
{
g_return_if_fail(IS_GTK_PROFILE_ENTRY(profileEntry));
CN_LOGPRINTF("flashing: [%d]", flashing);
gtk_widget_set_state(GTK_WIDGET(profileEntry->status),
GTK_STATE_NORMAL);
if (flashing == TRUE && profileEntry->statusFlashing == FALSE)
{
g_timeout_add(1100, on_flash_status, profileEntry);
}
profileEntry->statusFlashing = flashing;
}
extern void sview_init_grid(bool reset_highlight)
{
static node_info_msg_t *node_info_ptr = NULL;
int rc = SLURM_SUCCESS;
node_info_t *node_ptr = NULL;
int i = 0;
ListIterator itr = NULL;
grid_button_t *grid_button = NULL;
rc = get_new_info_node(&node_info_ptr, force_refresh);
if (rc == SLURM_NO_CHANGE_IN_DATA) {
/* need to clear out old data */
set_grid_used(grid_button_list, -1, -1, false, reset_highlight);
return;
} else if (rc != SLURM_SUCCESS) {
return;
}
if (!grid_button_list) {
g_print("you need to run get_system_stats() first\n");
exit(0);
}
itr = list_iterator_create(grid_button_list);
for (i = 0; i < node_info_ptr->record_count; i++) {
int tried_again = 0;
node_ptr = &node_info_ptr->node_array[i];
try_again:
while ((grid_button = list_next(itr))) {
if (grid_button->inx != i)
continue;
grid_button->state = node_ptr->node_state;
gtk_widget_set_state(grid_button->button,
GTK_STATE_NORMAL);
grid_button->used = false;
break;
}
if (!grid_button && !tried_again) {
/* the order should never change but just to
* make sure we don't miss it */
list_iterator_reset(itr);
tried_again = 1;
goto try_again;
}
}
list_iterator_destroy(itr);
}
static void set_parm(GtkWidget *widget, gpointer data)
{
struct v4l2_streamparm parm;
memset(&parm, 0, sizeof parm);
parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
parm.parm.capture.timeperframe.numerator = 1;
parm.parm.capture.timeperframe.denominator =
gtk_range_get_value(GTK_RANGE(widget));
if (ioctl(fd, VIDIOC_S_PARM, &parm) < 0) {
fprintf(stderr, "set frame rate error %d, %s\n",
errno, strerror(errno));
gtk_widget_set_state(widget, GTK_STATE_INSENSITIVE);
}
ioctl(fd, VIDIOC_G_PARM, &parm);
gtk_range_set_value(GTK_RANGE(widget),
parm.parm.capture.timeperframe.denominator);
}
static void
gdl_dock_tablabel_init (GdlDockTablabel *tablabel)
{
GtkWidget *widget;
GtkWidget *label_widget;
widget = GTK_WIDGET (tablabel);
tablabel->drag_handle_size = DEFAULT_DRAG_HANDLE_SIZE;
tablabel->item = NULL;
label_widget = gtk_label_new ("Dock item");
gtk_container_add (GTK_CONTAINER (tablabel), label_widget);
gtk_widget_show (label_widget);
tablabel->active = FALSE;
gtk_widget_set_state (GTK_WIDGET (tablabel), GTK_STATE_ACTIVE);
}
