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