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