static gboolean
eog_thumb_nav_scroll_step (gpointer user_data)
{
EogThumbNav *nav = EOG_THUMB_NAV (user_data);
GtkAdjustment *adj = nav->priv->adj;
gint delta;
if (nav->priv->scroll_pos < 10)
delta = EOG_THUMB_NAV_SCROLL_INC;
else if (nav->priv->scroll_pos < 20)
delta = EOG_THUMB_NAV_SCROLL_INC * 2;
else if (nav->priv->scroll_pos < 30)
delta = EOG_THUMB_NAV_SCROLL_INC * 2 + 5;
else
delta = EOG_THUMB_NAV_SCROLL_INC * 2 + 12;
if (!nav->priv->scroll_dir)
delta *= -1;
if ((gint) (gtk_adjustment_get_value (adj) + (gdouble) delta) >= 0 &&
(gint) (gtk_adjustment_get_value (adj) + (gdouble) delta) <= gtk_adjustment_get_upper (adj) - gtk_adjustment_get_page_size (adj)) {
gtk_adjustment_set_value(adj,
gtk_adjustment_get_value (adj) + (gdouble) delta);
nav->priv->scroll_pos++;
} else {
if (delta > 0)
gtk_adjustment_set_value (adj,
gtk_adjustment_get_upper (adj) - gtk_adjustment_get_page_size (adj));
else
gtk_adjustment_set_value (adj, 0);
nav->priv->scroll_pos = 0;
return FALSE;
}
return TRUE;
}
static void
color_balance_config_notify (GObject *object,
GParamSpec *pspec,
GimpColorBalanceTool *cb_tool)
{
GimpColorBalanceConfig *config = GIMP_COLOR_BALANCE_CONFIG (object);
if (! cb_tool->cyan_red_adj)
return;
if (! strcmp (pspec->name, "range"))
{
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (cb_tool->range_radio),
config->range);
}
else if (! strcmp (pspec->name, "cyan-red"))
{
gtk_adjustment_set_value (cb_tool->cyan_red_adj,
config->cyan_red[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "magenta-green"))
{
gtk_adjustment_set_value (cb_tool->magenta_green_adj,
config->magenta_green[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "yellow-blue"))
{
gtk_adjustment_set_value (cb_tool->yellow_blue_adj,
config->yellow_blue[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "preserve-luminosity"))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb_tool->preserve_toggle),
config->preserve_luminosity);
}
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (cb_tool));
}
void gcb_event_set_position(GtkWidget *w, GdkEventButton *s, struct gchan *o)
{
float position;
if(o->channel != 1) {
/* get your hands off! */
gtk_adjustment_set_value(GTK_ADJUSTMENT(o->adjprog), 0.0);
return;
}
position=GTK_ADJUSTMENT(o->adjprog)->value;
mixer->set_position(o->idx-1, position);
/* muse-core will play channel with set_position */
}
void
fill_page_from_note_data(note_data *note)
{
gint len;
gchar *buff;
if (note->title != NULL)
{
gtk_entry_set_text(GTK_ENTRY(sp->title_entry), note->title);
}
if (note->text != NULL)
{
len = strlen(note->text);
gtk_text_insert(GTK_TEXT(sp->text_entry), NULL, NULL, NULL, note->text,
len);
gtk_editable_set_position(GTK_EDITABLE(sp->text_entry), 0);
}
time_label_set_time(TIME_LABEL(sp->tlabel_expire), note->expire);
time_label_set_time(TIME_LABEL(sp->tlabel_created), note->created);
time_label_set_time(TIME_LABEL(sp->tlabel_changed), note->changed);
buff = g_strdup_printf("%ld", note->changes);
gtk_label_set_text(GTK_LABEL(sp->label_changes), buff);
g_free(buff);
if (note->id != NULL)
{
gtk_entry_set_text(GTK_ENTRY(sp->note_id_entry), note->id);
}
if (note->notetype == CheckNote || note->notetype == TodoNote)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sp->todo_check),
note->todo);
}
if (note->notetype == TodoNote)
{
gnome_date_edit_set_time(GNOME_DATE_EDIT(sp->de_deadline), note->deadline);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(sp->prio_entry), note->prio);
gtk_signal_handler_block_by_func(
GTK_OBJECT(sp->ad_complete), GTK_SIGNAL_FUNC(cb_complete_updates_done),
sp->todo_check);
gtk_adjustment_set_value(GTK_ADJUSTMENT(sp->ad_complete), note->complete);
gtk_signal_handler_unblock_by_func(
GTK_OBJECT(sp->ad_complete), GTK_SIGNAL_FUNC(cb_complete_updates_done),
sp->todo_check);
}
}
void
quarry_move_number_dialog_set_use_sequential_move_number
(QuarryMoveNumberDialog *dialog, gboolean use_sequential_move_number)
{
g_return_if_fail (QUARRY_IS_MOVE_NUMBER_DIALOG (dialog));
if (use_sequential_move_number) {
gtk_adjustment_set_value (dialog->move_number_adjustment,
dialog->sequential_move_number);
gtk_toggle_button_set_active (dialog->toggle_buttons[0], TRUE);
}
else
gtk_toggle_button_set_active (dialog->toggle_buttons[1], TRUE);
}
static void update_pos( void *user_data, gint total, gint current )
{
sequence_view_t *v = (sequence_view_t*) user_data;
multitracker_t *mt = v->backlink;
if(v->status_lock)
return;
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(v->timeline_)->adjustment), 1.0 / (gdouble) total * current );
char *now = format_time( current , mt->fps);
gtk_label_set_text( GTK_LABEL(v->labels_[0]), now );
free(now);
}
/*
* called from debugger module to show a message in debugger messages pane
*/
void on_debugger_message (const gchar* message, const gchar *color)
{
gchar *msg = g_strdup_printf("%s\n", message);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debugger_messages_textview));
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, msg, -1, color, NULL);
g_free(msg);
gtk_adjustment_set_value(vadj, gtk_adjustment_get_upper(vadj));
}
static gboolean slider_decrease_callback(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier, gpointer data)
{
GtkDarktableSlider *slider=DTGTK_SLIDER(data);
float value = gtk_adjustment_get_value(slider->adjustment);
value -= gtk_adjustment_get_step_increment(slider->adjustment);
if(slider->snapsize) value = slider->snapsize * (((int)value)/slider->snapsize);
gtk_adjustment_set_value(slider->adjustment, value);
gtk_widget_draw(GTK_WIDGET(slider),NULL);
g_signal_emit_by_name(G_OBJECT(slider),"value-changed");
return TRUE;
}
int
clip_GTK_ADJUSTMENTSETVALUE(ClipMachine * ClipMachineMemory)
{
C_widget *cadj = _fetch_cw_arg(ClipMachineMemory);
gfloat value = _clip_parnd(ClipMachineMemory, 2);
CHECKCWID(cadj, GTK_IS_ADJUSTMENT);
CHECKARG(2, NUMERIC_type_of_ClipVarType);
gtk_adjustment_set_value(GTK_ADJUSTMENT(cadj->widget), value);
return 0;
err:
return 1;
}
void
update_vscrollbar (DenemoProject * gui)
{
if(Denemo.non_interactive)
return;
GtkAdjustment *adj = GTK_ADJUSTMENT (Denemo.vadjustment);
gtk_adjustment_set_upper (adj, g_list_length (gui->movement->thescore) + 1.0);
gtk_adjustment_set_page_size (adj, gui->movement->bottom_staff - gui->movement->top_staff + 1.0);
gtk_adjustment_set_page_increment (adj, gui->movement->bottom_staff - gui->movement->top_staff + 1.0);
gtk_adjustment_set_value (adj, gui->movement->top_staff);
gtk_adjustment_changed (adj);
//gtk_range_slider_update (GTK_RANGE (Denemo.vscrollbar));
}
void wxTextCtrl::ShowPosition( long pos )
{
if (m_windowStyle & wxTE_MULTILINE)
{
GtkAdjustment *vp = GTK_TEXT(m_text)->vadj;
float totalLines = (float) GetNumberOfLines();
long posX;
long posY;
PositionToXY(pos, &posX, &posY);
float posLine = (float) posY;
float p = (posLine/totalLines)*(vp->upper - vp->lower) + vp->lower;
gtk_adjustment_set_value(GTK_TEXT(m_text)->vadj, p);
}
}
static void
display_shell_rotated (GimpDisplayShell *shell,
RotateDialogData *dialog)
{
g_signal_handlers_block_by_func (dialog->rotate_adj,
rotate_adjustment_changed,
dialog);
gtk_adjustment_set_value (dialog->rotate_adj, shell->rotate_angle);
g_signal_handlers_unblock_by_func (dialog->rotate_adj,
rotate_adjustment_changed,
dialog);
}
static void
alpha_scale_update (GtkWidget *color_button,
gpointer data)
{
GtkAdjustment *adj;
GimpRGB color;
adj = GTK_ADJUSTMENT (data);
gimp_color_button_get_color (GIMP_COLOR_BUTTON (color_button), &color);
gtk_adjustment_set_value (adj, color.a);
sinus_do_preview (NULL);
}
static void
load_dialog_set_ratio (gdouble x,
gdouble y)
{
ratio_x = x;
ratio_y = y;
g_signal_handlers_block_by_func (size, load_dialog_size_callback, NULL);
gimp_size_entry_set_refval (size, 0, wmf_width * x);
gimp_size_entry_set_refval (size, 1, wmf_height * y);
g_signal_handlers_unblock_by_func (size, load_dialog_size_callback, NULL);
g_signal_handlers_block_by_func (xadj, load_dialog_ratio_callback, NULL);
g_signal_handlers_block_by_func (yadj, load_dialog_ratio_callback, NULL);
gtk_adjustment_set_value (GTK_ADJUSTMENT (xadj), x);
gtk_adjustment_set_value (GTK_ADJUSTMENT (yadj), y);
g_signal_handlers_unblock_by_func (xadj, load_dialog_ratio_callback, NULL);
g_signal_handlers_unblock_by_func (yadj, load_dialog_ratio_callback, NULL);
}
void slider_refresh(GtkWidget * slider)
{
switch (SLIDER(slider)->type) {
case SLIDER_TYPE_INT:
gtk_adjustment_set_value(GTK_ADJUSTMENT
(SLIDER(slider)->adj),
GTK_ADJUSTMENT(SLIDER(slider)->
adj)->upper -
*(SLIDER(slider)->data.iptr));
break;
case SLIDER_TYPE_FLOAT:
gtk_adjustment_set_value(GTK_ADJUSTMENT
(SLIDER(slider)->adj),
GTK_ADJUSTMENT(SLIDER(slider)->
adj)->upper -
*(SLIDER(slider)->data.fptr));
break;
default:
printf("Ooops : Bad slider type : %d\n",
SLIDER(slider)->type);
return;
}
}
void MainWindow::log(const char* msg){
GtkTextBuffer *buffer;
GtkTextIter end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(_log));
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_insert (buffer, &end, msg, -1);
// Scroll para o final do Textview
GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(_logScroll));
gtk_adjustment_set_value(adj, (gtk_adjustment_get_upper(adj) -
gtk_adjustment_get_page_size(adj)));
}
static void
gimp_scale_entry_unconstrained_adjustment_callback (GtkAdjustment *adjustment,
GtkAdjustment *other_adj)
{
g_signal_handlers_block_by_func (other_adj,
gimp_scale_entry_unconstrained_adjustment_callback,
adjustment);
gtk_adjustment_set_value (other_adj, gtk_adjustment_get_value (adjustment));
g_signal_handlers_unblock_by_func (other_adj,
gimp_scale_entry_unconstrained_adjustment_callback,
adjustment);
}
static void set_freq_global(GtkWidget *button, gpointer data) {
gint i, value;
gchar *txt;
hf_wrapper_struct *hfw;
hfw = (hf_wrapper_struct *) * (hf_wrapper_struct **) data;
gtk_label_get(GTK_LABEL(GTK_BIN(button)->child), &txt);
value = atoi(txt);
for (i=0; i<12; i++) {
hfw->hf_options->surfadd_options->frq_percent[i] = value;
gtk_adjustment_set_value(
GTK_ADJUSTMENT(hfw->hf_options->freq_control_adj[i]), value);
}
gener_hf(hfw);
}
static void
gimp_posterize_tool_config_notify (GObject *object,
GParamSpec *pspec,
GimpPosterizeTool *posterize_tool)
{
GimpPosterizeConfig *config = GIMP_POSTERIZE_CONFIG (object);
if (! posterize_tool->levels_data)
return;
gtk_adjustment_set_value (posterize_tool->levels_data, config->levels);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (posterize_tool));
}
static void
dma_sparse_view_move_cursor (GtkTextView *text_view,
GtkMovementStep step,
gint count,
gboolean extend_selection)
{
DmaSparseView *view = DMA_SPARSE_VIEW (text_view);
switch (step)
{
case GTK_MOVEMENT_LOGICAL_POSITIONS:
case GTK_MOVEMENT_VISUAL_POSITIONS:
case GTK_MOVEMENT_WORDS:
case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
case GTK_MOVEMENT_HORIZONTAL_PAGES:
break;
case GTK_MOVEMENT_DISPLAY_LINES:
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PARAGRAPH_ENDS:
dma_sparse_iter_forward_lines (&view->priv->start, count);
gtk_adjustment_set_value (view->priv->vadjustment, (gdouble)dma_sparse_iter_get_address (&view->priv->start));
return;
case GTK_MOVEMENT_PAGES:
dma_sparse_iter_forward_lines (&view->priv->start, count * (view->priv->line_by_page > 1 ? view->priv->line_by_page - 1 : view->priv->line_by_page));
gtk_adjustment_set_value (view->priv->vadjustment, (gdouble)dma_sparse_iter_get_address (&view->priv->start));
return;
case GTK_MOVEMENT_BUFFER_ENDS:
break;
default:
break;
}
GTK_TEXT_VIEW_CLASS (parent_class)->move_cursor (text_view,
step, count,
extend_selection);
}
static void
gimp_brush_editor_set_data (GimpDataEditor *editor,
GimpData *data)
{
GimpBrushEditor *brush_editor = GIMP_BRUSH_EDITOR (editor);
GimpBrushGeneratedShape shape = GIMP_BRUSH_GENERATED_CIRCLE;
gdouble radius = 0.0;
gint spikes = 2;
gdouble hardness = 0.0;
gdouble ratio = 0.0;
gdouble angle = 0.0;
gdouble spacing = 0.0;
if (editor->data)
g_signal_handlers_disconnect_by_func (editor->data,
gimp_brush_editor_notify_brush,
editor);
GIMP_DATA_EDITOR_CLASS (parent_class)->set_data (editor, data);
if (editor->data)
g_signal_connect (editor->data, "notify",
G_CALLBACK (gimp_brush_editor_notify_brush),
editor);
gimp_view_set_viewable (GIMP_VIEW (editor->view), GIMP_VIEWABLE (data));
if (editor->data)
{
spacing = gimp_brush_get_spacing (GIMP_BRUSH (editor->data));
if (GIMP_IS_BRUSH_GENERATED (editor->data))
{
GimpBrushGenerated *brush = GIMP_BRUSH_GENERATED (editor->data);
shape = gimp_brush_generated_get_shape (brush);
radius = gimp_brush_generated_get_radius (brush);
spikes = gimp_brush_generated_get_spikes (brush);
hardness = gimp_brush_generated_get_hardness (brush);
ratio = gimp_brush_generated_get_aspect_ratio (brush);
angle = gimp_brush_generated_get_angle (brush);
}
}
gtk_widget_set_sensitive (brush_editor->options_box,
editor->data_editable);
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (brush_editor->shape_group),
shape);
gtk_adjustment_set_value (brush_editor->radius_data, radius);
gtk_adjustment_set_value (brush_editor->spikes_data, spikes);
gtk_adjustment_set_value (brush_editor->hardness_data, hardness);
gtk_adjustment_set_value (brush_editor->aspect_ratio_data, ratio);
gtk_adjustment_set_value (brush_editor->angle_data, angle);
gtk_adjustment_set_value (brush_editor->spacing_data, spacing);
}
void
nautilus_toolbar_reset_menus (NautilusToolbar *self)
{
NautilusWindowSlot *slot;
NautilusView *view;
GActionGroup *view_action_group;
GVariant *variant;
GVariantIter iter;
gboolean show_sort_trash, show_sort_search, show_sort_access, show_sort_modification, enable_sort;
const gchar *hint;
/* Allow actions from the current view to be activated through
* the view menu and action menu of the toolbar */
slot = nautilus_window_get_active_slot (self->priv->window);
view = nautilus_window_slot_get_current_view (slot);
view_action_group = nautilus_view_get_action_group (view);
gtk_widget_insert_action_group (GTK_WIDGET (self),
"view",
G_ACTION_GROUP (view_action_group));
gtk_widget_set_visible (self->priv->visible_columns,
g_action_group_has_action (view_action_group, "visible-columns"));
enable_sort = g_action_group_get_action_enabled (view_action_group, "sort");
show_sort_trash = show_sort_search = show_sort_modification = show_sort_access = FALSE;
gtk_widget_set_visible (self->priv->sort_menu, enable_sort);
if (enable_sort) {
variant = g_action_group_get_action_state_hint (view_action_group, "sort");
g_variant_iter_init (&iter, variant);
while (g_variant_iter_next (&iter, "&s", &hint)) {
if (g_strcmp0 (hint, "trash-time") == 0)
show_sort_trash = TRUE;
if (g_strcmp0 (hint, "search-relevance") == 0)
show_sort_search = TRUE;
}
g_variant_unref (variant);
}
gtk_widget_set_visible (self->priv->sort_trash_time, show_sort_trash);
gtk_widget_set_visible (self->priv->sort_search_relevance, show_sort_search);
variant = g_action_group_get_action_state (view_action_group, "zoom-to-level");
gtk_adjustment_set_value (self->priv->zoom_adjustment,
g_variant_get_int32 (variant));
g_variant_unref (variant);
}
static void scale_value_received(GObject *object,
CtrlEvent *event,
gpointer user_data)
{
CtkImageSliders *ctk_image_sliders = CTK_IMAGE_SLIDERS(user_data);
GtkAdjustment *adj;
GtkWidget *scale;
gint val;
if (event->type != CTRL_EVENT_TYPE_INTEGER_ATTRIBUTE) {
return;
}
switch (event->int_attr.attribute) {
case NV_CTRL_DIGITAL_VIBRANCE:
scale = ctk_image_sliders->digital_vibrance;
break;
case NV_CTRL_IMAGE_SHARPENING:
scale = ctk_image_sliders->image_sharpening;
break;
default:
return;
}
if (event->int_attr.is_availability_changed) {
setup_scale(ctk_image_sliders, event->int_attr.attribute, scale);
}
adj = CTK_SCALE(scale)->gtk_adjustment;
val = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj));
if (val != event->int_attr.value) {
val = event->int_attr.value;
g_signal_handlers_block_by_func(adj, scale_value_changed,
ctk_image_sliders);
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val);
post_scale_value_changed(GTK_ADJUSTMENT(adj),
ctk_image_sliders, val);
g_signal_handlers_unblock_by_func(adj, scale_value_changed,
ctk_image_sliders);
}
} /* scale_value_received() */
__EXPORT void lttvwindow_report_time_window(Tab *tab,
TimeWindow time_window)
{
//set_time_window(tab, time_window);
//set_time_window_adjustment(tab, time_window);
time_change_manager(tab, time_window);
#if 0
/* Set scrollbar */
LttvTracesetContext *tsc =
LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
TimeInterval time_span = tsc->time_span;
GtkAdjustment *adjustment = gtk_range_get_adjustment(GTK_RANGE(tab->scrollbar));
g_object_set(G_OBJECT(adjustment),
"lower",
0.0, /* lower */
"upper",
ltt_time_to_double(
ltt_time_sub(time_span.end_time, time_span.start_time))
, /* upper */
"step_increment",
ltt_time_to_double(time_window->time_width)
/ SCROLL_STEP_PER_PAGE
, /* step increment */
"page_increment",
ltt_time_to_double(time_window->time_width)
, /* page increment */
"page_size",
ltt_time_to_double(time_window->time_width)
, /* page size */
NULL);
gtk_adjustment_changed(adjustment);
//g_object_set(G_OBJECT(adjustment),
// "value",
// ltt_time_to_double(time_window->start_time)
// , /* value */
// NULL);
/* Note : the set value will call set_time_window if scrollbar value changed
*/
gtk_adjustment_set_value(adjustment,
ltt_time_to_double(
ltt_time_sub(time_window->start_time,
time_span.start_time))
);
#endif //0
}
void
sheet_scroll (const Sheet *sheet, int delta_x, int delta_y)
{
GtkAdjustment *hadj, *vadj;
GtkAllocation allocation;
gfloat vnew, hnew;
gfloat hmax, vmax;
const SheetPriv *priv = sheet->priv;
hadj = gtk_container_get_focus_hadjustment (GTK_CONTAINER (sheet));
vadj = gtk_container_get_focus_vadjustment (GTK_CONTAINER (sheet));
gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation);
if (priv->width > allocation.width)
hmax = (gfloat) (priv->width - allocation.width);
else
hmax = 0.0;
if (priv->height > allocation.height)
vmax = (gfloat) (priv->height - allocation.height);
else
vmax = 0.0;
hnew = CLAMP (gtk_adjustment_get_value (hadj) + (gfloat) delta_x, 0.0, hmax);
vnew = CLAMP (gtk_adjustment_get_value (vadj) + (gfloat) delta_y, 0.0, vmax);
if (hnew != gtk_adjustment_get_value (hadj)) {
gtk_adjustment_set_value (hadj, hnew);
g_signal_emit_by_name (G_OBJECT (hadj), "value_changed");
}
if (vnew != gtk_adjustment_get_value (vadj)) {
gtk_adjustment_set_value (vadj, vnew);
g_signal_emit_by_name (G_OBJECT (vadj), "value_changed");
}
}
static void cb_page_size( GtkAdjustment *get,
GtkAdjustment *set )
{
/* Set the page size and page increment size of the sample
* adjustment to the value specified by the "Page Size" scale */
set->page_size = get->value;
set->page_increment = get->value;
/* This sets the adjustment and makes it emit the "changed" signal to
reconfigure all the widgets that are attached to this signal. */
gtk_adjustment_set_value (set, CLAMP (set->value,
set->lower,
(set->upper - set->page_size)));
g_signal_emit_by_name(G_OBJECT(set), "changed");
}
extern gboolean window_callback(GtkWidget *widget, gpointer data)
{
struct view_s* v = data;
v->mode = gtk_combo_box_get_active(v->gtk_mode);
v->winlow = gtk_adjustment_get_value(v->gtk_winlow);
v->winhigh = gtk_adjustment_get_value(v->gtk_winhigh);
for (struct view_s* v2 = v->next; v2 != v; v2 = v2->next) {
if (v->sync && v2->sync) {
gtk_adjustment_set_value(v2->gtk_winlow, v->winlow);
gtk_adjustment_set_value(v2->gtk_winhigh, v->winhigh);
gtk_combo_box_set_active(v2->gtk_mode, v->mode);
}
}
v->rgb_invalid = true;
update_view(v);
return FALSE;
}
void carmen_map_graphics_adjust_scrollbars(GtkMapViewer *map_view,
carmen_world_point_p new_centre)
{
double x_value, y_value;
carmen_point_t screen;
GtkAdjustment *x_scroll_adj, *y_scroll_adj;
world_to_screen(new_centre, &screen, map_view);
x_scroll_adj = map_view->x_scroll_adj;
y_scroll_adj = map_view->y_scroll_adj;
screen.x += map_view->x_scroll_adj->value;
screen.y += map_view->y_scroll_adj->value;
x_value = screen.x - (x_scroll_adj->page_size/2);
y_value = screen.y - (y_scroll_adj->page_size/2);
if (x_value + x_scroll_adj->page_size > x_scroll_adj->upper)
x_value = x_scroll_adj->upper - x_scroll_adj->page_size;
if (x_value < 0)
x_value = 0;
if (y_value + y_scroll_adj->page_size > y_scroll_adj->upper)
y_value = y_scroll_adj->upper - y_scroll_adj->page_size;
if (y_value < 0)
y_value = 0;
if (fabs(x_scroll_adj->value - x_value) < 10.0 &&
fabs(y_scroll_adj->value - y_value) < 10.0)
return;
gtk_adjustment_set_value(x_scroll_adj, x_value);
gtk_adjustment_set_value(y_scroll_adj, y_value);
map_view->centre = *new_centre;
}
static void
vadjustment_changed_cb (GtkAdjustment *adjustment,
gpointer user_data)
{
CbMediaImageWidget *self = user_data;
double upper;
double new_value;
upper = gtk_adjustment_get_upper (adjustment);
new_value = upper * self->initial_scroll_y - (gtk_adjustment_get_page_size (adjustment) / 2.0);
gtk_adjustment_set_value (adjustment, new_value);
g_signal_handler_disconnect (adjustment, self->vadj_changed_id);
}
void gui_window_set_scroll(struct gui_window *g, int sx, int sy)
{
GtkAdjustment *vadj = nsgtk_layout_get_vadjustment(g->layout);
GtkAdjustment *hadj = nsgtk_layout_get_hadjustment(g->layout);
gdouble vlower, vpage, vupper, hlower, hpage, hupper, x = (double)sx, y = (double)sy;
assert(vadj);
assert(hadj);
g_object_get(vadj, "page-size", &vpage, "lower", &vlower, "upper", &vupper, NULL);
g_object_get(hadj, "page-size", &hpage, "lower", &hlower, "upper", &hupper, NULL);
if (x < hlower)
x = hlower;
if (x > (hupper - hpage))
x = hupper - hpage;
if (y < vlower)
y = vlower;
if (y > (vupper - vpage))
y = vupper - vpage;
gtk_adjustment_set_value(vadj, y);
gtk_adjustment_set_value(hadj, x);
}
