static void
init_data_sheet (PsppireDataEditor *de)
{
GtkAdjustment *vadj0, *hadj0;
GtkAdjustment *vadj1, *hadj1;
GtkWidget *sheet ;
de->vaxis[0] = psppire_axis_new ();
de->vaxis[1] = psppire_axis_new ();
/* There's only one horizontal axis, since the
column widths are parameters of the variables */
de->haxis = psppire_axis_new ();
de->split = TRUE;
de->paned = gtk_xpaned_new ();
init_sheet (de, 0, NULL, NULL, de->vaxis[0], de->haxis);
gtk_widget_show (de->sheet_bin[0]);
vadj0 = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[0]));
hadj0 = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[0]));
g_object_set (de->sheet_bin[0], "vscrollbar-policy", GTK_POLICY_NEVER, NULL);
g_object_set (de->sheet_bin[0], "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
init_sheet (de, 1, NULL, vadj0, de->vaxis[0], de->haxis);
gtk_widget_show (de->sheet_bin[1]);
sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[1]));
psppire_sheet_hide_row_titles (PSPPIRE_SHEET (sheet));
hadj1 = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[1]));
g_object_set (de->sheet_bin[1], "vscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
g_object_set (de->sheet_bin[1], "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
init_sheet (de, 2, hadj0, NULL, de->vaxis[1], de->haxis);
gtk_widget_show (de->sheet_bin[2]);
sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[2]));
psppire_sheet_hide_column_titles (PSPPIRE_SHEET (sheet));
g_object_set (de->sheet_bin[2], "vscrollbar-policy", GTK_POLICY_NEVER, NULL);
g_object_set (de->sheet_bin[2], "hscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
vadj1 = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[2]));
init_sheet (de, 3, hadj1, vadj1, de->vaxis[1], de->haxis);
gtk_widget_show (de->sheet_bin[3]);
sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[3]));
psppire_sheet_hide_column_titles (PSPPIRE_SHEET (sheet));
psppire_sheet_hide_row_titles (PSPPIRE_SHEET (sheet));
g_object_set (de->sheet_bin[3], "vscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
g_object_set (de->sheet_bin[3], "hscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
gtk_xpaned_pack_top_left (GTK_XPANED (de->paned), de->sheet_bin[0], TRUE, TRUE);
gtk_xpaned_pack_top_right (GTK_XPANED (de->paned), de->sheet_bin[1], TRUE, TRUE);
gtk_xpaned_pack_bottom_left (GTK_XPANED (de->paned), de->sheet_bin[2], TRUE, TRUE);
gtk_xpaned_pack_bottom_right (GTK_XPANED (de->paned), de->sheet_bin[3], TRUE, TRUE);
gtk_xpaned_set_position_y (GTK_XPANED (de->paned), 150);
gtk_xpaned_set_position_x (GTK_XPANED (de->paned), 350);
}
static void
ephy_push_scroller_scroll_pixels (EphyEmbed *embed, int scroll_x, int scroll_y)
{
GtkAdjustment *adj;
gdouble value;
gdouble new_value;
gdouble page_size;
gdouble upper;
gdouble lower;
GtkWidget *sw;
sw = gtk_widget_get_parent (GTK_WIDGET (ephy_embed_get_web_view (embed)));
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (sw));
adj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (sw));
upper = gtk_adjustment_get_upper (adj);
lower = gtk_adjustment_get_lower (adj);
value = gtk_adjustment_get_value (adj);
page_size = gtk_adjustment_get_page_size (adj);
new_value = CLAMP (value - scroll_x, lower, upper - page_size);
gtk_adjustment_set_value (adj, new_value);
adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (sw));
upper = gtk_adjustment_get_upper (adj);
lower = gtk_adjustment_get_lower (adj);
value = gtk_adjustment_get_value (adj);
page_size = gtk_adjustment_get_page_size (adj);
new_value = CLAMP (value - scroll_y, lower, upper - page_size);
gtk_adjustment_set_value (adj, new_value);
}
/*
* gets the sheets parent adjustments
* returns TRUE on success
*/
gboolean
sheet_get_adjustments (const Sheet *sheet, GtkAdjustment **hadj, GtkAdjustment **vadj)
{
GtkWidget *parent;
GtkScrolledWindow *scrolled;
if (__unlikely (!sheet))
return FALSE;
if (__unlikely (!vadj || !hadj))
return FALSE;
parent = gtk_widget_get_parent (GTK_WIDGET (sheet));
if (__unlikely (!parent || !GTK_IS_SCROLLED_WINDOW (parent)))
return FALSE;
scrolled = GTK_SCROLLED_WINDOW (parent);
*hadj = gtk_scrolled_window_get_hadjustment (scrolled);
if (__unlikely (!*hadj || !GTK_IS_ADJUSTMENT (*hadj)))
return FALSE;
*vadj = gtk_scrolled_window_get_vadjustment (scrolled);
if (__unlikely (!*vadj || !GTK_IS_ADJUSTMENT (*vadj)))
return FALSE;
return TRUE;
}
GtkWidget *
picture_create_widget (GtkWidget * dlg)
{
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), options.hscroll_policy, options.vscroll_policy);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (sw)),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (sw)));
gtk_container_add (GTK_CONTAINER (sw), viewport);
picture = gtk_image_new ();
gtk_container_add (GTK_CONTAINER (viewport), picture);
/* load picture */
if (options.common_data.uri &&
g_file_test (options.common_data.uri, G_FILE_TEST_EXISTS))
load_picture (options.common_data.uri);
else
gtk_image_set_from_stock (GTK_IMAGE (picture), "gtk-missing-image", GTK_ICON_SIZE_DIALOG);
if (loaded && !animated)
{
create_popup_menu ();
g_signal_connect (G_OBJECT (viewport), "button-press-event", G_CALLBACK (button_handler), NULL);
g_signal_connect (G_OBJECT (viewport), "key-press-event", G_CALLBACK (key_handler), NULL);
}
return sw;
}
/* Update our geometry from the fixed widget.
*/
static void
workspaceview_scroll_update( Workspaceview *wview )
{
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
GtkAdjustment *hadj = gtk_scrolled_window_get_hadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
GtkAdjustment *vadj = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
wview->vp.left = hadj->value;
wview->vp.top = vadj->value;
wview->vp.width = hadj->page_size;
wview->vp.height = vadj->page_size;
wview->width = hadj->upper;
wview->height = vadj->upper;
/* Update vp hint in model too.
*/
ws->vp = wview->vp;
#ifdef DEBUG
printf( "workspaceview_scroll_update: %s\n", IOBJECT( ws )->name );
printf( " wview->vp: l=%d, t=%d, w=%d, h=%d; fixed w=%d; h=%d\n",
wview->vp.left, wview->vp.top,
wview->vp.width, wview->vp.height,
wview->width, wview->height );
#endif /*DEBUG*/
}
/* Scroll to make an xywh area visible. If the area is larger than the
* viewport, position the view at the bottom left if the xywh area ...
* this is usually right for workspaces.
*/
void
workspaceview_scroll( Workspaceview *wview, int x, int y, int w, int h )
{
GtkAdjustment *hadj = gtk_scrolled_window_get_hadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
GtkAdjustment *vadj = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
Rect *vp = &wview->vp;
int nx, ny;
nx = hadj->value;
if( x + w > IM_RECT_RIGHT( vp ) )
nx = IM_MAX( 0, (x + w) - vp->width );
if( x < nx )
nx = x;
ny = vadj->value;
if( y + h > IM_RECT_BOTTOM( vp ) )
ny = IM_MAX( 0, (y + h) - vp->height );
if( y < ny )
ny = y;
#ifdef DEBUG
printf( "workspaceview_scroll: x=%d, y=%d, w=%d, h=%d, "
"nx = %d, ny = %d\n", x, y, w, h, nx, ny );
#endif /*DEBUG*/
adjustments_set_value( hadj, vadj, nx, ny );
}
static gint
luaH_webview_scroll_index(lua_State *L)
{
webview_data_t *d = luaH_checkwvdata(L, lua_upvalueindex(1));
const gchar *prop = luaL_checkstring(L, 2);
luakit_token_t t = l_tokenize(prop);
GtkAdjustment *a = (*prop == 'x') ?
gtk_scrolled_window_get_hadjustment(d->win)
: gtk_scrolled_window_get_vadjustment(d->win);
if (t == L_TK_X || t == L_TK_Y) {
lua_pushnumber(L, gtk_adjustment_get_value(a));
return 1;
} else if (t == L_TK_XMAX || t == L_TK_YMAX) {
lua_pushnumber(L, gtk_adjustment_get_upper(a) -
gtk_adjustment_get_page_size(a));
return 1;
} else if (t == L_TK_XPAGE_SIZE || t == L_TK_YPAGE_SIZE) {
lua_pushnumber(L, gtk_adjustment_get_page_size(a));
return 1;
}
return 0;
}
void
cb_refresh_view(GtkWidget* GIRARA_UNUSED(view), gpointer data)
{
zathura_t* zathura = data;
if (zathura == NULL || zathura->document == NULL) {
return;
}
unsigned int page_id = zathura_document_get_current_page_number(zathura->document);
zathura_page_t* page = zathura_document_get_page(zathura->document, page_id);
if (page == NULL) {
return;
}
GtkAdjustment* vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
GtkAdjustment* hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
double position_x = zathura_document_get_position_x(zathura->document);
double position_y = zathura_document_get_position_y(zathura->document);
zathura_adjustment_set_value_from_ratio(vadj, position_y);
zathura_adjustment_set_value_from_ratio(hadj, position_x);
statusbar_page_number_update(zathura);
}
static gint
luaH_webview_get_hscroll(lua_State *L)
{
widget_t *w = luaH_checkudata(L, 1, &widget_class);
GtkAdjustment *adjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(w->widget));
return push_adjustment_values(L, adjustment);
}
bool
sc_goto(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int t)
{
g_return_val_if_fail(session != NULL, false);
g_return_val_if_fail(session->global.data != NULL, false);
zathura_t* zathura = session->global.data;
g_return_val_if_fail(argument != NULL, false);
g_return_val_if_fail(zathura->document != NULL, false);
zathura_jumplist_save(zathura);
if (t != 0) {
/* add offset */
t += zathura_document_get_page_offset(zathura->document);
page_set(zathura, t - 1);
} else if (argument->n == TOP) {
page_set(zathura, 0);
} else if (argument->n == BOTTOM) {
page_set(zathura, zathura_document_get_number_of_pages(zathura->document) - 1);
}
/* adjust horizontal position */
GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(session->gtk.view));
cb_view_hadjustment_changed(hadjustment, zathura);
zathura_jumplist_add(zathura);
return false;
}
static void
add_row(GtkWidget *table, gint *row_p,
const gchar *name, const gchar *value, gboolean multiline,
gboolean expand)
{
gchar *bold_name;
GtkWidget *name_w;
bold_name = g_strconcat("<b>", name, "</b>", NULL);
name_w = gtk_label_new(bold_name);
g_free(bold_name);
gtk_misc_set_alignment(GTK_MISC(name_w), 0.0, 0.0);
gtk_label_set_use_markup(GTK_LABEL(name_w), TRUE);
gtk_table_attach(GTK_TABLE(table), name_w, 0, 1, *row_p, *row_p + 1,
GTK_FILL, GTK_FILL, 0, 0);
if (multiline) {
GtkWidget *label, *viewport;
GtkScrolledWindow *swin;
guint flags;
label = gtk_label_new (value);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_widget_set_size_request (label, 200, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
swin = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
gtk_scrolled_window_set_policy(swin,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (swin),
gtk_scrolled_window_get_vadjustment (swin));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER(swin), viewport);
(*row_p)++;
if (expand)
flags = GTK_FILL|GTK_EXPAND;
else
flags = GTK_FILL;
gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(swin), 0, 2, *row_p, *row_p + 1,
GTK_FILL|GTK_EXPAND, flags, 0, 0);
gtk_container_add (GTK_CONTAINER (viewport), label);
} else {
GtkWidget *label = gtk_label_new(value);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, *row_p, *row_p + 1,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
}
(*row_p)++;
}
void
thunar_progress_dialog_add_job (ThunarProgressDialog *dialog,
ThunarJob *job,
const gchar *icon_name,
const gchar *title)
{
GtkWidget *viewport;
GtkWidget *view;
_thunar_return_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog));
_thunar_return_if_fail (THUNAR_IS_JOB (job));
_thunar_return_if_fail (g_utf8_validate (title, -1, NULL));
view = thunar_progress_view_new_with_job (job);
thunar_progress_view_set_icon_name (THUNAR_PROGRESS_VIEW (view), icon_name);
thunar_progress_view_set_title (THUNAR_PROGRESS_VIEW (view), title);
gtk_box_pack_start (GTK_BOX (dialog->content_box), view, FALSE, TRUE, 0);
gtk_widget_show (view);
/* use the first job's icon-name for the dialog */
if (dialog->views == NULL)
gtk_window_set_icon_name (GTK_WINDOW (dialog), icon_name);
/* add the view to the list of known views */
dialog->views = g_list_prepend (dialog->views, view);
/* check if we need to wrap the views in a scroll window (starting
* at SCROLLVIEW_THRESHOLD parallel operations */
if (g_list_length (dialog->views) == SCROLLVIEW_THRESHOLD)
{
/* create a scrolled window and add it to the dialog */
dialog->scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (dialog->vbox), dialog->scrollwin);
gtk_widget_show (dialog->scrollwin);
/* create a viewport for the content box */
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin)),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin)));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (dialog->scrollwin), viewport);
gtk_widget_show (viewport);
/* move the content box into the viewport */
gtk_widget_reparent (dialog->content_box, viewport);
}
g_signal_connect_swapped (view, "need-attention",
G_CALLBACK (thunar_progress_dialog_view_needs_attention), dialog);
g_signal_connect_swapped (view, "finished",
G_CALLBACK (thunar_progress_dialog_job_finished), dialog);
if (dialog->status_icon != NULL)
thunar_progress_dialog_update_status_icon (dialog);
}
bool
sc_mouse_scroll(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t)
{
g_return_val_if_fail(session != NULL, false);
g_return_val_if_fail(session->global.data != NULL, false);
zathura_t* zathura = session->global.data;
g_return_val_if_fail(argument != NULL, false);
g_return_val_if_fail(event != NULL, false);
if (zathura->document == NULL) {
return false;
}
static int x = 0;
static int y = 0;
GtkAdjustment* x_adj = NULL;
GtkAdjustment* y_adj = NULL;
switch (event->type) {
/* scroll */
case GIRARA_EVENT_SCROLL_UP:
case GIRARA_EVENT_SCROLL_DOWN:
case GIRARA_EVENT_SCROLL_LEFT:
case GIRARA_EVENT_SCROLL_RIGHT:
return sc_scroll(session, argument, NULL, t);
/* drag */
case GIRARA_EVENT_BUTTON_PRESS:
x = event->x;
y = event->y;
break;
case GIRARA_EVENT_BUTTON_RELEASE:
x = 0;
y = 0;
break;
case GIRARA_EVENT_MOTION_NOTIFY:
x_adj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(session->gtk.view));
y_adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(session->gtk.view));
if (x_adj == NULL || y_adj == NULL) {
return false;
}
zathura_adjustment_set_value(x_adj,
gtk_adjustment_get_value(x_adj) - (event->x - x));
zathura_adjustment_set_value(y_adj,
gtk_adjustment_get_value(y_adj) - (event->y - y));
break;
/* unhandled events */
default:
break;
}
return false;
}
static gint
luaH_webview_set_scroll_horiz(lua_State *L)
{
widget_t *w = luaH_checkudata(L, 1, &widget_class);
gdouble value = (gdouble) luaL_checknumber(L, 2);
GtkAdjustment *adjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(w->widget));
set_adjustment(adjustment, value);
return 0;
}
void
cb_view_vadjustment_value_changed(GtkAdjustment* GIRARA_UNUSED(adjustment), gpointer data)
{
zathura_t* zathura = data;
if (zathura == NULL || zathura->document == NULL || zathura->ui.page_widget == NULL) {
return;
}
GtkAdjustment* view_vadjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
GtkAdjustment* view_hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
GdkRectangle view_rect;
/* get current adjustment values */
view_rect.y = 0;
view_rect.height = gtk_adjustment_get_page_size(view_vadjustment);
view_rect.x = 0;
view_rect.width = gtk_adjustment_get_page_size(view_hadjustment);
int page_padding = 1;
girara_setting_get(zathura->ui.session, "page-padding", &page_padding);
GdkRectangle center;
center.x = (view_rect.width + 1) / 2;
center.y = (view_rect.height + 1) / 2;
center.height = center.width = (2 * page_padding) + 1;
unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
double scale = zathura_document_get_scale(zathura->document);
bool updated = false;
/* find page that fits */
for (unsigned int page_id = 0; page_id < number_of_pages; page_id++) {
zathura_page_t* page = zathura_document_get_page(zathura->document, page_id);
GdkRectangle page_rect;
GtkWidget* page_widget = zathura_page_get_widget(zathura, page);
gtk_widget_translate_coordinates(page_widget,
zathura->ui.session->gtk.view, 0, 0, &page_rect.x, &page_rect.y);
page_rect.width = zathura_page_get_width(page) * scale;
page_rect.height = zathura_page_get_height(page) * scale;
if (gdk_rectangle_intersect(&view_rect, &page_rect, NULL) == TRUE) {
zathura_page_set_visibility(page, true);
if (zathura->global.update_page_number == true && updated == false
&& gdk_rectangle_intersect(¢er, &page_rect, NULL) == TRUE) {
zathura_document_set_current_page_number(zathura->document, page_id);
updated = true;
}
} else {
zathura_page_set_visibility(page, false);
}
zathura_page_widget_update_view_time(ZATHURA_PAGE(page_widget));
}
statusbar_page_number_update(zathura);
}
void
cmd_scrollbars_visibility() {
if(uzbl.gui.scrollbars_visible) {
uzbl.gui.bar_h = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (uzbl.gui.scrolled_win));
uzbl.gui.bar_v = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (uzbl.gui.scrolled_win));
}
else {
uzbl.gui.bar_v = gtk_range_get_adjustment (GTK_RANGE (uzbl.gui.scbar_v));
uzbl.gui.bar_h = gtk_range_get_adjustment (GTK_RANGE (uzbl.gui.scbar_h));
}
gtk_widget_set_scroll_adjustments (GTK_WIDGET (uzbl.gui.web_view), uzbl.gui.bar_h, uzbl.gui.bar_v);
}
static void
create_gui(MathWindow *window)
{
GtkWidget *main_vbox, *vbox;
GtkWidget *scrolled_window;
main_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), main_vbox);
gtk_widget_show(main_vbox);
window->priv->menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(main_vbox), window->priv->menu_bar, TRUE, TRUE, 0);
gtk_widget_show(window->priv->menu_bar);
create_menu(window);
vbox = gtk_vbox_new(FALSE, 6);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
gtk_box_pack_start(GTK_BOX(main_vbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(scrolled_window), TRUE, TRUE, 0);
g_signal_connect(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrolled_window)), "changed", G_CALLBACK(scroll_changed_cb), window);
g_signal_connect(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrolled_window)), "value-changed", G_CALLBACK(scroll_value_changed_cb), window);
window->priv->right_aligned = TRUE;
gtk_widget_show(scrolled_window);
window->priv->display = math_display_new_with_equation(window->priv->equation);
gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(window->priv->display));
gtk_widget_show(GTK_WIDGET(window->priv->display));
window->priv->buttons = math_buttons_new(window->priv->equation);
g_signal_connect(window->priv->buttons, "notify::mode", G_CALLBACK(button_mode_changed_cb), window);
button_mode_changed_cb(window->priv->buttons, NULL, window);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(window->priv->buttons), TRUE, TRUE, 0);
gtk_widget_show(GTK_WIDGET(window->priv->buttons));
}
void
sheet_get_pointer (Sheet *sheet, gdouble *x, gdouble *y)
{
GtkWidget *widget;
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
gdouble value, x1, y1;
gint _x, _y;
GdkDeviceManager *device_manager;
GdkDevice *device_pointer;
GdkRectangle allocation;
// gtk_widget_get_pointer (GTK_WIDGET (sheet), &_x, &_y);
// replaced by a code copied from evince
if (!gtk_widget_get_realized (GTK_WIDGET (sheet)))
return;
device_manager = gdk_display_get_device_manager (
gtk_widget_get_display (GTK_WIDGET (sheet)));
device_pointer = gdk_device_manager_get_client_pointer (device_manager);
gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET (sheet)),
device_pointer,
&_x, &_y, NULL);
if (!gtk_widget_get_has_window (GTK_WIDGET (sheet)))
return;
gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation);
_x -= allocation.x;
_y -= allocation.y;
x1 = (gdouble) _x;
y1 = (gdouble) _y;
widget = gtk_widget_get_parent (GTK_WIDGET (sheet));
hadjustment = gtk_scrolled_window_get_hadjustment (
GTK_SCROLLED_WINDOW (widget));
value = gtk_adjustment_get_value (hadjustment);
x1 += value;
vadjustment = gtk_scrolled_window_get_vadjustment (
GTK_SCROLLED_WINDOW (widget));
value = gtk_adjustment_get_value (vadjustment);
y1 += value;
*x = x1;
*y = y1;
goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), x, y);
snap_to_grid (sheet->grid, x, y);
}
bool
sc_navigate(girara_session_t* session, girara_argument_t* argument,
girara_event_t* UNUSED(event), unsigned int t)
{
g_return_val_if_fail(session != NULL, false);
g_return_val_if_fail(session->global.data != NULL, false);
zathura_t* zathura = session->global.data;
g_return_val_if_fail(argument != NULL, false);
g_return_val_if_fail(zathura->document != NULL, false);
int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
int new_page = zathura_document_get_current_page_number(zathura->document);
bool scroll_wrap = false;
girara_setting_get(session, "scroll-wrap", &scroll_wrap);
bool columns_per_row_offset = false;
girara_setting_get(session, "advance-pages-per-row", &columns_per_row_offset);
int offset = 1;
if (columns_per_row_offset == true) {
girara_setting_get(session, "pages-per-row", &offset);
}
t = (t == 0) ? (unsigned int) offset : t;
if (argument->n == NEXT) {
if (scroll_wrap == false) {
new_page = new_page + t;
} else {
new_page = (new_page + t) % number_of_pages;
}
} else if (argument->n == PREVIOUS) {
if (scroll_wrap == false) {
new_page = new_page - t;
} else {
new_page = (new_page + number_of_pages - t) % number_of_pages;
}
}
if ((new_page < 0 || new_page >= number_of_pages) && !scroll_wrap) {
return false;
}
page_set(zathura, new_page);
/* adjust horizontal position */
GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(session->gtk.view));
cb_view_hadjustment_changed(hadjustment, zathura);
return false;
}
static void
workspaceview_scroll_to( Workspaceview *wview, int x, int y )
{
GtkAdjustment *hadj = gtk_scrolled_window_get_hadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
GtkAdjustment *vadj = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW( wview->window ) );
int nx, ny;
nx = IM_CLIP( 0, x, wview->width - wview->vp.width );
ny = IM_CLIP( 0, y, wview->height - wview->vp.height );
adjustments_set_value( hadj, vadj, nx, ny );
}
void
photos_utils_scrolled_window_scroll (GtkScrolledWindow *scrolled_window, gdouble delta_x, gdouble delta_y)
{
GtkAdjustment *adjustment;
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
g_return_if_fail (photos_utils_scrolled_window_can_scroll (scrolled_window));
adjustment = gtk_scrolled_window_get_hadjustment (scrolled_window);
photos_utils_adjustment_scroll (adjustment, delta_x);
adjustment = gtk_scrolled_window_get_vadjustment (scrolled_window);
photos_utils_adjustment_scroll (adjustment, delta_y);
}
static GObject *
carrick_list_constructor (GType gtype,
guint n_properties,
GObjectConstructParam *properties)
{
GObject *obj;
GObjectClass *parent_class;
CarrickListPrivate *priv;
GtkWidget *viewport, *box;
parent_class = G_OBJECT_CLASS (carrick_list_parent_class);
obj = parent_class->constructor (gtype, n_properties, properties);
priv = LIST_PRIVATE (obj);
priv->adjustment = gtk_scrolled_window_get_vadjustment
(GTK_SCROLLED_WINDOW (obj));
g_signal_connect (priv->adjustment, "value-changed",
G_CALLBACK (_adjustment_value_changed_cb), obj);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment
(GTK_SCROLLED_WINDOW (obj)),
gtk_scrolled_window_get_vadjustment
(GTK_SCROLLED_WINDOW (obj)));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport),
GTK_SHADOW_NONE);
gtk_widget_show (viewport);
gtk_container_add (GTK_CONTAINER (obj), viewport);
box = gtk_vbox_new (FALSE, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (viewport),
box);
gtk_label_set_line_wrap (GTK_LABEL (priv->fallback),
TRUE);
gtk_widget_set_size_request (priv->fallback,
550,
-1);
gtk_widget_show (priv->fallback);
gtk_misc_set_padding (GTK_MISC (priv->fallback), 0, 12);
gtk_box_pack_start (GTK_BOX (box), priv->fallback,
FALSE, FALSE, 2);
priv->box = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (box),
priv->box);
return obj;
}
static int gtkCanvasSetDXAttrib(Ihandle* ih, const char *value)
{
if (ih->data->sb & IUP_SB_HORIZ)
{
double xmin, xmax, linex;
float dx;
int value_changed;
GtkAdjustment* sb_horiz = gtk_scrolled_window_get_hadjustment(gtkCanvasGetScrolledWindow(ih));
if (!sb_horiz) return 1;
if (!iupStrToFloat(value, &dx))
return 1;
xmin = iupAttribGetFloat(ih, "XMIN");
xmax = iupAttribGetFloat(ih, "XMAX");
if (!iupAttribGet(ih,"LINEX"))
{
linex = dx/10;
if (linex==0)
linex = 1;
}
else
linex = iupAttribGetFloat(ih,"LINEX");
#if GTK_CHECK_VERSION(2, 14, 0)
{
double page_size = dx;
double dvalue = gtk_adjustment_get_value(sb_horiz);
value_changed = gtkCanvasCheckScroll(xmin, xmax, &page_size, &dvalue);
gtk_adjustment_configure(sb_horiz, dvalue, xmin, xmax, linex, page_size, dx);
}
#else
sb_horiz->lower = xmin;
sb_horiz->upper = xmax;
sb_horiz->step_increment = linex;
sb_horiz->page_size = dx;
value_changed = gtkCanvasCheckScroll(xmin, xmax, &sb_horiz->page_size, &sb_horiz->value);
sb_horiz->page_increment = sb_horiz->page_size;
gtk_adjustment_changed(sb_horiz);
#endif
if (value_changed)
gtk_adjustment_value_changed(sb_horiz);
}
return 1;
}
static void
GetScrolledWindow(
GtkWidget *widget,
_ScrolledWindow *data)
{
GtkAdjustment *vad
, *had;
ENTER_FUNC;
vad = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(widget));
had = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(widget));
data->hpos = (int)gtk_adjustment_get_value(had);
data->vpos = (int)gtk_adjustment_get_value(vad);
LEAVE_FUNC;
}
/////////////////////////////////////////////////////////////////////////////////////
// Methods to support a pseudo "listbox" in GTK+ since it is otherwise pretty ugly :)
/////////////////////////////////////////////////////////////////////////////////////
GtkWidget *gui_listbox_new(GCallback sel_change_callback, gpointer user_data)
{
GtkWidget *scroll_window;
GtkWidget *list_view;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column1;
GtkAdjustment *vscroll;
GtkAdjustment *hscroll;
GtkListStore *list_store;
// Create a list store to hold a displayed string and internal index
list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
// create a scrollable container
scroll_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
// create a tree view object
list_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store));
gtk_container_add(GTK_CONTAINER(scroll_window), list_view);
// set the renderer for the two columns we have and append the
// columns to the tree view
renderer = gtk_cell_renderer_text_new ();
column1 = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (list_view), column1);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (list_view), FALSE);
// Set vertical adjustment for the tree view
vscroll = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scroll_window));
gtk_tree_view_set_vadjustment(GTK_TREE_VIEW (list_view), vscroll);
// Set vertical adjustment for the tree view
hscroll = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scroll_window));
gtk_tree_view_set_hadjustment(GTK_TREE_VIEW (list_view), hscroll);
if(sel_change_callback != NULL)
g_signal_connect (list_view, "cursor-changed", G_CALLBACK(sel_change_callback), user_data);
return scroll_window;
}
/* Returns the horizontal scrollbar's adjustment, used to
* connect the horizontal scrollbar to the child widget's
* horizontal scroll functionality. */
int
clip_GTK_SCROLLEDWINDOWGETHADJUSTMENT (ClipMachine *cm)
{
C_widget *csw = _fetch_cw_arg(cm);
ClipVar * cv = RETPTR(cm);
GtkAdjustment* adj;
C_widget *cadj;
CHECKCWID(csw,GTK_IS_SCROLLED_WINDOW);
adj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW(csw->widget));
cadj = _list_get_cwidget(cm, adj);
if (!cadj) cadj = _register_widget(cm, (GtkWidget*)adj, NULL);
if (cadj) _clip_mclone(cm, cv, &cadj->obj);
return 0;
err:
return 1;
}
bool SidebarPreviewBase::scrollToPreview(SidebarPreviewBase* sidebar)
{
XOJ_CHECK_TYPE_OBJ(sidebar, SidebarPreviewBase);
if (!sidebar->enabled)
{
return false;
}
MainWindow* win = sidebar->control->getWindow();
if (win == NULL)
{
return false;
}
GtkWidget* w = win->get("sidebar");
if (!gtk_widget_get_visible(w))
{
return false;
}
if (sidebar->selectedEntry != size_t_npos && sidebar->selectedEntry < sidebar->previews.size())
{
SidebarPreviewBaseEntry* p = sidebar->previews[sidebar->selectedEntry];
// scroll to preview
GtkAdjustment* hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(sidebar->scrollPreview));
GtkAdjustment* vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sidebar->scrollPreview));
GtkWidget* widget = p->getWidget();
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
int x = allocation.x;
int y = allocation.y;
if (x == -1)
{
g_idle_add((GSourceFunc) scrollToPreview, sidebar);
return false;
}
gtk_adjustment_clamp_page(vadj, y, y + allocation.height);
gtk_adjustment_clamp_page(hadj, x, x + allocation.width);
}
return false;
}
GtkWidget *graph_new(track_state_t *track_state) {
graph_priv_t *priv = g_new0(graph_priv_t, 1);
priv->track_state = track_state;
priv->zoom = 1;
/* outmost widget: a vbox */
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
g_object_set_data(G_OBJECT(vbox), "priv", priv);
GtkWidget *win = scrolled_window_new(GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
priv->graph = gtk_drawing_area_new();
int flags = track_contents(track_state);
printf("flags = %x\n", flags);
gtk_signal_connect(GTK_OBJECT(priv->graph), "expose_event",
G_CALLBACK(graph_expose_event), vbox);
gtk_signal_connect(GTK_OBJECT(priv->graph),"configure_event",
G_CALLBACK(graph_configure_event), vbox);
g_signal_connect(G_OBJECT(priv->graph), "destroy",
G_CALLBACK(graph_destroy_event), vbox);
gtk_widget_add_events(win, GDK_STRUCTURE_MASK);
gtk_signal_connect(GTK_OBJECT(win), "expose_event",
G_CALLBACK(swin_expose_event), vbox);
scrolled_window_add_with_viewport(win, priv->graph);
priv->adj =
gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(win));
gtk_signal_connect(GTK_OBJECT(priv->adj), "value_changed",
G_CALLBACK(scroll_changed), priv);
GtkWidget *hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), graph_range_new(priv), FALSE, FALSE, 0);
gtk_box_pack_start_defaults(GTK_BOX(hbox), win);
gtk_box_pack_start_defaults(GTK_BOX(vbox), hbox);
GtkWidget *bottom_box = graph_bottom_box(vbox);
gtk_box_pack_start(GTK_BOX(vbox), bottom_box, FALSE, FALSE, 0);
return vbox;
}
static void
drag_update_cb (GtkGestureDrag *gesture,
double offset_x,
double offset_y,
gpointer user_data)
{
CbMediaImageWidget *self = user_data;
GtkAdjustment *adjustment;
adjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (self));
gtk_adjustment_set_value (adjustment, self->drag_start_hvalue - offset_x);
adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (self));
gtk_adjustment_set_value (adjustment, self->drag_start_vvalue - offset_y);
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
}
static void
palette_editor_scroll_top_left (GimpPaletteEditor *palette_editor)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (palette_editor);
GtkAdjustment *hadj;
GtkAdjustment *vadj;
if (! data_editor->view)
return;
hadj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (data_editor->view));
vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (data_editor->view));
if (hadj)
gtk_adjustment_set_value (hadj, 0.0);
if (vadj)
gtk_adjustment_set_value (vadj, 0.0);
}