/* Set up the property editors in the dialog. */ static void setup_dialog (GtkBuilder *dialog) { GtkRadioButton *radio; gboolean touchpad_present, mouse_present; /* Orientation radio buttons */ radio = GTK_RADIO_BUTTON (WID ("left_handed_radio")); g_settings_bind (mouse_settings, "left-handed", radio, "active", G_SETTINGS_BIND_DEFAULT); /* explicitly connect to button-release so that you can change orientation with either button */ g_signal_connect (WID ("right_handed_radio"), "button_release_event", G_CALLBACK (orientation_radio_button_release_event), NULL); g_signal_connect (WID ("left_handed_radio"), "button_release_event", G_CALLBACK (orientation_radio_button_release_event), NULL); /* Double-click time */ g_settings_bind (mouse_settings, "double-click", gtk_range_get_adjustment (GTK_RANGE (WID ("double_click_scale"))), "value", G_SETTINGS_BIND_DEFAULT); /* Mouse section */ mouse_present = mouse_is_present (); gtk_widget_set_visible (WID ("mouse_vbox"), mouse_present); g_signal_connect (WID ("pointer_speed_scale"), "value-changed", G_CALLBACK (pointer_speed_scale_event), dialog); /* Trackpad page */ touchpad_present = touchpad_is_present (); gtk_widget_set_visible (WID ("touchpad_vbox"), touchpad_present); g_settings_bind (touchpad_settings, "touchpad-enabled", WID ("touchpad_enabled_switch"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (touchpad_settings, "touchpad-enabled", WID ("touchpad_options_box"), "sensitive", G_SETTINGS_BIND_GET); g_settings_bind (touchpad_settings, "disable-while-typing", WID ("disable_w_typing_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (touchpad_settings, "tap-to-click", WID ("tap_to_click_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (touchpad_settings, "natural-scroll", WID ("natural_scroll_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (WID ("touchpad_pointer_speed_scale"), "value-changed", G_CALLBACK (pointer_speed_scale_event), dialog); if (touchpad_present) { synaptics_check_capabilities (dialog); setup_scrollmethod_radios (dialog); } g_signal_connect (WID ("two_finger_scroll_toggle"), "toggled", G_CALLBACK (scrollmethod_changed_event), dialog); }
static gboolean on_range_change_value (GtkRange *range, GtkScrollType scroll, gdouble value, NimfCandidate *candidate) { g_debug (G_STRLOC ": %s", G_STRFUNC); NimfEngine *engine = nimf_service_ic_get_engine (candidate->target); g_return_val_if_fail (candidate->target && NIMF_IS_ENGINE (engine), FALSE); NimfEngineClass *engine_class; GtkAdjustment *adjustment; gdouble lower, upper; adjustment = gtk_range_get_adjustment (range); lower = gtk_adjustment_get_lower (adjustment); upper = gtk_adjustment_get_upper (adjustment); if (value < lower) value = lower; if (value > upper - 1) value = upper - 1; engine_class = NIMF_ENGINE_GET_CLASS (engine); if (engine_class->candidate_scrolled) engine_class->candidate_scrolled (engine, candidate->target, value); return FALSE; }
Scrollbar::Scrollbar(bool horizontal) { XOJ_INIT_TYPE(Scrollbar); #ifdef ENABLE_OS if(horizontal) { this->scrollbar = os_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL); } else { this->scrollbar = os_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL); } #else if (horizontal) { this->scrollbar = gtk_hscrollbar_new(NULL); } else { this->scrollbar = gtk_vscrollbar_new(NULL); } #endif g_object_ref(this->scrollbar); this->listener = NULL; this->adj = gtk_range_get_adjustment(GTK_RANGE(this->scrollbar)); gtk_adjustment_set_step_increment(this->adj, 20); this->value = 50; this->setMax(100); this->setValue(this->value); g_signal_connect(this->adj, "value-changed", G_CALLBACK(scrolled), this); }
static gboolean cb_timeout (gpointer data) { MateVolumeAppletDock *dock = data; GtkAdjustment *adj; gfloat volume; gboolean res = TRUE; if (!dock->timeout) return FALSE; adj = gtk_range_get_adjustment (dock->scale); volume = gtk_range_get_value (dock->scale); volume += dock->direction * gtk_adjustment_get_step_increment (adj); if (volume <= gtk_adjustment_get_lower (adj)) { volume = gtk_adjustment_get_lower (adj); res = FALSE; } else if (volume >= gtk_adjustment_get_upper (adj)) { volume = gtk_adjustment_get_upper (adj); res = FALSE; } gtk_range_set_value (dock->scale, volume); if (!res) dock->timeout = 0; return res; }
static void on_tclist_dialog_ok (GtkWidget * widget, GbWidgetNewData * data) { GtkWidget *new_widget, *spinbutton, *dialog, *label; #ifndef GTK_HAVE_FEATURES_1_1_4 GtkAdjustment *adjustment; #endif gint cols, i; dialog = gtk_widget_get_toplevel (widget); /* Only call callback if placeholder/fixed widget is still there */ if (gb_widget_can_finish_new (data)) { spinbutton = gtk_object_get_data (GTK_OBJECT (dialog), "cols"); g_return_if_fail (spinbutton != NULL); cols = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinbutton)); new_widget = tclist_new (cols); gtk_clist_column_titles_show (GTK_CLIST (new_widget)); for (i = 0; i < cols; i++) { label = new_label (new_widget); gtk_clist_set_column_widget (GTK_CLIST (new_widget), i, label); gtk_clist_set_column_width (GTK_CLIST (new_widget), i, 80); } /* Connect signals for redrawing. */ /* The CList doesn't have scrollbars in 1.1.4+. We'll have to do this another way at some point. */ #ifndef GTK_HAVE_FEATURES_1_1_4 adjustment = gtk_range_get_adjustment (GTK_RANGE (GTK_CLIST (new_widget)->hscrollbar)); gtk_signal_connect_after (GTK_OBJECT (adjustment), "value_changed", (GtkSignalFunc) hadjustment_value_changed, new_widget); adjustment = gtk_range_get_adjustment (GTK_RANGE (GTK_CLIST (new_widget)->vscrollbar)); gtk_signal_connect_after (GTK_OBJECT (adjustment), "value_changed", (GtkSignalFunc) vadjustment_value_changed, new_widget); #endif gb_widget_initialize (new_widget, data); (*data->callback) (new_widget, data); } gtk_widget_destroy (dialog); }
static void start_cb (GtkMenuItem *item, GtkWidget *scrollbar) { GtkAdjustment *adj; adj = gtk_range_get_adjustment (GTK_RANGE (scrollbar)); gtk_adjustment_set_value (adj, gtk_adjustment_get_lower (adj)); }
void v_scroll_bar_callback_window (GtkRange *widget, gpointer data) { GtkAdjustment* ta = gtk_range_get_adjustment (widget); double newV = ta->value*(ta->upper/(ta->upper-ta->page_size)); _HYWindow * parent_obj = (_HYWindow*)data; parent_obj->ProcessEvent (generateScrollEvent(0,newV-parent_obj->last_V_Position)); parent_obj->last_V_Position = newV; }
/* * Creates a new GtkWidget of class GtkCList, performing any specialized * initialization needed for the widget to work correctly in this environment. * If a dialog box is used to initialize the widget, return NULL from this * function, and call data->callback with your new widget when it is done. * If the widget needs a special destroy handler, add a signal here. */ static GtkWidget * gb_tclist_new (GbWidgetNewData * data) { GtkWidget *new_widget; #ifndef GTK_HAVE_FEATURES_1_1_4 GtkAdjustment *adjustment; #endif gint cols = 0, i; if (data->action == GB_LOADING) { cols = load_int (data->loading_data, Cols); if (cols == 0) cols = 1; new_widget = tclist_new (cols); /* GtkCList has problems if the title buttons aren't created. */ for (i = 0; i < cols; i++) { gtk_clist_set_column_widget (GTK_CLIST (new_widget), i, new_unnamed_label (new_widget)); gtk_clist_set_column_width (GTK_CLIST (new_widget), i, 80); editor_add_mouse_signals_to_existing (GTK_CLIST (new_widget)->column[i].button); } /* Connect signals for redrawing. */ /* The CList doesn't have scrollbars in 1.1.4+. We'll have to do this another way at some point. */ #ifndef GTK_HAVE_FEATURES_1_1_4 adjustment = gtk_range_get_adjustment (GTK_RANGE (GTK_CLIST (new_widget)->hscrollbar)); gtk_signal_connect_after (GTK_OBJECT (adjustment), "value_changed", (GtkSignalFunc) hadjustment_value_changed, new_widget); adjustment = gtk_range_get_adjustment (GTK_RANGE (GTK_CLIST (new_widget)->vscrollbar)); gtk_signal_connect_after (GTK_OBJECT (adjustment), "value_changed", (GtkSignalFunc) vadjustment_value_changed, new_widget); #endif return new_widget; } else { show_tclist_dialog (data); return NULL; } }
void shoes_native_slot_clear(shoes_canvas *canvas) { if (canvas->slot.vscroll) { GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(canvas->slot.vscroll)); gtk_adjustment_set_value(adj, adj->lower); } }
static void end_cb (GtkMenuItem *item, GtkWidget *scrollbar) { GtkAdjustment *adj; adj = gtk_range_get_adjustment (GTK_RANGE (scrollbar)); gtk_adjustment_set_value (adj, gtk_adjustment_get_upper (adj) - gtk_adjustment_get_page_size (adj)); }
void termit_for_each_row(int lua_callback) { TRACE("%s lua_callback=%d", __FUNCTION__, lua_callback); gint page = gtk_notebook_get_current_page(GTK_NOTEBOOK(termit.notebook)); TERMIT_GET_TAB_BY_INDEX(pTab, page); GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(pTab->scrollbar)); const glong rows_total = gtk_adjustment_get_upper(adj); termit_for_each_row_execute(pTab, 0, rows_total, lua_callback); }
static void tropas_ok_cb (GtkWidget *window ) { tropas_cant = (gint) gtk_range_get_adjustment(GTK_RANGE(tropas_hscale_cant))->value; if( tropas_cant > 0) out_tropas( tropas_src, tropas_dst, tropas_cant ); gtk_widget_destroy(tropas_dialog); }
static void post_change_event (GtkRange *range, struct range_scrollbar *rs) { GtkAdjustment *adj; adj = gtk_range_get_adjustment (range); (*gdk_env)->CallVoidMethod (gdk_env, *(rs->scrollbar), postAdjustmentEventID, AWT_ADJUSTMENT_TRACK, (jint) adj->value); }
void diaElemGenericSlider<T>::getMe(void) { GtkWidget *widget=(GtkWidget *)myWidget; T *val=(T *)param; ADM_assert(widget); GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE(widget)); *val = (T)GTK_ADJUSTMENT(adj)->value; if(*val<min) *val=min; if(*val>max) *val=max; }
void termit_for_each_visible_row(int lua_callback) { TRACE("%s lua_callback=%d", __FUNCTION__, lua_callback); gint page = gtk_notebook_get_current_page(GTK_NOTEBOOK(termit.notebook)); TERMIT_GET_TAB_BY_INDEX(pTab, page); GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(pTab->scrollbar)); const glong row_start = ceil(gtk_adjustment_get_value(adj)); const glong page_size = vte_terminal_get_row_count(VTE_TERMINAL(pTab->vte)); termit_for_each_row_execute(pTab, row_start, row_start + page_size, lua_callback); }
PRIVATE void focus_in_handler(GtkRange *b, GdkEventFocus *event, gpointer userdata) { Control *c = userdata; GtkAdjustment *adj = gtk_range_get_adjustment(b); GtkWidget **widgets = c->data; if (c->events_flow) { int note = 127 - adj->value; update_label(widgets[SEQUENCE_LENGTH * 2], note); } }
/** * gtk_test_slider_get_value: * @widget: valid widget pointer. * * Retrive the literal adjustment value for GtkRange based * widgets and spin buttons. Note that the value returned by * this function is anything between the lower and upper bounds * of the adjustment belonging to @widget, and is not a percentage * as passed in to gtk_test_slider_set_perc(). * * Returns: gtk_adjustment_get_value (adjustment) for an adjustment belonging to @widget. * * Since: 2.14 **/ double gtk_test_slider_get_value (GtkWidget *widget) { GtkAdjustment *adjustment = NULL; if (GTK_IS_RANGE (widget)) adjustment = gtk_range_get_adjustment (GTK_RANGE (widget)); else if (GTK_IS_SPIN_BUTTON (widget)) adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); return adjustment ? gtk_adjustment_get_value (adjustment) : 0; }
gboolean ghid_port_ranges_pan (gdouble x, gdouble y, gboolean relative) { GtkAdjustment *h_adj, *v_adj; gdouble x0, y0, x1, y1; h_adj = gtk_range_get_adjustment (GTK_RANGE (ghidgui->h_range)); v_adj = gtk_range_get_adjustment (GTK_RANGE (ghidgui->v_range)); x0 = h_adj->value; y0 = v_adj->value; if (relative) { x1 = x0 + x; y1 = y0 + y; } else { x1 = x; y1 = y; } if (x1 < h_adj->lower) x1 = h_adj->lower; if (x1 > h_adj->upper - h_adj->page_size) x1 = h_adj->upper - h_adj->page_size; if (y1 < v_adj->lower) y1 = v_adj->lower; if (y1 > v_adj->upper - v_adj->page_size) y1 = v_adj->upper - v_adj->page_size; if (x0 != x1 && y0 != y1) ghidgui->combine_adjustments = TRUE; if (x0 != x1) gtk_range_set_value (GTK_RANGE (ghidgui->h_range), x1); if (y0 != y1) gtk_range_set_value (GTK_RANGE (ghidgui->v_range), y1); ghid_note_event_location (NULL); return ((x0 != x1) || (y0 != y1)); }
Adjustment* Scale::getAdjustment() { GtkAdjustment* adjust = 0; if(adjustment == NULL) { adjust = gtk_range_get_adjustment(GTK_RANGE(widget)); adjustment = new Adjustment(adjust); adjustmentCreated = true; } return adjustment; }
void AdjustScroller (GtkWidget* scrollbar, long viewport, long size) { GtkAdjustment* old = gtk_range_get_adjustment (GTK_RANGE(scrollbar)); double newPageSize = viewport*MAX_CONTROL_VALUE/size, scaledValue = old->upper-old->page_size?old->value*(old->upper/(old->upper-old->page_size)):0.0; scaledValue *= (old->upper-newPageSize)/old->upper; GtkObject* newAdj = gtk_adjustment_new (scaledValue,0,MAX_CONTROL_VALUE,MAX_CONTROL_VALUE/100.0,MAX_CONTROL_VALUE/10.0,newPageSize); gtk_range_set_adjustment (GTK_RANGE(scrollbar),GTK_ADJUSTMENT(newAdj)); }
/* regroup */ static void reagrupe_ok_cb (GtkWidget *window ) { reagrupe_cant = (gint) gtk_range_get_adjustment(GTK_RANGE(reagrupe_hscale_cant))->value; if( reagrupe_cant > 0) { reagrupe_out( reagrupe_src, reagrupe_dst, reagrupe_cant ); } else reagrupe_reset(); gtk_widget_destroy(reagrupe_dialog); }
/** * gtk_test_slider_set_perc * @widget: valid widget pointer. * @percentage: value between 0 and 100. * * This function will adjust the slider position of all GtkRange * based widgets, such as scrollbars or scales, it'll also adjust * spin buttons. The adjustment value of these widgets is set to * a value between the lower and upper limits, according to the * @percentage argument. * * Since: 2.14 **/ void gtk_test_slider_set_perc (GtkWidget *widget, double percentage) { GtkAdjustment *adjustment = NULL; if (GTK_IS_RANGE (widget)) adjustment = gtk_range_get_adjustment (GTK_RANGE (widget)); else if (GTK_IS_SPIN_BUTTON (widget)) adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); if (adjustment) gtk_adjustment_set_value (adjustment, adjustment->lower + (adjustment->upper - adjustment->lower - adjustment->page_size) * percentage * 0.01); }
PRIVATE void refresh_pattern(Control *control) { Data *data = control->g->data; GtkWidget **widgets = control->data; int i; for (i = 0; i < SEQUENCE_LENGTH; i++) { gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(widgets[i])), 127 - data->pattern[data->edit][i]); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets[i + SEQUENCE_LENGTH]), data->note[data->edit][i]); } }
static void set_value_from_selector_state(GxSelector *selector, int selectorstate) { if (!selector->model) { return; } int n = gtk_tree_model_iter_n_children(selector->model, NULL); if (selectorstate < 0 || selectorstate >= n) { selectorstate = 0; } int lower = gtk_adjustment_get_lower(gtk_range_get_adjustment(GTK_RANGE(selector))); gtk_range_set_value(GTK_RANGE(selector), lower + selectorstate); }
void alarm_current_volume(GtkButton *button, gpointer data) { gint vol; GtkAdjustment *adj; AUDDBG("on_current_button_clicked\n"); aud_drct_get_volume_main(&vol); adj = gtk_range_get_adjustment(alarm_conf.volume); gtk_adjustment_set_value(adj, (gfloat)vol); }
static void gimmix_update_volume () { gint volume; GtkAdjustment *volume_adj; volume_adj = gtk_range_get_adjustment (GTK_RANGE(volume_scale)); volume = mpd_status_get_volume (gmo); gtk_adjustment_set_value (GTK_ADJUSTMENT(volume_adj), volume); return; }
/** * gimp_scrolled_preview_set_position: * @preview: a #GimpScrolledPreview * @x: horizontal scroll offset * @y: vertical scroll offset * * Since: GIMP 2.4 **/ void gimp_scrolled_preview_set_position (GimpScrolledPreview *preview, gint x, gint y) { GtkAdjustment *adj; g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview)); gimp_scrolled_preview_freeze (preview); gimp_scrolled_preview_hscr_update (preview); gimp_scrolled_preview_vscr_update (preview); adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); gtk_adjustment_set_value (adj, x - GIMP_PREVIEW (preview)->xmin); adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); gtk_adjustment_set_value (adj, y - GIMP_PREVIEW (preview)->ymin); gimp_scrolled_preview_thaw (preview); }
static void cb_volume_scale_changed (GtkWidget *widget, gpointer data) { GtkAdjustment *volume_adj; gint value; volume_adj = gtk_range_get_adjustment (GTK_RANGE(widget)); value = gtk_adjustment_get_value (GTK_ADJUSTMENT(volume_adj)); mpd_status_set_volume (gmo, value); return; }
void ghid_port_ranges_changed (void) { GtkAdjustment *h_adj, *v_adj; if (!ghidgui->combine_adjustments) HideCrosshair (FALSE); if (ghidgui->combine_adjustments) { ghidgui->combine_adjustments = FALSE; return; } ghidgui->need_restore_crosshair = TRUE; h_adj = gtk_range_get_adjustment (GTK_RANGE (ghidgui->h_range)); v_adj = gtk_range_get_adjustment (GTK_RANGE (ghidgui->v_range)); gport->view_x0 = h_adj->value; gport->view_y0 = v_adj->value; ghid_invalidate_all (); }
static void cc_ua_panel_init_mouse (CcUaPanel *self) { CcUaPanelPrivate *priv = self->priv; GtkWidget *w; /* mouse keys */ w = WID (priv->builder, "pointing_mouse_keys_switch"); settings_on_off_editor_new (priv, priv->kb_settings, "mousekeys-enable", w, NULL); /* simulated secondary click */ w = WID (priv->builder, "pointing_second_click_switch"); settings_on_off_editor_new (priv, priv->mouse_settings, "secondary-click-enabled", w, secondary_click_section); w = WID (priv->builder, "pointing_secondary_click_delay_scale"); g_settings_bind (priv->mouse_settings, "secondary-click-time", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); /* dwell click */ w = WID (priv->builder, "pointing_hover_click_switch"); settings_on_off_editor_new (priv, priv->mouse_settings, "dwell-click-enabled", w, dwell_click_section); w = WID (priv->builder, "pointing_dwell_delay_scale"); g_settings_bind (priv->mouse_settings, "dwell-time", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); w = WID (priv->builder, "pointing_dwell_threshold_scale"); g_settings_bind (priv->mouse_settings, "dwell-threshold", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); /* mouse preferences button */ g_signal_connect (WID (priv->builder, "pointing_mouse_preferences_link"), "activate-link", G_CALLBACK (pointing_mouse_preferences_clicked_cb), self); }