void gSlider::init() { GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(widget)); //if (_min == _max) // _max = _min + 1; if (_value < _min) _value = _min; else if (_value > _max) _value = _max; if (g_typ == Type_gSlider) { gtk_range_set_range(GTK_RANGE(widget), (gdouble)_min, (gdouble)_max); gtk_range_set_increments(GTK_RANGE(widget), (gdouble)_step, (gdouble)_page_step); } else { gtk_range_set_range(GTK_RANGE(widget), (gdouble)_min, (gdouble)_max + _page_step); gtk_range_set_increments(GTK_RANGE(widget), (gdouble)_step, (gdouble)_page_step); gtk_adjustment_set_page_size(adj, _page_step); } gtk_range_set_value(GTK_RANGE(widget), _value); #ifndef GTK3 gtk_range_set_update_policy(GTK_RANGE(widget), _tracking ? GTK_UPDATE_CONTINUOUS : GTK_UPDATE_DISCONTINUOUS); #endif checkInverted(); }
static gboolean position_update (PlayerAV *self) { guint len = player_av_get_duration (PLAYER (self)); guint pos = player_av_get_position (PLAYER (self)); switch (self->priv->state) { case PLAYER_STATE_PLAYING: case PLAYER_STATE_PAUSED: _player_emit_position_changed (PLAYER (self), pos); gtk_range_set_range (GTK_RANGE (self->priv->fs_scale), 0, len); gtk_range_set_value (GTK_RANGE (self->priv->fs_scale), pos); break; default: _player_emit_position_changed (PLAYER (self), pos); gtk_range_set_range (GTK_RANGE (self->priv->fs_scale), 0, 1); gtk_range_set_value (GTK_RANGE (self->priv->fs_scale), 0); } if (self->priv->state != PLAYER_STATE_PLAYING) { return FALSE; } return TRUE; }
/** * * set_scale_range: * * Set the scale range - maximum value should be display * track list length - (8 NULL images + 1 as index value), * ie. the ones either end of the list. * */ static void _init_slider_range(ClarityWidgetPrivate *priv) { g_signal_handler_block(G_OBJECT(priv->cdslider), priv->slider_signal_id); gint slider_ubound = album_model_get_size(priv->album_model) - 1; if (slider_ubound < 1) { /* If only one album cover is displayed then slider_ubbound returns * 0 and causes a slider assertion error. Avoid this by disabling the * slider, which makes sense because only one cover is displayed. */ slider_ubound = 1; gtk_widget_set_sensitive(GTK_WIDGET(priv->cdslider), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(priv->leftbutton), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(priv->rightbutton), FALSE); } else { gtk_widget_set_sensitive(GTK_WIDGET(priv->cdslider), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(priv->leftbutton), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(priv->rightbutton), TRUE); } gtk_range_set_range(GTK_RANGE (priv->cdslider), 0, slider_ubound); ClarityCanvas *ccanvas = CLARITY_CANVAS(priv->draw_area); gint index = clarity_canvas_get_current_index(ccanvas); if (index >= 0 && index <= slider_ubound) gtk_range_set_value(GTK_RANGE (priv->cdslider), index); else gtk_range_set_value(GTK_RANGE (priv->cdslider), 0); g_signal_handler_unblock(G_OBJECT(priv->cdslider), priv->slider_signal_id); }
static void zoom_adj(void) { float page_size=0; float step_inc=0; float page_inc=0; float val=0; float start=0; float stop=0; waveform_get_range(WAVEFORM(se->waveform), &start, &stop); gtk_range_set_range(GTK_RANGE(se->hscroll), start, stop); val = start; se->range = page_size = stop - start; step_inc = se->range / 100; page_inc = step_inc / 10; se->hscrolladj = gtk_adjustment_new(val, 0.0, 1.0, step_inc, page_inc, page_size); gtk_range_set_adjustment(GTK_RANGE(se->hscroll), GTK_ADJUSTMENT(se->hscrolladj)); /* emit value-changed signal so waveform is redrawn with * the new dimensions */ g_signal_emit_by_name(G_OBJECT(se->hscroll), "value-changed"); return; }
static void get_brightness_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error = NULL; GVariant *result; guint brightness; GtkRange *range; CcScreenPanel *self = CC_SCREEN_PANEL (user_data); result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (result == NULL) { gtk_widget_hide (WID ("screen_brightness_hscale")); gtk_widget_hide (WID ("screen_auto_reduce_checkbutton")); gtk_widget_hide (WID ("brightness-frame")); g_object_set (G_OBJECT (WID ("turn-off-alignment")), "left-padding", 0, NULL); g_warning ("Error getting brightness: %s", error->message); g_error_free (error); return; } /* set the slider */ g_variant_get (result, "(u)", &brightness); range = GTK_RANGE (WID ("screen_brightness_hscale")); gtk_range_set_range (range, 0, 100); gtk_range_set_increments (range, 1, 10); gtk_range_set_value (range, brightness); g_signal_connect (range, "value-changed", G_CALLBACK (brightness_slider_value_changed_cb), user_data); g_variant_unref (result); }
/* This function is called periodically to refresh the GUI */ static gboolean refresh_ui (CustomData *data) { GstFormat fmt = GST_FORMAT_TIME; gint64 current = -1; /* We do not want to update anything unless we are in the PAUSED or PLAYING states */ if (data->state < GST_STATE_PAUSED) return TRUE; /* If we didn't know it yet, query the stream duration */ if (!GST_CLOCK_TIME_IS_VALID (data->duration)) { if (!gst_element_query_duration (data->playbin, fmt, &data->duration)) { g_printerr ("Could not query current duration.\n"); } else { /* Set the range of the slider to the clip duration, in SECONDS */ gtk_range_set_range (GTK_RANGE (data->slider), 0, (gdouble)data->duration / GST_SECOND); } } if (gst_element_query_position (data->playbin, fmt, ¤t)) { /* Block the "value-changed" signal, so the slider_cb function is not called * (which would trigger a seek the user has not requested) */ g_signal_handler_block (data->slider, data->slider_update_signal_id); /* Set the position of the slider to the current pipeline positoin, in SECONDS */ gtk_range_set_value (GTK_RANGE (data->slider), (gdouble)current / GST_SECOND); /* Re-enable the signal */ g_signal_handler_unblock (data->slider, data->slider_update_signal_id); } return TRUE; }
void mn_non_linear_range_setup_static (GtkRange *range, const MNNonLinearRangeBlock *blocks, int num_blocks) { RangeInfo *info; int i; int num_values = 0; g_return_if_fail(GTK_IS_RANGE(range)); g_return_if_fail(blocks != NULL); g_return_if_fail(num_blocks > 0); global_init(); info = g_new0(RangeInfo, 1); info->blocks = blocks; info->num_blocks = num_blocks; g_object_set_qdata_full(G_OBJECT(range), info_quark, info, g_free); for (i = 0; i < num_blocks; i++) num_values += get_block_len(&blocks[i]); gtk_range_set_range(range, 0, num_values - 1); }
void pHexEdit::constructor() { gtkWidget = gtk_hbox_new(false, 0); container = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(container), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(container), GTK_SHADOW_ETCHED_IN); subWidget = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(subWidget), false); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(subWidget), GTK_WRAP_NONE); gtk_container_add(GTK_CONTAINER(container), subWidget); g_signal_connect(G_OBJECT(subWidget), "key-press-event", G_CALLBACK(HexEdit_keyPress), (gpointer)&hexEdit); scrollBar = gtk_vscrollbar_new((GtkAdjustment*)0); gtk_range_set_range(GTK_RANGE(scrollBar), 0, 255); gtk_range_set_increments(GTK_RANGE(scrollBar), 1, 16); gtk_widget_set_sensitive(scrollBar, false); g_signal_connect(G_OBJECT(scrollBar), "change-value", G_CALLBACK(HexEdit_scroll), (gpointer)&hexEdit); gtk_box_pack_start(GTK_BOX(gtkWidget), container, true, true, 0); gtk_box_pack_start(GTK_BOX(gtkWidget), scrollBar, false, false, 1); textBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(subWidget)); textCursor = gtk_text_buffer_get_mark(textBuffer, "insert"); gtk_widget_show(scrollBar); gtk_widget_show(subWidget); gtk_widget_show(container); }
gboolean browser_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data) { GdkGLContext *context = gtk_widget_get_gl_context(widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget); if (!gdk_gl_drawable_gl_begin(gldrawable, context)) return false; glViewport(0, 0, widget->allocation.width, widget->allocation.height); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0f, widget->allocation.width, widget->allocation.height, 0.0f, -1.0f, 1.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gdk_gl_drawable_gl_end(gldrawable); rows = (tex_names.size() / browser_columns) + 1; int width = widget->allocation.width / browser_columns; int rows_page = widget->allocation.height / width; gtk_range_set_range(GTK_RANGE(browse_vscroll), 0.0, (rows * width) - widget->allocation.height); scroll_to_selected_texture(widget); return true; }
static void cb_adjust_latency(GtkComboBox *widget, gpointer data) { GtkRange *range = static_cast<GtkRange *>(data); // Minimum latency for timestretch is 15ms. Everything else is 3ms. const int min_latency = gtk_combo_box_get_active(widget) == 0 ? LATENCY_MIN_TIMESTRETCH : LATENCY_MIN; gtk_range_set_range(range, min_latency, LATENCY_MAX); }
static void cb_button_download(GtkButton *button, gpointer user_data) { ts_download(); load_ts_phrase(); gtk_range_set_range(GTK_RANGE(scroll_bar), 0, tsN); disp_page(); }
GuiScale GuiScale_create (GuiForm parent, int left, int right, int top, int bottom, int minimum, int maximum, int value, unsigned long flags) { GuiScale me = Thing_new (GuiScale); my d_shell = parent -> d_shell; my d_parent = parent; #if gtk my d_widget = gtk_hscrollbar_new (NULL); gtk_range_set_range (GTK_RANGE (my d_widget), 0, 1000); GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (my d_widget)); adj -> page_size = 150; gtk_adjustment_changed (adj); _GuiObject_setUserData (my d_widget, me); my v_positionInForm (my d_widget, left, right, top, bottom, parent); g_signal_connect (G_OBJECT (my d_widget), "destroy", G_CALLBACK (_GuiGtkScale_destroyCallback), me); #elif cocoa #elif motif my d_widget = XmCreateScale (parent -> d_widget, "scale", NULL, 0); _GuiObject_setUserData (my d_widget, me); my v_positionInForm (my d_widget, left, right, top, bottom, parent); XtVaSetValues (my d_widget, XmNorientation, XmHORIZONTAL, XmNminimum, minimum, XmNmaximum, maximum, XmNvalue, value, //XmNy, 300, #ifdef macintosh //XmNscaleWidth, 340, #endif NULL); #endif return me; }
void wxSlider::SetRange( int minValue, int maxValue ) { BlockScrollEvent(); gtk_range_set_range(GTK_RANGE (m_widget), minValue, maxValue); gtk_range_set_increments(GTK_RANGE (m_widget), 1, (maxValue - minValue + 9) / 10); UnblockScrollEvent(); }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkRange_gtk_1range_1set_1range ( JNIEnv* env, jclass cls, jlong _self, jdouble _min, jdouble _max ) { GtkRange* self; gdouble min; gdouble max; // convert parameter self self = (GtkRange*) _self; // convert parameter min min = (gdouble) _min; // convert parameter max max = (gdouble) _max; // call function gtk_range_set_range(self, min, max); // cleanup parameter self // cleanup parameter min // cleanup parameter max }
void wxSlider::SetRange( int minValue, int maxValue ) { GTKDisableEvents(); if (minValue == maxValue) maxValue++; gtk_range_set_range(GTK_RANGE (m_scale), minValue, maxValue); gtk_range_set_increments(GTK_RANGE (m_scale), 1, (maxValue - minValue + 9) / 10); GTKEnableEvents(); if (HasFlag(wxSL_MIN_MAX_LABELS)) { wxString str; str.Printf( "%d", minValue ); if (HasFlag(wxSL_INVERSE)) gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() ); else gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() ); str.Printf( "%d", maxValue ); if (HasFlag(wxSL_INVERSE)) gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() ); else gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() ); } }
void pVerticalScroller::setLength(unsigned length) { locked = true; length += length == 0; gtk_range_set_range(GTK_RANGE(gtkWidget), 0, max(1u, length - 1)); gtk_range_set_increments(GTK_RANGE(gtkWidget), 1, length >> 3); locked = false; }
static void show_trough_toggled (GtkToggleButton *button, GtkScale *scale) { gboolean value; value = gtk_toggle_button_get_active (button); gtk_range_set_range (GTK_RANGE (scale), 0., value ? 100.0 : 0.); }
static void generateWavePeriod(void) { int waveType = 0; double waveFreq; int i; struct iio_device *trigger = iio_context_find_device(ctx, "hrtimer-1"); unsigned long triggerFreq; long long triggerFreqLL = 0; iio_device_attr_read_longlong(trigger, "frequency", &triggerFreqLL); triggerFreq = triggerFreqLL; /* Set the maximum frequency that user can select to 10% of the input generator frequency. */ if (triggerFreq >= 10) gtk_range_set_range(GTK_RANGE(scale_freq), 0.1, triggerFreq / 10); wave_ampl = gtk_range_get_value(GTK_RANGE(scale_ampl)); wave_offset = gtk_range_get_value(GTK_RANGE(scale_offset)); waveFreq = gtk_range_get_value(GTK_RANGE(scale_freq)); buffer_size = (unsigned int)round(triggerFreq / waveFreq); if (buffer_size < 2) buffer_size = 2; else if (buffer_size > 10000) buffer_size = 10000; current_sample = 0; soft_buffer_ch0 = g_renew(uint8_t, soft_buffer_ch0, buffer_size); gtk_range_set_value(GTK_RANGE(scale_freq), (double)triggerFreq / buffer_size); gtk_widget_queue_draw(scale_freq); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_sine))) waveType = SINEWAVE; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_square))) waveType = SQUAREWAVE; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_triangle))) waveType = TRIANGLE; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_sawtooth))) waveType = SAWTOOTH; FillSoftBuffer(waveType, soft_buffer_ch0); /* Also generate a preview of the output signal. */ float_soft_buff = g_renew(gfloat, float_soft_buff, 2 * buffer_size); X = g_renew(gfloat, X, 2 * buffer_size); for (i = 0; i < 2 * buffer_size; i++) X[i] = i; for (i = 0; i < 2 * buffer_size; i++) float_soft_buff[i] = soft_buffer_ch0[i % buffer_size] * 3.3 / 256; gtk_databox_graph_remove_all(GTK_DATABOX(databox)); databox_graph = gtk_databox_lines_new((2 * buffer_size), X, float_soft_buff, &color_prev_graph, 2); databox_graph_dots = gtk_databox_points_new((2 * buffer_size), X, float_soft_buff, &color_prev_graph_dots, 5); gtk_databox_graph_add(GTK_DATABOX(databox), databox_graph_dots); gtk_databox_graph_add(GTK_DATABOX(databox), databox_graph); gtk_databox_set_total_limits(GTK_DATABOX(databox), -0.2, (i - 1), 3.5, -0.2); }
/** \fn DIA_srtPos \brief Dialog that handles subtitle size and position */ int DIA_srtPos(AVDMGenericVideoStream *in,uint32_t *size,uint32_t *position) { uint8_t ret=0; uint32_t width,height; // Allocate space for green-ised video width=in->getInfo()->width; height=in->getInfo()->height; dialog=create_dialog1(); gtk_register_dialog(dialog); gtk_window_set_title (GTK_WINDOW (dialog), QT_TR_NOOP("Subtitle Size and Position")); gtk_widget_show(dialog); myCrop=new flySrtPos( width, height,in,WID(drawingarea1),WID(hscale1)); myCrop->param.fontSize=*size; myCrop->param.position=*position; gtk_range_set_range(GTK_RANGE(WID(vscale1)),0,height-1); myCrop->upload(); myCrop->sliderChanged(); gtk_signal_connect(GTK_OBJECT(WID(drawingarea1)), "expose_event", GTK_SIGNAL_FUNC(gui_draw), NULL); gtk_signal_connect (GTK_OBJECT(WID( spinbutton1)), "value_changed", GTK_SIGNAL_FUNC (gui_update), NULL); gtk_signal_connect (GTK_OBJECT(WID( hscale1)), "value_changed", GTK_SIGNAL_FUNC (slider_update), NULL); gtk_signal_connect (GTK_OBJECT(WID( vscale1)), "value_changed", GTK_SIGNAL_FUNC (gui_update), NULL); ret=0; int response; response=gtk_dialog_run(GTK_DIALOG(dialog)); if(response==GTK_RESPONSE_OK) { myCrop->download(); *size=myCrop->param.fontSize; *position=myCrop->param.position; ret=1; } gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); delete myCrop; return ret; }
void pHexEdit::setScroll() { unsigned rows = hexEdit.state.length / hexEdit.state.columns; if(rows) rows--; if(rows) { gtk_range_set_range(GTK_RANGE(scrollBar), 0, rows); gtk_widget_set_sensitive(scrollBar, true); } else { gtk_widget_set_sensitive(scrollBar, false); } }
static void set_slider_length (gint length) { if (length > 0) { gtk_range_set_range ((GtkRange *) slider, 0, length); gtk_widget_show (slider); } else gtk_widget_hide (slider); }
static void gx_regler_cp_configure(GxControlParameter *self, gchar* group, gchar *name, gdouble lower, gdouble upper, gdouble step) { g_return_if_fail(GX_IS_REGLER(self)); GxRegler *regler = GX_REGLER(self); if (regler->label) { gtk_label_set_text(regler->label, name); } GtkRange *range = GTK_RANGE(self); gtk_range_set_range(range, lower, upper); gtk_range_set_increments(range, step, 0); }
static void brasero_song_control_set_length (BraseroSongControl *player) { BraseroSongControlPrivate *priv; priv = BRASERO_SONG_CONTROL_PRIVATE (player); if (priv->end - priv->start != 0) gtk_range_set_range (GTK_RANGE (priv->progress), 0.0, (gdouble) priv->end - priv->start); brasero_song_control_update_position (player); }
static void rejilla_song_control_set_length (RejillaSongControl *player) { RejillaSongControlPrivate *priv; priv = REJILLA_SONG_CONTROL_PRIVATE (player); if (priv->end - priv->start != 0) gtk_range_set_range (GTK_RANGE (priv->progress), 0.0, (gdouble) priv->end - priv->start); rejilla_song_control_update_position (player); }
G_MODULE_EXPORT void vcodec_changed_cb(GtkWidget *widget, signal_user_data_t *ud) { float val, vqmin, vqmax, step, page; int inverted, digits; ghb_widget_to_setting(ud->settings, widget); ghb_check_dependency(ud, widget, NULL); ghb_show_container_options(ud); ghb_update_summary_info(ud); ghb_clear_presets_selection(ud); ghb_live_reset(ud); // Set the range of the video quality slider val = ghb_vquality_default(ud); ghb_vquality_range(ud, &vqmin, &vqmax, &step, &page, &digits, &inverted); ghb_scale_configure(ud, "VideoQualitySlider", val, vqmin, vqmax, step, page, digits, inverted); ghb_update_ui_combo_box(ud, "VideoTune", NULL, FALSE); ghb_update_ui_combo_box(ud, "VideoProfile", NULL, FALSE); ghb_update_ui_combo_box(ud, "VideoLevel", NULL, FALSE); ghb_ui_update(ud, "VideoTune", ghb_int_value(0)); ghb_ui_update(ud, "VideoProfile", ghb_int_value(0)); ghb_ui_update(ud, "VideoLevel", ghb_int_value(0)); ghb_ui_update(ud, "VideoOptionExtra", ghb_string_value("")); // Set the range of the preset slider int encoder = ghb_get_video_encoder(ud->settings); GtkWidget *presetSlider = GHB_WIDGET(ud->builder, "VideoPresetSlider"); GtkWidget *presetLabel = GHB_WIDGET(ud->builder, "VideoPresetLabel"); const char * const *video_presets; int count = 0; video_presets = hb_video_encoder_get_presets(encoder); while (video_presets && video_presets[count]) count++; gtk_widget_set_visible(presetSlider, count > 0); gtk_widget_set_visible(presetLabel, count > 0); if (count) { gtk_range_set_range(GTK_RANGE(presetSlider), 0, count-1); } ghb_set_video_preset(ud->settings, encoder, "medium"); GhbValue *gval = ghb_dict_get_value(ud->settings, "VideoPresetSlider"); ghb_ui_settings_update(ud, ud->settings, "VideoPresetSlider", gval); // Advanced options are only for x264 if (!(encoder & HB_VCODEC_X264_MASK)) { ghb_ui_update(ud, "x264UseAdvancedOptions", ghb_boolean_value(FALSE)); } }
static GObject *constructor(GType gtype, guint n_properties, GObjectConstructParam *properties) { GObject *obj; obj = G_OBJECT_CLASS(roccat_volume_scale_parent_class)->constructor(gtype, n_properties, properties); gtk_range_set_range(GTK_RANGE(obj), -100.0, 10.0); gtk_range_set_increments(GTK_RANGE(obj), 1.0, 10.0); gtk_scale_set_draw_value(GTK_SCALE(obj), TRUE); gtk_scale_set_value_pos(GTK_SCALE(obj), GTK_POS_RIGHT); g_signal_connect(G_OBJECT(obj), "format-value", G_CALLBACK(format_value_cb), NULL); return obj; }
static void trough (GtkToggleButton *button) { GSList *l; gboolean value; value = gtk_toggle_button_get_active (button); for (l = scales; l; l = l->next) { GtkRange *range = l->data; gtk_range_set_range (range, 0., value ? 100.0 : 0.); } }
void shoes_native_slot_lengthen(SHOES_SLOT_OS *slot, int height, int endy) { if (slot->vscroll) { GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(slot->vscroll)); if (adj->upper != (gdouble)endy) { gtk_range_set_range(GTK_RANGE(slot->vscroll), 0., (gdouble)endy); if (adj->page_size >= adj->upper) gtk_widget_hide(slot->vscroll); else gtk_widget_show(slot->vscroll); } } }
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); }
void file_is_unloaded() { // stop decode window display_close(engine); engine = NULL; set_GOP_selected(0); // toggle our file options gtk_widget_set_sensitive(menu_load_mpeg2, TRUE); gtk_widget_set_sensitive(menu_load_clip_list, TRUE); gtk_widget_set_sensitive(menu_save_clip_list, FALSE); gtk_widget_set_sensitive(menu_export_mpeg2, FALSE); gtk_widget_set_sensitive(menu_close, FALSE); gtk_widget_set_sensitive(menu_delete, FALSE); gtk_widget_set_sensitive(menu_clear, FALSE); gtk_widget_set_sensitive(menu_video_window, FALSE); gtk_widget_set_sensitive(button_run, FALSE); gtk_widget_set_sensitive(button_prev, FALSE); gtk_widget_set_sensitive(button_next, FALSE); gtk_widget_set_sensitive(button_refresh, FALSE); gtk_widget_set_sensitive(button_start_mark, FALSE); gtk_widget_set_sensitive(button_end_mark, FALSE); // adjust the slider scales gtk_range_set_range(GTK_RANGE(GOP_selector), 0.0, 0.1); gtk_spin_button_set_range(GTK_SPIN_BUTTON(GOP_selector_spinbutton), 0.0, 0.1); // wipe out GOP info window clear_GOP_info(); // wipe out clip window clear_GOP_slices(); // reset parser mpeg2parser->reset(); if (error_dialog) { // hide the errors (no errors now!) gtk_widget_hide(error_dialog); } }