void anypaper_window_set_position_range(AnypaperWindow *window, gint rangex, gint rangey)
{
if (rangex < 0) gtk_spin_button_set_range (GTK_SPIN_BUTTON (window->priv->spin1), (gdouble) 2 * rangex, 0);
if (rangex >= 0) gtk_spin_button_set_range (GTK_SPIN_BUTTON (window->priv->spin1), 0, 2 * rangex);
if (rangey < 0) gtk_spin_button_set_range (GTK_SPIN_BUTTON (window->priv->spin2), (gdouble) 2 * rangey, 0);
if (rangey >= 0) gtk_spin_button_set_range (GTK_SPIN_BUTTON (window->priv->spin2), 0, 2 * rangey);
if (rangex == 0)
{
gtk_widget_set_sensitive (window->priv->spin1, FALSE);
gtk_widget_set_sensitive (window->priv->label1, FALSE);
}
else
{
gtk_widget_set_sensitive (window->priv->spin1, TRUE);
gtk_widget_set_sensitive (window->priv->label1, TRUE);
}
if (rangey == 0)
{
gtk_widget_set_sensitive (window->priv->spin2, FALSE);
gtk_widget_set_sensitive (window->priv->label2, FALSE);
}
else
{
gtk_widget_set_sensitive (window->priv->spin2, TRUE);
gtk_widget_set_sensitive (window->priv->label2, TRUE);
}
}
G_MODULE_EXPORT void
hanlder_gpgme_add_subkey_type_changed (GtkComboBox *combo, BastileWidget *swidget)
{
gint type;
GtkSpinButton *length;
GtkTreeModel *model;
GtkTreeIter iter;
length = GTK_SPIN_BUTTON (bastile_widget_get_widget (swidget, LENGTH));
model = gtk_combo_box_get_model (combo);
gtk_combo_box_get_active_iter (combo, &iter);
gtk_tree_model_get (model, &iter,
COMBO_INT, &type,
-1);
switch (type) {
/* DSA */
case 0:
gtk_spin_button_set_range (length, DSA_MIN, DSA_MAX);
gtk_spin_button_set_value (length, LENGTH_DEFAULT < DSA_MAX ? LENGTH_DEFAULT : DSA_MAX);
break;
/* ElGamal */
case 1:
gtk_spin_button_set_range (length, ELGAMAL_MIN, LENGTH_MAX);
gtk_spin_button_set_value (length, LENGTH_DEFAULT);
break;
/* RSA */
default:
gtk_spin_button_set_range (length, RSA_MIN, LENGTH_MAX);
gtk_spin_button_set_value (length, LENGTH_DEFAULT);
break;
}
}
void _update_dimensions(dt_lib_export_t *d)
{
uint32_t w=0,h=0;
_get_max_output_dimension(d,&w,&h);
gtk_spin_button_set_range( d->width,0, (w>0?w:10000) );
gtk_spin_button_set_range( d->height,0, (h>0?h:10000) );
}
G_MODULE_EXPORT void
x264_me_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
{
gint me;
ghb_widget_to_setting(ud->x264_priv, widget);
if (!ignore_options_update)
{
ignore_options_update = TRUE;
x264_opt_update(ud, widget);
ignore_options_update = FALSE;
}
ghb_check_dependency(ud, widget, NULL);
ghb_clear_presets_selection(ud);
widget = GHB_WIDGET(ud->builder, "x264_merange");
me = ghb_settings_combo_int(ud->x264_priv, "x264_me");
if (me < 2)
{ // me < umh
// me_range 4 - 16
gtk_spin_button_set_range(GTK_SPIN_BUTTON(widget), 4, 16);
}
else
{
// me_range 4 - 64
gtk_spin_button_set_range(GTK_SPIN_BUTTON(widget), 4, 64);
}
}
static gboolean
drawable_button_release_cb (GtkWidget *widget, GdkEventButton *event, VnrCrop *crop)
{
if(event->button == 1)
{
crop->drawing_rectangle = FALSE;
gtk_spin_button_set_range(crop->spin_width, 1,
(crop->width - crop->sub_x) / crop->zoom);
gtk_spin_button_set_range(crop->spin_height, 1,
(crop->height - crop->sub_y) / crop->zoom);
vnr_crop_update_spin_button_values (crop);
}
return FALSE;
}
void wxSpinCtrlGTKBase::DoSetRange(double minVal, double maxVal)
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid spin button") );
wxSpinCtrlEventDisabler disable(this);
gtk_spin_button_set_range( GTK_SPIN_BUTTON(m_widget), minVal, maxVal);
}
void
brasero_split_dialog_set_boundaries (BraseroSplitDialog *self,
gint64 start,
gint64 end)
{
BraseroSplitDialogPrivate *priv;
guint64 length;
priv = BRASERO_SPLIT_DIALOG_PRIVATE (self);
if (BRASERO_DURATION_TO_BYTES (start) % 2352)
start += BRASERO_BYTES_TO_DURATION (2352 - (BRASERO_DURATION_TO_BYTES (start) % 2352));
if (BRASERO_DURATION_TO_BYTES (end) % 2352)
end += BRASERO_BYTES_TO_DURATION (2352 - (BRASERO_DURATION_TO_BYTES (end) % 2352));
if (end - start < BRASERO_MIN_STREAM_LENGTH)
return;
priv->start = start;
priv->end = end;
brasero_song_control_set_boundaries (BRASERO_SONG_CONTROL (priv->player),
priv->start,
priv->end);
/* Don't allow splitting the track in sections longer than the track
* length in seconds */
length = (gdouble) brasero_song_control_get_length (BRASERO_SONG_CONTROL (priv->player)) / 1000000000;
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->spin_sec), 1.0, length);
}
void
pfi_gui_make ( void )
{
extern const char pfi_gtk_gui[];
GtkBuilder * b;
int i;
pfi_mutex = g_mutex_new();
/* Create the interface builder */
b = gtk_builder_new();
/* Load spec */
gtk_builder_add_from_string( b, pfi_gtk_gui, -1, NULL );
/* Grab symbols */
for( i = 0; syms[i].symname; i++ )
*syms[i].stor = (GtkWidget*)gtk_builder_get_object( b, syms[i].symname );
system( "touch pfilog.txt" );
gtk_file_chooser_set_filename( GTK_FILE_CHOOSER(pfi_gui_e_file), "pfilog.txt" );
gtk_spin_button_set_range( GTK_SPIN_BUTTON(pfi_gui_e_arg_start), 0.0, 3.0 );
gtk_widget_set_sensitive( pfi_gui_b_disable, FALSE );
g_signal_connect( G_OBJECT(pfi_gui_window), "delete-event", (GCallback)delete_event, NULL );
g_signal_connect( G_OBJECT(pfi_gui_b_close), "clicked", (GCallback)close, NULL );
g_signal_connect( G_OBJECT(pfi_gui_b_enable), "clicked", (GCallback)enable, NULL );
g_signal_connect( G_OBJECT(pfi_gui_b_disable), "clicked", (GCallback)disable, NULL );
}
static void
panel_properties_dialog_setup_size_spin (PanelPropertiesDialog *dialog,
GladeXML *gui)
{
dialog->size_widgets = glade_xml_get_widget (gui, "size_widgets");
g_return_if_fail (dialog->size_widgets != NULL);
dialog->size_spin = glade_xml_get_widget (gui, "size_spin");
g_return_if_fail (dialog->size_spin != NULL);
dialog->size_label = glade_xml_get_widget (gui, "size_label");
g_return_if_fail (dialog->size_label != NULL);
dialog->size_label_pixels = glade_xml_get_widget (gui, "size_label_pixels");
g_return_if_fail (dialog->size_label_pixels != NULL);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (dialog->size_spin),
panel_toplevel_get_minimum_size (dialog->toplevel),
panel_toplevel_get_maximum_size (dialog->toplevel));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spin),
panel_profile_get_toplevel_size (dialog->toplevel));
g_signal_connect_swapped (dialog->size_spin, "value_changed",
G_CALLBACK (panel_properties_dialog_size_changed),
dialog);
if ( ! panel_profile_is_writable_toplevel_size (dialog->toplevel)) {
gtk_widget_set_sensitive (dialog->size_spin, FALSE);
gtk_widget_set_sensitive (dialog->size_label, FALSE);
gtk_widget_set_sensitive (dialog->size_label_pixels, FALSE);
gtk_widget_show (dialog->writability_warn_general);
}
}
static void
photos_print_setup_set_initial_values (PhotosPrintSetup *self)
{
PhotosPrintSetupPrivate *priv = self->priv;
GeglRectangle bbox;
gdouble page_height;
gdouble page_width;
gdouble factor;
gdouble height;
gdouble max_perc;
gdouble width;
factor = get_scale_to_px_factor (self);
bbox = gegl_node_get_bounding_box (priv->node);
width = (gdouble) bbox.width/factor;
height = (gdouble) bbox.height/factor;
max_perc = photos_print_setup_get_max_percentage (self);
width *= max_perc;
height *= max_perc;
gtk_range_set_range (GTK_RANGE (priv->scaling), 1, 100 * max_perc);
gtk_range_set_increments (GTK_RANGE (priv->scaling), max_perc, 10 * max_perc);
gtk_range_set_value (GTK_RANGE (priv->scaling), 100 * max_perc);
photos_print_preview_set_scale (PHOTOS_PRINT_PREVIEW (priv->preview), max_perc);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->width), 0, width);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->height), 0, height);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->width), width);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->height), height);
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->center), CENTER_BOTH);
photos_print_setup_center (gtk_page_setup_get_page_width (priv->page_setup, priv->current_unit),
gtk_spin_button_get_value (GTK_SPIN_BUTTON (priv->width)),
GTK_SPIN_BUTTON (priv->left), GTK_SPIN_BUTTON (priv->right));
photos_print_setup_center (gtk_page_setup_get_page_height (priv->page_setup, priv->current_unit),
gtk_spin_button_get_value (GTK_SPIN_BUTTON (priv->height)),
GTK_SPIN_BUTTON (priv->top), GTK_SPIN_BUTTON (priv->bottom));
page_width = gtk_page_setup_get_page_width (priv->page_setup, priv->current_unit);
page_height = gtk_page_setup_get_page_height (priv->page_setup, priv->current_unit);
update_image_pos_ranges (self, page_width, page_height, width, height);
}
static void cell_width_value_changed(void)
{
int min;
min = CELL_HEIGHT_MIN > cell_width ? CELL_HEIGHT_MIN : cell_width;
gtk_spin_button_set_range(GTK_SPIN_BUTTON(cell_height_spin),
min, CELL_HEIGHT_MAX);
}
void wxSpinCtrl::SetRange(int minVal, int maxVal)
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid spin button") );
wxSpinCtrl_GtkDisableEvents( this );
gtk_spin_button_set_range( GTK_SPIN_BUTTON(m_widget), minVal, maxVal);
wxSpinCtrl_GtkEnableEvents( this );
}
static void update_page(TraceViewStore *store)
{
if (!store->spin)
return;
gtk_spin_button_set_range(GTK_SPIN_BUTTON(store->spin),
1, store->pages);
}
GtkWidget * AP_UnixDialog_InsertTable::_constructWindow(void)
{
GtkWidget * window;
const XAP_StringSet * pSS = m_pApp->getStringSet();
#if GTK_CHECK_VERSION(3,0,0)
GtkBuilder * builder = newDialogBuilder("ap_UnixDialog_InsertTable.ui");
#else
GtkBuilder * builder = newDialogBuilder("ap_UnixDialog_InsertTable-2.ui");
#endif
// Update our member variables with the important widgets that
// might need to be queried or altered later
window = GTK_WIDGET(gtk_builder_get_object(builder, "ap_UnixDialog_InsertTable"));
GtkWidget * widget = GTK_WIDGET(gtk_builder_get_object(builder, "rbAutoColSize"));
UT_ASSERT(widget); // it shouldn't happen if things are propoerly installed.
m_radioGroup = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
m_pColSpin = GTK_WIDGET(gtk_builder_get_object(builder, "sbNumCols"));
m_pRowSpin = GTK_WIDGET(gtk_builder_get_object(builder, "sbNumRows"));
m_pColWidthSpin = GTK_WIDGET(gtk_builder_get_object(builder, "sbColSize"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_pColSpin), getNumCols());
gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_pRowSpin), getNumRows());
GtkWidget *rbAutoColSize = GTK_WIDGET(gtk_builder_get_object(builder, "rbAutoColSize"));
UT_ASSERT(rbAutoColSize);
s_auto_colsize_toggled (GTK_TOGGLE_BUTTON (rbAutoColSize), m_pColWidthSpin);
g_signal_connect (G_OBJECT (rbAutoColSize), "toggled", G_CALLBACK (s_auto_colsize_toggled), m_pColWidthSpin);
// set the dialog title
std::string s;
pSS->getValueUTF8(AP_STRING_ID_DLG_InsertTable_TableTitle,s);
abiDialogSetTitle(window, "%s", s.c_str());
// Units
gtk_label_set_text (GTK_LABEL (GTK_WIDGET(gtk_builder_get_object(builder, "lbInch"))), UT_dimensionName(m_dim));
double spinstep = getSpinIncr ();
gtk_spin_button_set_increments (GTK_SPIN_BUTTON(m_pColWidthSpin), spinstep, spinstep * 5);
double spinmin = getSpinMin ();
gtk_spin_button_set_range (GTK_SPIN_BUTTON(m_pColWidthSpin), spinmin, spinmin * 1000);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_pColWidthSpin), m_columnWidth);
// localize the strings in our dialog, and set tags for some widgets
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbTableSize")), pSS, AP_STRING_ID_DLG_InsertTable_TableSize);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbNumCols")), pSS, AP_STRING_ID_DLG_InsertTable_NumCols);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbNumRows")), pSS, AP_STRING_ID_DLG_InsertTable_NumRows);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbAutoFit")), pSS, AP_STRING_ID_DLG_InsertTable_AutoFit);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbAutoColSize")), pSS, AP_STRING_ID_DLG_InsertTable_AutoColSize);
g_object_set_data (G_OBJECT (GTK_WIDGET(gtk_builder_get_object(builder, "rbAutoColSize"))), WIDGET_ID_TAG_KEY, GINT_TO_POINTER(b_AUTOSIZE));
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbFixedColSize")), pSS, AP_STRING_ID_DLG_InsertTable_FixedColSize);
g_object_set_data (G_OBJECT (GTK_WIDGET(gtk_builder_get_object(builder, "rbFixedColSize"))), WIDGET_ID_TAG_KEY, GINT_TO_POINTER(b_FIXEDSIZE));
localizeButtonUnderline(GTK_WIDGET(gtk_builder_get_object(builder, "btInsert")), pSS, AP_STRING_ID_DLG_InsertButton);
g_object_unref(G_OBJECT(builder));
return window;
}
static void
update_time_unit_limits (GtkComboBox *menu, GtkWidget *spin_button)
{
/* set the range on the spin button so it can't overflow when
* converted to seconds when we're constructing the query
*/
gulong mult = time_unit_options [gtk_combo_box_get_active (menu)].timeMultiplier;
gtk_spin_button_set_range (GTK_SPIN_BUTTON (spin_button), 1, G_MAXINT / mult);
}
void
insert_label_spin_with_limits(GtkWidget * table, char * ltext, GtkWidget ** spin, double spinval,
double min, double max, int y1, int y2) {
insert_label_spin(table, ltext, spin, spinval, y1, y2);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(*spin), min, max);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(*spin), spinval);
}
void wxSpinButton::SetRange(int minVal, int maxVal)
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid spin button") );
GtkDisableEvents();
gtk_spin_button_set_range((GtkSpinButton*)m_widget, minVal, maxVal);
m_pos = int(gtk_spin_button_get_value((GtkSpinButton*)m_widget));
GtkEnableEvents();
}
static gboolean
kaplan_meier_tool_set_censor_from_cb (G_GNUC_UNUSED GtkWidget *dummy,
KaplanMeierToolState *state)
{
gtk_spin_button_set_range (GTK_SPIN_BUTTON (state->censor_spin_to),
gtk_spin_button_get_value (GTK_SPIN_BUTTON (state->censor_spin_from)),G_MAXSHORT);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->censorship_button), TRUE);
return FALSE;
}
static void remmina_rdp_settings_appscale_on_changed(GtkComboBox *widget, RemminaPluginRdpsetGrid *grid)
{
TRACE_CALL(__func__);
GtkTreeIter iter;
guint i = 0;
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(grid->device_scale_factor_combo), &iter)) {
gtk_tree_model_get(GTK_TREE_MODEL(grid->device_scale_factor_store), &iter, 0, &i, -1);
}
if (i == 0) {
gtk_widget_set_sensitive(GTK_WIDGET(grid->desktop_scale_factor_spin), FALSE);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), 0, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), 0);
}else {
gtk_widget_set_sensitive(GTK_WIDGET(grid->desktop_scale_factor_spin), TRUE);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), 100, 500);
// gtk_spin_button_set_value(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), i);
}
}
static void
cb_dialog_goto_update_sensitivity (G_GNUC_UNUSED GtkWidget *dummy,
GotoState *state)
{
GnmValue *val = dialog_goto_get_val (state);
if (val != NULL) {
gint cols, rows;
Sheet *sheet = val->v_range.cell.a.sheet;
GnmSheetSize const *ssz;
if (sheet == NULL)
sheet = wb_control_cur_sheet (WORKBOOK_CONTROL (state->wbcg));
ssz = gnm_sheet_get_size (sheet);
cols = ssz->max_cols;
rows = ssz->max_rows;
if (val->v_range.cell.a.sheet != NULL &&
val->v_range.cell.b.sheet != NULL &&
val->v_range.cell.a.sheet != val->v_range.cell.b.sheet) {
ssz = gnm_sheet_get_size (sheet);
if (cols > ssz->max_cols)
cols = ssz->max_cols;
if (rows > ssz->max_rows)
cols = ssz->max_rows;
}
cols -= val->v_range.cell.a.col;
rows -= val->v_range.cell.a.row;
if (cols < 1) cols = 1;
if (rows < 1) rows = 1;
gtk_spin_button_set_range (state->spin_cols, 1, cols);
gtk_spin_button_set_range (state->spin_rows, 1, rows);
gtk_widget_set_sensitive (state->go_button, TRUE);
value_release (val);
} else
gtk_widget_set_sensitive (state->go_button, FALSE);
gtk_entry_set_activates_default (state->goto_text, (val != NULL));
}
static void
update_image_pos_ranges (PhotosPrintSetup *setup,
gdouble page_width,
gdouble page_height,
gdouble width,
gdouble height)
{
PhotosPrintSetupPrivate *priv;
priv = setup->priv;
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->left),
0, page_width - width);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->right),
0, page_width - width);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->top),
0, page_height - height);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->bottom),
0, page_height - height);
}
static void
range_subdialog (GtkButton *b, gpointer data)
{
gint response;
struct select_cases_dialog *scd = data;
gint n_cases = psppire_data_store_get_case_count (scd->data_store);
GtkWidget *parent_dialog = get_widget_assert (scd->xml,
"select-cases-dialog");
GtkWidget *dialog = get_widget_assert (scd->xml,
"select-cases-range-dialog");
GtkWidget *first = get_widget_assert (scd->xml,
"range-dialog-first");
GtkWidget *last = get_widget_assert (scd->xml,
"range-dialog-last");
gtk_spin_button_set_range (GTK_SPIN_BUTTON (last), 1, n_cases);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (first), 1, n_cases);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (parent_dialog));
response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
if ( response == PSPPIRE_RESPONSE_CONTINUE)
{
GtkWidget *first = get_widget_assert (scd->xml, "range-dialog-first");
GtkWidget *last = get_widget_assert (scd->xml, "range-dialog-last");
GtkWidget *l1 = get_widget_assert (scd->xml, "range-sample-label");
gchar *text = widget_printf (_("%d thru %d"), first, last);
gtk_label_set_text (GTK_LABEL (l1), text);
g_free (text);
}
}
static void
panel_properties_size_spin_update_range (PanelPropertiesDialog *dialog)
{
//TODO: we should also do this when the monitor size changes
/* note: we might not be fully setup, so we have to do checks */
if (!dialog->size_spin)
return;
gtk_spin_button_set_range (GTK_SPIN_BUTTON (dialog->size_spin),
panel_toplevel_get_minimum_size (dialog->toplevel),
panel_toplevel_get_maximum_size (dialog->toplevel));
}
void
jam_spin_button_set(GtkSpinButton *w,
gboolean numeric,
gdouble min, gdouble max,
gdouble step, gdouble page,
gint digits) {
g_assert(GTK_IS_SPIN_BUTTON(w));
gtk_spin_button_set_numeric(w, numeric);
gtk_spin_button_set_range(w, min, max);
gtk_spin_button_set_increments(w, step, page);
gtk_spin_button_set_digits(w, digits);
}
static void
cb_plot_area_changed (GtkWidget *spin, PlotAreaPrefState *state)
{
GogViewAllocation pos;
double value;
double max;
value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin)) / 100.0;
gog_chart_get_plot_area (state->chart, &pos);
if (spin == state->x_spin) {
pos.x = value;
max = 1.0 - pos.x;
g_signal_handler_block (state->w_spin, state->w_spin_signal);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (state->w_spin), 0.0, max * 100.0);
if (pos.w > max) pos.w = max;
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->w_spin), pos.w * 100.0);
g_signal_handler_unblock (state->w_spin, state->w_spin_signal);
}
else if (spin == state->y_spin) {
pos.y = value;
max = 1.0 - pos.y;
g_signal_handler_block (state->h_spin, state->h_spin_signal);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (state->h_spin), 0.0, max * 100.0);
if (pos.h > max) pos.h = max;
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->h_spin), pos.w * 100.0);
g_signal_handler_unblock (state->h_spin, state->h_spin_signal);
}
else if (spin == state->w_spin) {
pos.w = value;
}
else if (spin == state->h_spin) {
pos.h = value;
}
gog_chart_set_plot_area (state->chart, &pos);
gtk_combo_box_set_active (GTK_COMBO_BOX (state->position_select_combo), 1);
gtk_widget_show (state->manual_setting_grid);
}
static void
panel_properties_dialog_update_orientation (PanelPropertiesDialog *dialog,
GConfValue *value)
{
PanelOrientation orientation;
GtkTreeModel *model;
GtkTreeIter iter;
OrientationComboItem *item;
int max_size;
int spin_size;
int profile_size;
if (!value || value->type != GCONF_VALUE_STRING)
return;
if (!panel_profile_map_orientation_string (gconf_value_get_string (value), &orientation))
return;
/* change the maximum size of the panel */
//TODO: we should also do this when the monitor size changes
max_size = panel_toplevel_get_maximum_size (dialog->toplevel);
spin_size = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dialog->size_spin));
profile_size = panel_profile_get_toplevel_size (dialog->toplevel);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (dialog->size_spin),
panel_toplevel_get_minimum_size (dialog->toplevel),
max_size);
if (spin_size > max_size)
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spin),
max_size);
else if (spin_size != profile_size)
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spin),
MIN (profile_size, max_size));
/* update the orientation combo box */
model = gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->orientation_combo));
if (!gtk_tree_model_get_iter_first (model, &iter))
return;
do {
gtk_tree_model_get (model, &iter, COLUMN_ITEM, &item, -1);
if (item != NULL && item->orientation == orientation) {
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (dialog->orientation_combo),
&iter);
return;
}
} while (gtk_tree_model_iter_next (model, &iter));
}
static void update_fade_spins(void)
{
int fade = patch_get_fade_samples(se->patch);
int max_fade = patch_get_max_fade_samples(se->patch);
int xfade = patch_get_xfade_samples(se->patch);
int max_xfade = patch_get_max_xfade_samples(se->patch);
g_signal_handlers_block_by_func(se->fade_spin, cb_fade_spin_changed, 0);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(se->fade_spin), 0, max_fade);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(se->fade_spin), fade);
g_signal_handlers_unblock_by_func( se->fade_spin,
cb_fade_spin_changed,
0);
g_signal_handlers_block_by_func(se->xfade_spin,
cb_xfade_spin_changed,
0);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(se->xfade_spin), 0,
max_xfade);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(se->xfade_spin), xfade);
g_signal_handlers_unblock_by_func(se->xfade_spin,
cb_xfade_spin_changed, 0);
}
static void
pgd_render_slice_selector_setup (PgdRenderDemo *demo)
{
PopplerPage *page;
gdouble width, height;
page = poppler_document_get_page (demo->doc, demo->page);
if (!page)
return;
poppler_page_get_size (page, &width, &height);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_x), 0, width);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_y), 0, height);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_w), 0, width);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_h), 0, height);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_x), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_y), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_w), width);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_h), height);
g_object_unref (page);
}
static void up_down_converter_toggled_cb(GtkToggleButton *button, gpointer data)
{
static gint rx_updn_hid, tx_updn_hid;
static gdouble lo_min, lo_max;
static void (*rx_lo_update_value)(struct iio_widget *, const char *, size_t);
static void (*tx_lo_update_value)(struct iio_widget *, const char *, size_t);
if (gtk_toggle_button_get_active(button)) {
iio_spin_button_progress_deactivate(&rx_widgets[rx_lo]);
iio_spin_button_progress_deactivate(&tx_widgets[tx_lo]);
rx_updn_hid = g_signal_connect(rx_widgets[rx_lo].widget, "value-changed",
G_CALLBACK(updn_converter_lo_freq_changed_cb), (gpointer)UPDN_RX);
tx_updn_hid = g_signal_connect(tx_widgets[tx_lo].widget, "value-changed",
G_CALLBACK(updn_converter_lo_freq_changed_cb), (gpointer)UPDN_TX);
gtk_spin_button_get_range(GTK_SPIN_BUTTON(rx_widgets[rx_lo].widget), &lo_min, &lo_max);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(rx_widgets[rx_lo].widget), 1, 100);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(tx_widgets[tx_lo].widget), 1, 100);
rx_lo_update_value = rx_widgets[rx_lo].update_value;
tx_lo_update_value = tx_widgets[tx_lo].update_value;
rx_widgets[rx_lo].update_value = NULL;
tx_widgets[tx_lo].update_value = NULL;
} else {
g_signal_handler_disconnect(rx_widgets[rx_lo].widget, rx_updn_hid);
g_signal_handler_disconnect(tx_widgets[tx_lo].widget, tx_updn_hid);
rx_widgets[rx_lo].update_value = rx_lo_update_value;
tx_widgets[tx_lo].update_value = tx_lo_update_value;
iio_spin_button_progress_activate(&rx_widgets[rx_lo]);
iio_spin_button_progress_activate(&tx_widgets[tx_lo]);
g_signal_emit_by_name(rx_widgets[rx_lo].widget,
"value-changed", NULL);
g_signal_emit_by_name(tx_widgets[tx_lo].widget,
"value-changed", NULL);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(rx_widgets[rx_lo].widget), lo_min, lo_max);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(tx_widgets[tx_lo].widget), lo_min, lo_max);
}
}
static void
pgd_text_area_selector_setup (PgdTextDemo *demo)
{
PopplerPage *page;
gdouble width, height;
page = poppler_document_get_page (demo->doc, demo->page);
if (!page)
return;
poppler_page_get_size (page, &width, &height);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->area_x1), -10, width - 10);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->area_y1), -10, height - 10);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->area_x2), 0, width + 10);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->area_y2), 0, height + 10);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->area_x1), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->area_y1), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->area_x2), width);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->area_y2), height);
g_object_unref (page);
}