static void visibility_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { if (!g_strcmp0 (pspec->name, "visible")) { gint index; gint n_children; gboolean child_added = FALSE; GList *children; AtkObject *child; GtkWidget *widget; GtkScrolledWindow *scrolled_window; GtkWidget *hscrollbar, *vscrollbar; GtkAccessible *accessible = GTK_ACCESSIBLE (user_data); widget = gtk_accessible_get_widget (user_data); if (widget == NULL) return; scrolled_window = GTK_SCROLLED_WINDOW (widget); children = gtk_container_get_children (GTK_CONTAINER (widget)); index = n_children = g_list_length (children); g_list_free (children); hscrollbar = gtk_scrolled_window_get_hscrollbar (scrolled_window); vscrollbar = gtk_scrolled_window_get_vscrollbar (scrolled_window); if ((gpointer) object == (gpointer) (hscrollbar)) { if (gtk_scrolled_window_get_hscrollbar (scrolled_window)) child_added = TRUE; child = gtk_widget_get_accessible (hscrollbar); } else if ((gpointer) object == (gpointer) (vscrollbar)) { if (gtk_scrolled_window_get_vscrollbar (scrolled_window)) child_added = TRUE; child = gtk_widget_get_accessible (vscrollbar); if (gtk_scrolled_window_get_hscrollbar (scrolled_window)) index = n_children + 1; } else { g_assert_not_reached (); return; } if (child_added) g_signal_emit_by_name (accessible, "children-changed::add", index, child, NULL); else g_signal_emit_by_name (accessible, "children-changed::remove", index, child, NULL); } }
static AtkObject * gtk_scrolled_window_accessible_ref_child (AtkObject *obj, gint child) { GtkWidget *widget; GtkScrolledWindow *scrolled_window; GtkWidget *hscrollbar, *vscrollbar; GList *children, *tmp_list; gint n_children; AtkObject *accessible = NULL; g_return_val_if_fail (child >= 0, NULL); widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); if (widget == NULL) return NULL; scrolled_window = GTK_SCROLLED_WINDOW (widget); hscrollbar = gtk_scrolled_window_get_hscrollbar (scrolled_window); vscrollbar = gtk_scrolled_window_get_vscrollbar (scrolled_window); children = gtk_container_get_children (GTK_CONTAINER (widget)); n_children = g_list_length (children); if (child == n_children) { if (gtk_scrolled_window_get_hscrollbar (scrolled_window)) accessible = gtk_widget_get_accessible (hscrollbar); else if (gtk_scrolled_window_get_vscrollbar (scrolled_window)) accessible = gtk_widget_get_accessible (vscrollbar); } else if (child == n_children + 1 && gtk_scrolled_window_get_hscrollbar (scrolled_window) && gtk_scrolled_window_get_vscrollbar (scrolled_window)) accessible = gtk_widget_get_accessible (vscrollbar); else if (child < n_children) { tmp_list = g_list_nth (children, child); if (tmp_list) accessible = gtk_widget_get_accessible (GTK_WIDGET (tmp_list->data)); } g_list_free (children); if (accessible) g_object_ref (accessible); return accessible; }
static gint gtk_scrolled_window_accessible_get_n_children (AtkObject *object) { GtkWidget *widget; GtkScrolledWindow *scrolled_window; GList *children; gint n_children; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (object)); if (widget == NULL) return 0; scrolled_window = GTK_SCROLLED_WINDOW (widget); children = gtk_container_get_children (GTK_CONTAINER (widget)); n_children = g_list_length (children); g_list_free (children); if (gtk_scrolled_window_get_hscrollbar (scrolled_window)) n_children++; if (gtk_scrolled_window_get_vscrollbar (scrolled_window)) n_children++; return n_children; }
static void get_scrolled_window_sizing (GtkSourceCompletionInfo *info, gint *border, gint *hscroll, gint *vscroll) { GtkWidget *scrollbar; *border = 0; *hscroll = 0; *vscroll = 0; if (info->priv->scroll != NULL) { *border = gtk_container_get_border_width (GTK_CONTAINER (info)); scrollbar = gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (info->priv->scroll)); if (GTK_WIDGET_VISIBLE (scrollbar)) { *hscroll = scrollbar->allocation.height; } scrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (info->priv->scroll)); if (GTK_WIDGET_VISIBLE (scrollbar)) { *vscroll = scrollbar->allocation.height; } } }
static void inf_text_gtk_viewport_user_invalidate_user_area(InfTextGtkViewportUser* user) { InfTextGtkViewportPrivate* priv; GtkWidget* scrollbar; priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(user->viewport); if(priv->show_user_markers && user->rectangle.width > 0 && user->rectangle.height > 0) { scrollbar = gtk_scrolled_window_get_vscrollbar(priv->scroll); /* During destruction of the widget it can happen that there is no * vertical scrollbar anymore, so check for it here. */ if(scrollbar != NULL) { gtk_widget_queue_draw_area( scrollbar, user->rectangle.x, user->rectangle.y, user->rectangle.width, user->rectangle.height ); } } }
void qtcScrolledWindowSetup(GtkWidget *widget) { if (widget && GTK_IS_SCROLLED_WINDOW(widget) && !g_object_get_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET")) { GtkScrolledWindow *scrolledWindow=GTK_SCROLLED_WINDOW(widget); GtkWidget *child; if((child=gtk_scrolled_window_get_hscrollbar(scrolledWindow))) qtcScrolledWindowSetupConnections(child, widget); if((child=gtk_scrolled_window_get_vscrollbar(scrolledWindow))) qtcScrolledWindowSetupConnections(child, widget); if((child=gtk_bin_get_child(GTK_BIN(widget)))) { if(GTK_IS_TREE_VIEW(child) || GTK_IS_TEXT_VIEW(child) || GTK_IS_ICON_VIEW(child)) qtcScrolledWindowSetupConnections(child, widget); else { const gchar *type=g_type_name(qtcWidgetType(child)); if(type && (0==strcmp(type, "ExoIconView") || 0==strcmp(type, "FMIconContainer"))) qtcScrolledWindowSetupConnections(child, widget); } } g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET", (gpointer)1); } }
void setup(GtkWidget *widget) { GtkWidgetProps props(widget); if (widget && GTK_IS_SCROLLED_WINDOW(widget) && !props->scrolledWindowHacked) { GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(widget); GtkWidget *child; if ((child = gtk_scrolled_window_get_hscrollbar(scrolledWindow))) { setupConnections(child, widget); } if ((child = gtk_scrolled_window_get_vscrollbar(scrolledWindow))) { setupConnections(child, widget); } if ((child = gtk_bin_get_child(GTK_BIN(widget)))) { if (GTK_IS_TREE_VIEW(child) || GTK_IS_TEXT_VIEW(child) || GTK_IS_ICON_VIEW(child)) { setupConnections(child, widget); } else if (oneOf(gTypeName(child), "ExoIconView", "FMIconContainer")) { setupConnections(child, widget); } } props->scrolledWindowHacked = true; } }
GtkWidget *factory_build_main_window() { GtkCssProvider *provider; GdkScreen *screen; GtkWidget *tabbar; GtkWidget *window; GtkWidget *scroll; GtkWidget *vbox; GtkWidget *ebox; /* load css and apply style */ provider = gtk_css_provider_new(); screen = gdk_screen_get_default(); gtk_css_provider_load_from_file(provider, g_file_new_for_path("style.css"), NULL); gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER); /* setup elements */ tabbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(tabbar), true); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "awb"); gtk_window_set_resizable(GTK_WINDOW(window), false); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_NEVER); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); ebox = gtk_event_box_new(); /* link to gui struct */ awb.gui.tabbar = tabbar; awb.gui.window = window; awb.gui.scrollarea = scroll; awb.gui.inbox = ebox; GtkWidget *scrollarea = factory_build_history(); /* packing */ gtk_box_pack_start(GTK_BOX(vbox), tabbar, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), scroll, 1, 1, 0); gtk_box_pack_end(GTK_BOX(vbox), ebox, 0, 0, 0); gtk_box_pack_end(GTK_BOX(vbox), factory_build_inputbar(), 0, 0, 0); gtk_box_pack_end(GTK_BOX(vbox), scrollarea /*factory_build_history()*/, 0, 0, 0); gtk_box_pack_end(GTK_BOX(vbox), factory_build_statusbar(), 0, 0, 0); gtk_container_add(GTK_CONTAINER(window), vbox); awb_new_tab("about:blank"); gtk_widget_show_all(awb.gui.window); gtk_widget_set_visible(awb.gui.statusbar.ssl, false); gtk_widget_set_visible(awb.gui.inputbar.widget, false); gtk_widget_set_visible(awb.gui.tabbar, false); gtk_widget_set_visible(awb.gui.history, false); gtk_widget_set_visible(GTK_WIDGET(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(scrollarea))), false); return window; }
static int gtkListSetBgColorAttrib(Ihandle* ih, const char* value) { unsigned char r, g, b; GtkScrolledWindow* scrolled_window = (GtkScrolledWindow*)iupAttribGet(ih, "_IUP_EXTRAPARENT"); if (scrolled_window && !ih->data->is_dropdown) { /* ignore given value, must use only from parent for the scrollbars */ char* parent_value = iupBaseNativeParentGetBgColor(ih); if (iupStrToRGB(parent_value, &r, &g, &b)) { GtkWidget* sb; if (!GTK_IS_SCROLLED_WINDOW(scrolled_window)) scrolled_window = (GtkScrolledWindow*)iupAttribGet(ih, "_IUPGTK_SCROLLED_WINDOW"); iupgtkBaseSetBgColor((GtkWidget*)scrolled_window, r, g, b); #if GTK_CHECK_VERSION(2, 8, 0) sb = gtk_scrolled_window_get_hscrollbar(scrolled_window); if (sb) iupgtkBaseSetBgColor(sb, r, g, b); sb = gtk_scrolled_window_get_vscrollbar(scrolled_window); if (sb) iupgtkBaseSetBgColor(sb, r, g, b); #endif } } if (!iupStrToRGB(value, &r, &g, &b)) return 0; if (ih->data->has_editbox) { GtkWidget* entry = (GtkWidget*)iupAttribGet(ih, "_IUPGTK_ENTRY"); iupgtkBaseSetBgColor(entry, r, g, b); } { GtkCellRenderer* renderer = (GtkCellRenderer*)iupAttribGet(ih, "_IUPGTK_RENDERER"); GdkColor color = {0L,0,0,0}; color.red = iupCOLOR8TO16(r); color.green = iupCOLOR8TO16(g); color.blue = iupCOLOR8TO16(b); if (renderer) g_object_set(G_OBJECT(renderer), "cell-background-gdk", &color, NULL); } return iupdrvBaseSetBgColorAttrib(ih, value); }
void lcrt_edit_on_clear_scrollback_activate(GtkMenuItem *menuitem, gpointer user_data) { struct lcrt_window *lwindow = (struct lcrt_window *)user_data; struct lcrt_terminal *lterminal = lwindow->w_notebook->current_terminal; GtkWidget *vscrollbar; vscrollbar = gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(lterminal->scrolledwindow)); #if 1 gtk_adjustment_set_value( gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(lterminal->scrolledwindow)), 0); #endif }
void bjb_main_view_disconnect_scrolled_window (BjbMainView *self) { GtkAdjustment *vadjustment; GtkWidget *vscrollbar; BjbMainViewPriv *priv = self->priv; if (priv->view == NULL || !GTK_IS_SCROLLED_WINDOW (priv->view)) return; vadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->view)); vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (priv->view)); g_signal_handlers_disconnect_by_func (vadjustment, bjb_main_view_view_changed, self); g_signal_handlers_disconnect_by_func (vscrollbar, bjb_main_view_view_changed, self); }
/** * inf_text_gtk_viewport_set_show_user_markers: * @viewport: A #InfTextGtkViewport. * @show: Whether to show the position of non-local users. * * If @show is %TRUE then draw a marker indicating the cursor position of all * non-local users with status %INF_USER_ACTIVE in the scrollbar of the * scrolled window. If @show is %FALSE then do not draw user markers into the * scrollbar. */ void inf_text_gtk_viewport_set_show_user_markers(InfTextGtkViewport* viewport, gboolean show) { InfTextGtkViewportPrivate* priv; g_return_if_fail(INF_TEXT_GTK_IS_VIEWPORT(viewport)); priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(viewport); if(priv->show_user_markers != show) { gtk_widget_queue_draw(gtk_scrolled_window_get_vscrollbar(priv->scroll)); priv->show_user_markers = show; g_object_notify(G_OBJECT(viewport), "show-user-markers"); } }
static void gtk_scrolled_window_accessible_initialize (AtkObject *obj, gpointer data) { GtkScrolledWindow *window; ATK_OBJECT_CLASS (_gtk_scrolled_window_accessible_parent_class)->initialize (obj, data); window = GTK_SCROLLED_WINDOW (data); g_signal_connect_data (gtk_scrolled_window_get_hscrollbar (window), "notify::visible", G_CALLBACK (visibility_changed), obj, NULL, FALSE); g_signal_connect_data (gtk_scrolled_window_get_vscrollbar (window), "notify::visible", G_CALLBACK (visibility_changed), obj, NULL, FALSE); obj->role = ATK_ROLE_SCROLL_PANE; }
gint utl_gui_get_sw_vscrollbar_width (GtkWidget *scrolled_window) { GtkWidget *vscrollbar; GValue *value; gint width; value = g_new0 (GValue, 1); value = g_value_init (value, G_TYPE_INT); vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (scrolled_window)); gtk_widget_style_get_property (vscrollbar, "slider-width", value); width = g_value_get_int (value); g_value_unset (value); g_free (value); return width; }
static int gtkCanvasSetBgColorAttrib(Ihandle* ih, const char* value) { GtkScrolledWindow* scrolled_window = gtkCanvasGetScrolledWindow(ih); unsigned char r, g, b; /* ignore given value, must use only from parent for the scrollbars */ char* parent_value = iupBaseNativeParentGetBgColor(ih); if (iupStrToRGB(parent_value, &r, &g, &b)) { GtkWidget* sb; iupgtkBaseSetBgColor((GtkWidget*)scrolled_window, r, g, b); #if GTK_CHECK_VERSION(2, 8, 0) sb = gtk_scrolled_window_get_hscrollbar(scrolled_window); if (sb) iupgtkBaseSetBgColor(sb, r, g, b); sb = gtk_scrolled_window_get_vscrollbar(scrolled_window); if (sb) iupgtkBaseSetBgColor(sb, r, g, b); #endif } if (!IupGetCallback(ih, "ACTION")) { /* enable automatic double buffering */ gtk_widget_set_double_buffered(ih->handle, TRUE); gtk_widget_set_double_buffered((GtkWidget*)scrolled_window, TRUE); return iupdrvBaseSetBgColorAttrib(ih, value); } else { /* disable automatic double buffering */ gtk_widget_set_double_buffered(ih->handle, FALSE); gtk_widget_set_double_buffered((GtkWidget*)scrolled_window, FALSE); gdk_window_set_back_pixmap(iupgtkGetWindow(ih->handle), NULL, FALSE); iupAttribSetStr(ih, "_IUPGTK_NO_BGCOLOR", "1"); return 1; } }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ void x_window_create_main(GschemToplevel *w_current) { TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current); GtkPolicyType policy; GtkWidget *main_box=NULL; GtkWidget *menubar=NULL; GtkWidget *toolbar=NULL; GtkWidget *handlebox=NULL; GtkWidget *hscrollbar; GtkWidget *vscrollbar; GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; char *right_button_text; /* used to signify that the window isn't mapped yet */ w_current->window = NULL; w_current->main_window = GTK_WIDGET (gschem_main_window_new ()); gtk_widget_set_name (w_current->main_window, "gschem"); gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE); /* We want the widgets to flow around the drawing area, so we don't * set a size of the main window. The drawing area's size is fixed, * see below */ /* * normally we let the window manager handle locating and sizing * the window. However, for some batch processing of schematics * (generating a pdf of all schematics for example) we want to * override this. Hence "auto_place_mode". */ if( auto_place_mode ) gtk_widget_set_uposition (w_current->main_window, 10, 10); /* this should work fine */ g_signal_connect (G_OBJECT (w_current->main_window), "delete_event", G_CALLBACK (i_callback_close_wm), w_current); /* Containers first */ main_box = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_box), 0); gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box); menubar = get_main_menu (w_current); if (w_current->handleboxes) { handlebox = gtk_handle_box_new (); gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (handlebox), menubar); } else { gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0); } w_current->menubar = menubar; gtk_widget_realize (w_current->main_window); if (w_current->handleboxes && w_current->toolbars) { handlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0); } if (w_current->toolbars) { toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); if (w_current->handleboxes) { gtk_container_add (GTK_CONTAINER (handlebox), toolbar); } else { gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("New"), _("New file"), "toolbar/new", x_window_stock_pixmap("new", w_current), (GtkSignalFunc) i_callback_toolbar_file_new, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open file..."), "toolbar/open", x_window_stock_pixmap("open", w_current), (GtkSignalFunc) i_callback_toolbar_file_open, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save file"), "toolbar/save", x_window_stock_pixmap("save", w_current), (GtkSignalFunc) i_callback_toolbar_file_save, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Undo"), _("Undo last operation"), "toolbar/undo", x_window_stock_pixmap("undo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_undo, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Redo"), _("Redo last undo"), "toolbar/redo", x_window_stock_pixmap("redo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_redo, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Component"), _("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"), "toolbar/component", x_window_stock_pixmap("insert-symbol", w_current), (GtkSignalFunc) i_callback_toolbar_add_component, w_current); w_current->toolbar_net = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Nets"), _("Add nets mode\nRight mouse button to cancel"), "toolbar/nets", x_window_stock_pixmap("insert-net", w_current), (GtkSignalFunc) i_callback_toolbar_add_net, w_current); w_current->toolbar_bus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_net, _("Bus"), _("Add buses mode\nRight mouse button to cancel"), "toolbar/bus", x_window_stock_pixmap("insert-bus", w_current), (GtkSignalFunc) i_callback_toolbar_add_bus, w_current); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Text"), _("Add Text..."), "toolbar/text", x_window_stock_pixmap("insert-text", w_current), (GtkSignalFunc) i_callback_toolbar_add_text, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); w_current->toolbar_select = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_bus, _("Select"), _("Select mode"), "toolbar/select", x_window_stock_pixmap("select", w_current), (GtkSignalFunc) i_callback_toolbar_edit_select, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select), TRUE); } /* Try to create popup menu (appears in right mouse button */ w_current->popup_menu = (GtkWidget *) get_main_popup(w_current); /* Setup a GtkScrolledWindow for the drawing area */ hadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0)); vadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom, 100.0, 100.0, 10.0)); w_current->scrolled = gtk_scrolled_window_new (hadjustment, vadjustment); gtk_container_add(GTK_CONTAINER(main_box), w_current->scrolled); x_window_create_drawing(w_current->scrolled, w_current); x_window_setup_draw_events(w_current); policy = (w_current->scrollbars_flag) ? GTK_POLICY_ALWAYS : GTK_POLICY_NEVER; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w_current->scrolled), policy, policy); hscrollbar = gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (hscrollbar), GTK_UPDATE_CONTINUOUS); vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (vscrollbar), GTK_UPDATE_CONTINUOUS); /* macro box */ w_current->macro_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_MACRO_WIDGET, NULL)); gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_widget, FALSE, FALSE, 0); g_signal_connect (w_current->macro_widget, "response", G_CALLBACK (&x_window_invoke_macro), w_current); /* bottom box */ if (default_third_button == POPUP_ENABLED) { right_button_text = _("Menu/Cancel"); } else { right_button_text = _("Pan/Cancel"); } w_current->bottom_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_BOTTOM_WIDGET, "grid-mode", gschem_options_get_grid_mode (w_current->options), "grid-size", gschem_options_get_snap_size (w_current->options), /* x_grid_query_drawn_spacing (w_current), -- occurs before the page is set */ "left-button-text", _("Pick"), "middle-button-text", _("none"), "right-button-text", right_button_text, "snap-mode", gschem_options_get_snap_mode (w_current->options), "snap-size", gschem_options_get_snap_size (w_current->options), "status-text", _("Select Mode"), NULL)); i_update_middle_button (w_current, NULL, NULL); gtk_box_pack_start (GTK_BOX (main_box), w_current->bottom_widget, FALSE, FALSE, 0); gtk_widget_show_all (w_current->main_window); w_current->window = w_current->drawing_area->window; w_current->drawable = w_current->window; x_window_setup_gc(w_current); }
static void inf_text_gtk_viewport_set_scrolled_window(InfTextGtkViewport* viewport, GtkScrolledWindow* scroll) { InfTextGtkViewportPrivate* priv; GtkWidget* scrollbar; GtkAdjustment* adjustment; priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(viewport); if(priv->scroll != NULL) { scrollbar = gtk_scrolled_window_get_vscrollbar(priv->scroll); /* Can already be unset at this point */ /* TODO: Should we catch that and unregister our signals before? OTOH it * is most likely going to be freed anyway... */ if(scrollbar != NULL) { adjustment = gtk_range_get_adjustment(GTK_RANGE(scrollbar)); g_assert(adjustment != NULL); inf_signal_handlers_disconnect_by_func( G_OBJECT(adjustment), G_CALLBACK(inf_text_gtk_viewport_adjustment_changed_cb), viewport ); inf_signal_handlers_disconnect_by_func( G_OBJECT(scrollbar), G_CALLBACK(inf_text_gtk_viewport_scrollbar_size_allocate_cb), viewport ); inf_signal_handlers_disconnect_by_func( G_OBJECT(scrollbar), G_CALLBACK(inf_text_gtk_viewport_scrollbar_style_set_cb), viewport ); inf_signal_handlers_disconnect_by_func( G_OBJECT(scrollbar), #if GTK_CHECK_VERSION(2, 91, 0) G_CALLBACK(inf_text_gtk_viewport_scrollbar_draw_cb), #else G_CALLBACK(inf_text_gtk_viewport_scrollbar_expose_event_cb), #endif viewport ); } g_object_unref(priv->scroll); } priv->scroll = scroll; if(scroll != NULL) { scrollbar = gtk_scrolled_window_get_vscrollbar(priv->scroll); /* TODO: can this happen? maybe for GTK_POLICY_NEVER? */ g_assert(scrollbar != NULL); adjustment = gtk_range_get_adjustment(GTK_RANGE(scrollbar)); g_assert(adjustment != NULL); g_object_ref(scroll); g_signal_connect_after( G_OBJECT(adjustment), "changed", G_CALLBACK(inf_text_gtk_viewport_adjustment_changed_cb), viewport ); g_signal_connect_after( G_OBJECT(scrollbar), "size-allocate", G_CALLBACK(inf_text_gtk_viewport_scrollbar_size_allocate_cb), viewport ); g_signal_connect_after( G_OBJECT(scrollbar), "style-set", G_CALLBACK(inf_text_gtk_viewport_scrollbar_style_set_cb), viewport ); #if GTK_CHECK_VERSION(2, 91, 0) g_signal_connect_after( G_OBJECT(scrollbar), "draw", G_CALLBACK(inf_text_gtk_viewport_scrollbar_draw_cb), viewport ); #else g_signal_connect_after( G_OBJECT(scrollbar), "expose-event", G_CALLBACK(inf_text_gtk_viewport_scrollbar_expose_event_cb), viewport ); #endif } g_object_notify(G_OBJECT(viewport), "scrolled-window"); }
static VALUE rg_vscrollbar(VALUE self) { return GOBJ2RVAL(gtk_scrolled_window_get_vscrollbar(_SELF(self))); }
static void activate (GApplication *app) { GtkBuilder *builder; GtkWindow *window; GtkWidget *widget; GtkTreeModel *model; GtkTreeIter iter; GError *error = NULL; GtkWidget *sw; GtkWidget *scrollbar; GtkWidget *menu; GtkWidget *item; static GActionEntry win_entries[] = { { "run", activate_run, NULL, NULL, NULL } }; builder = gtk_builder_new (); gtk_builder_add_from_resource (builder, "/ui/main.ui", &error); if (error != NULL) { g_critical ("%s", error->message); exit (1); } window = (GtkWindow *)gtk_builder_get_object (builder, "window"); gtk_application_add_window (GTK_APPLICATION (app), window); g_action_map_add_action_entries (G_ACTION_MAP (window), win_entries, G_N_ELEMENTS (win_entries), window); notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook"); info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview"); source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview"); headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar"); treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview"); model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)); sw = (GtkWidget *)gtk_builder_get_object (builder, "source-scrolledwindow"); scrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (sw)); menu = gtk_menu_new (); item = gtk_menu_item_new_with_label ("Start"); g_signal_connect (item, "activate", G_CALLBACK (start_cb), scrollbar); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label ("End"); g_signal_connect (item, "activate", G_CALLBACK (end_cb), scrollbar); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show_all (menu); g_signal_connect (scrollbar, "popup-menu", G_CALLBACK (scrollbar_popup), menu); load_file (gtk_demos[0].name, gtk_demos[0].filename); populate_model (model); g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model); widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection"); g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model); gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter); gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter); gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview)); gtk_widget_show_all (GTK_WIDGET (window)); g_object_unref (builder); }
static int gtkCanvasMapMethod(Ihandle* ih) { GtkScrolledWindow* scrolled_window; void* visual; if (!ih->parent) return IUP_ERROR; ih->data->sb = iupBaseGetScrollbar(ih); visual = (void*)IupGetAttribute(ih, "VISUAL"); /* defined by the OpenGL Canvas in X11 or NULL */ if (visual) iupgtkPushVisualAndColormap(visual, (void*)iupAttribGet(ih, "COLORMAP")); ih->handle = gtk_drawing_area_new(); if (visual) gtk_widget_pop_colormap(); if (!ih->handle) return IUP_ERROR; #if GTK_CHECK_VERSION(2, 18, 0) /* CD will NOT work properly without this, must use always the CD-GDK driver */ gtk_widget_set_has_window(ih->handle, TRUE); #endif scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL); if (!scrolled_window) return IUP_ERROR; { /* to avoid the "cannot add non scrollable widget" warning */ #if GTK_CHECK_VERSION(2, 6, 0) GLogFunc def_func = g_log_set_default_handler(gtkCanvasDummyLogFunc, NULL); #endif gtk_container_add((GtkContainer*)scrolled_window, ih->handle); #if GTK_CHECK_VERSION(2, 6, 0) g_log_set_default_handler(def_func, NULL); #endif } gtk_widget_show((GtkWidget*)scrolled_window); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window); /* add to the parent, all GTK controls must call this. */ iupgtkBaseAddToParent(ih); g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(iupgtkKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(ih->handle), "expose-event", G_CALLBACK(gtkCanvasExposeEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkCanvasButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkCanvasButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "scroll-event",G_CALLBACK(gtkCanvasScrollEvent), ih); #if GTK_CHECK_VERSION(2, 8, 0) g_signal_connect(G_OBJECT(gtk_scrolled_window_get_hscrollbar(scrolled_window)), "change-value",G_CALLBACK(gtkCanvasHChangeValue), ih); g_signal_connect(G_OBJECT(gtk_scrolled_window_get_vscrollbar(scrolled_window)), "change-value",G_CALLBACK(gtkCanvasVChangeValue), ih); #endif /* To receive mouse events on a drawing area, you will need to enable them. */ gtk_widget_add_events(ih->handle, GDK_EXPOSURE_MASK| GDK_POINTER_MOTION_MASK|GDK_POINTER_MOTION_HINT_MASK| GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_MOTION_MASK| GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK| GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK| GDK_FOCUS_CHANGE_MASK|GDK_STRUCTURE_MASK); /* To receive keyboard events, you will need to set the GTK_CAN_FOCUS flag on the drawing area. */ if (ih->iclass->is_interactive) { if (iupAttribGetBoolean(ih, "CANFOCUS")) iupgtkSetCanFocus(ih->handle, 1); } if (iupAttribGetBoolean(ih, "BORDER")) gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN); else gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_NONE); gtk_widget_realize((GtkWidget*)scrolled_window); gtk_widget_realize(ih->handle); /* must be connected after realize or a RESIZE_CB will happen before MAP_CB works only for the GtkDrawingArea. */ g_signal_connect(G_OBJECT(ih->handle), "configure-event", G_CALLBACK(gtkCanvasConfigureEvent), ih); iupAttribSetStr(ih, "_IUP_GTK_FIRST_RESIZE", "1"); /* configure for DRAG&DROP */ if (IupGetCallback(ih, "DROPFILES_CB")) iupAttribSetStr(ih, "DRAGDROP", "YES"); /* update a mnemonic in a label if necessary */ iupgtkUpdateMnemonic(ih); /* configure scrollbar */ if (ih->data->sb) { GtkPolicyType hscrollbar_policy = GTK_POLICY_NEVER, vscrollbar_policy = GTK_POLICY_NEVER; if (ih->data->sb & IUP_SB_HORIZ) hscrollbar_policy = GTK_POLICY_AUTOMATIC; if (ih->data->sb & IUP_SB_VERT) vscrollbar_policy = GTK_POLICY_AUTOMATIC; gtk_scrolled_window_set_policy(scrolled_window, hscrollbar_policy, vscrollbar_policy); } else gtk_scrolled_window_set_policy(scrolled_window, GTK_POLICY_NEVER, GTK_POLICY_NEVER); /* force the update of BGCOLOR here, to let derived classes ignore it if ACTION is defined */ gtkCanvasSetBgColorAttrib(ih, iupAttribGetStr(ih, "BGCOLOR")); return IUP_NOERROR; }
static void set_up_tree_view (TotemYouTubePlugin *self, GtkBuilder *builder, guint key) { GtkUIManager *ui_manager; GtkActionGroup *action_group; GtkAction *action, *menu_item; GtkWidget *vscroll, *tree_view; GtkTreeViewColumn *column; GtkCellRenderer *renderer; /* Add the cell renderer. This can't be done with GtkBuilder, because it unavoidably sets the expand parameter to FALSE */ /* TODO: Depends on bug #453692 */ renderer = GTK_CELL_RENDERER (totem_cell_renderer_video_new (TRUE)); column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, (key == SEARCH_TREE_VIEW) ? "yt_treeview_search_column" : "yt_treeview_related_column")); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "thumbnail", 0, "title", 1, NULL); /* Give the video lists a handle to Totem and connect their scrollbar signals */ if (key == SEARCH_TREE_VIEW) { tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_search")); vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_search"))); self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_search")); self->tree_view[key] = GTK_TREE_VIEW (tree_view); self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_search")); } else { tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_related")); vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_related"))); self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_related")); self->tree_view[key] = GTK_TREE_VIEW (tree_view); self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_related")); } g_object_set (tree_view, "totem", self->totem, NULL); g_signal_connect (vscroll, "button-press-event", G_CALLBACK (button_press_event_cb), self); g_signal_connect (vscroll, "button-release-event", G_CALLBACK (button_release_event_cb), self); /* Add the extra popup menu options. This is done here rather than in the UI file, because it's done for multiple treeviews; * if it were done in the UI file, the same action group would be used multiple times, which GTK+ doesn't like. */ ui_manager = totem_video_list_get_ui_manager (TOTEM_VIDEO_LIST (tree_view)); action_group = gtk_action_group_new ("youtube-action-group"); action = gtk_action_new ("open-in-web-browser", _("_Open in Web Browser"), _("Open the video in your web browser"), "gtk-jump-to"); gtk_action_group_add_action_with_accel (action_group, action, NULL); gtk_ui_manager_insert_action_group (ui_manager, action_group, 1); gtk_ui_manager_add_ui (ui_manager, gtk_ui_manager_new_merge_id (ui_manager), "/ui/totem-video-list-popup/", "open-in-web-browser", "open-in-web-browser", GTK_UI_MANAGER_MENUITEM, FALSE); menu_item = gtk_ui_manager_get_action (ui_manager, "/ui/totem-video-list-popup/open-in-web-browser"); g_signal_connect (menu_item, "activate", G_CALLBACK (open_in_web_browser_activate_cb), self); /* Connect to more scroll events */ #if GTK_CHECK_VERSION(3, 0, 0) self->vadjust[key] = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view)); #else self->vadjust[key] = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(tree_view)); #endif g_signal_connect (self->vadjust[key], "value-changed", G_CALLBACK (value_changed_cb), self); self->cancel_button = GTK_WIDGET (gtk_builder_get_object (builder, "yt_cancel_button")); }
bool sc_adjust_window(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(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); unsigned int pages_per_row = 1; girara_setting_get(session, "pages-per-row", &pages_per_row); unsigned int first_page_column = 1; girara_setting_get(session, "first-page-column", &first_page_column); int padding = 1; girara_setting_get(zathura->ui.session, "page-padding", &padding); if (zathura->ui.page_widget == NULL || zathura->document == NULL) { goto error_ret; } float old_zoom = zathura_document_get_scale(zathura->document); zathura_document_set_adjust_mode(zathura->document, argument->n); if (argument->n == ZATHURA_ADJUST_NONE) { /* there is nothing todo */ goto error_ret; } /* get window size */ GtkAllocation allocation; gtk_widget_get_allocation(session->gtk.view, &allocation); unsigned int width = allocation.width; unsigned int height = allocation.height; /* scrollbar spacing */ gint spacing; gtk_widget_style_get(session->gtk.view, "scrollbar_spacing", &spacing, NULL); width -= spacing; /* correct view size */ if (gtk_widget_get_visible(GTK_WIDGET(session->gtk.inputbar)) == true) { gtk_widget_get_allocation(session->gtk.inputbar, &allocation); height += allocation.height; } double scale = 1.0; unsigned int cell_height = 0, cell_width = 0; unsigned int document_height = 0, document_width = 0; zathura_document_set_scale(zathura->document, scale); zathura_document_get_cell_size(zathura->document, &cell_height, &cell_width); zathura_get_document_size(zathura, cell_height, cell_width, &document_height, &document_width); double page_ratio = (double)cell_height / (double)document_width; double window_ratio = (double)height / (double)width; if (argument->n == ZATHURA_ADJUST_WIDTH || (argument->n == ZATHURA_ADJUST_BESTFIT && page_ratio < window_ratio)) { scale = (double)(width - (pages_per_row - 1) * padding) / (double)(pages_per_row * cell_width); zathura_document_set_scale(zathura->document, scale); bool show_scrollbars = false; girara_setting_get(session, "show-scrollbars", &show_scrollbars); if (show_scrollbars) { /* If the document is taller than the view, there's a vertical * scrollbar; we need to substract its width from the view's width. */ zathura_get_document_size(zathura, cell_height, cell_width, &document_height, &document_width); if (height < document_height) { GtkWidget* vscrollbar = gtk_scrolled_window_get_vscrollbar( GTK_SCROLLED_WINDOW(session->gtk.view)); if (vscrollbar != NULL) { GtkRequisition requisition; gtk_widget_get_requisition(vscrollbar, &requisition); if (0 < requisition.width && (unsigned)requisition.width < width) { width -= requisition.width; scale = (double)(width - (pages_per_row - 1) * padding) / (double)(pages_per_row * cell_width); zathura_document_set_scale(zathura->document, scale); } } } } } else if (argument->n == ZATHURA_ADJUST_BESTFIT) { scale = (double)height / (double)cell_height; zathura_document_set_scale(zathura->document, scale); } else { goto error_ret; } /* keep position */ readjust_view_after_zooming(zathura, old_zoom, false); /* re-render all pages */ render_all(zathura); error_ret: return false; }
void init_stuff (int argc, char *argv[]) { GtkWidget *w; GList *dev_list; GdkDevice *device; GdkScreen *screen; int i, j; struct Brush *b; gboolean can_xinput, success; gchar *tmppath, *tmpfn; // create some data structures needed to populate the preferences ui.default_page.bg = g_new(struct Background, 1); // initialize config file names tmppath = g_build_filename(g_get_home_dir(), CONFIG_DIR, NULL); mkdir(tmppath, 0700); // safer (MRU data may be confidential) ui.mrufile = g_build_filename(tmppath, MRU_FILE, NULL); ui.configfile = g_build_filename(tmppath, CONFIG_FILE, NULL); g_free(tmppath); // initialize preferences init_config_default(); load_config_from_file(); ui.font_name = g_strdup(ui.default_font_name); ui.font_size = ui.default_font_size; ui.hiliter_alpha_mask = 0xffffff00 + (guint)(255*ui.hiliter_opacity); // we need an empty canvas prior to creating the journal structures canvas = GNOME_CANVAS (gnome_canvas_new_aa ()); // initialize data ui.default_page.bg->canvas_item = NULL; ui.layerbox_length = 0; if (argc > 2 || (argc == 2 && argv[1][0] == '-')) { printf(_("Invalid command line parameters.\n" "Usage: %s [filename.xoj]\n"), argv[0]); gtk_exit(0); } undo = NULL; redo = NULL; journal.pages = NULL; bgpdf.status = STATUS_NOT_INIT; new_journal(); ui.cur_item_type = ITEM_NONE; ui.cur_item = NULL; ui.cur_path.coords = NULL; ui.cur_path_storage_alloc = 0; ui.cur_path.ref_count = 1; ui.cur_widths = NULL; ui.cur_widths_storage_alloc = 0; ui.selection = NULL; ui.cursor = NULL; ui.pen_cursor_pix = ui.hiliter_cursor_pix = NULL; ui.cur_brush = &(ui.brushes[0][ui.toolno[0]]); for (j=0; j<=NUM_BUTTONS; j++) for (i=0; i < NUM_STROKE_TOOLS; i++) { b = &(ui.brushes[j][i]); b->tool_type = i; if (b->color_no>=0) { b->color_rgba = predef_colors_rgba[b->color_no]; if (i == TOOL_HIGHLIGHTER) { b->color_rgba &= ui.hiliter_alpha_mask; } } b->thickness = predef_thickness[i][b->thickness_no]; } for (i=0; i<NUM_STROKE_TOOLS; i++) g_memmove(ui.default_brushes+i, &(ui.brushes[0][i]), sizeof(struct Brush)); ui.cur_mapping = 0; ui.which_unswitch_button = 0; ui.in_proximity = FALSE; ui.warned_generate_fontconfig = FALSE; reset_recognizer(); // initialize various interface elements gtk_window_set_default_size(GTK_WINDOW (winMain), ui.window_default_width, ui.window_default_height); if (ui.maximize_at_start) gtk_window_maximize(GTK_WINDOW (winMain)); update_toolbar_and_menu(); update_font_button(); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalApplyAllPages")), ui.bg_apply_all_pages); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalNewPageKeepsBG")), ui.new_page_bg_from_pdf); if (ui.fullscreen) { gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), TRUE); gtk_toggle_tool_button_set_active( GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), TRUE); gtk_window_fullscreen(GTK_WINDOW(winMain)); } gtk_button_set_relief(GTK_BUTTON(GET_COMPONENT("buttonColorChooser")), GTK_RELIEF_NONE); allow_all_accels(); add_scroll_bindings(); // prevent interface items from stealing focus // glade doesn't properly handle can_focus, so manually set it gtk_combo_box_set_focus_on_click(GTK_COMBO_BOX(GET_COMPONENT("comboLayer")), FALSE); g_signal_connect(GET_COMPONENT("spinPageNo"), "activate", G_CALLBACK(handle_activate_signal), NULL); gtk_container_forall(GTK_CONTAINER(winMain), unset_flags, (gpointer)GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(canvas), GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(GET_COMPONENT("spinPageNo")), GTK_CAN_FOCUS); // install hooks on button/key/activation events to make the spinPageNo lose focus gtk_container_forall(GTK_CONTAINER(winMain), install_focus_hooks, NULL); // set up and initialize the canvas gtk_widget_show (GTK_WIDGET (canvas)); w = GET_COMPONENT("scrolledwindowMain"); gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (canvas)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_events (GTK_WIDGET (canvas), GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_PROXIMITY_IN_MASK | GDK_PROXIMITY_OUT_MASK); gnome_canvas_set_pixels_per_unit (canvas, ui.zoom); gnome_canvas_set_center_scroll_region (canvas, TRUE); gtk_layout_get_hadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; gtk_layout_get_vadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; // set up the page size and canvas size update_page_stuff(); g_signal_connect ((gpointer) canvas, "button_press_event", G_CALLBACK (on_canvas_button_press_event), NULL); g_signal_connect ((gpointer) canvas, "button_release_event", G_CALLBACK (on_canvas_button_release_event), NULL); g_signal_connect ((gpointer) canvas, "enter_notify_event", G_CALLBACK (on_canvas_enter_notify_event), NULL); g_signal_connect ((gpointer) canvas, "leave_notify_event", G_CALLBACK (on_canvas_leave_notify_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_in_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_out_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "expose_event", G_CALLBACK (on_canvas_expose_event), NULL); g_signal_connect ((gpointer) canvas, "key_press_event", G_CALLBACK (on_canvas_key_press_event), NULL); g_signal_connect ((gpointer) canvas, "motion_notify_event", G_CALLBACK (on_canvas_motion_notify_event), NULL); g_signal_connect ((gpointer) gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_vscroll_changed), NULL); g_signal_connect ((gpointer) gtk_layout_get_hadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_hscroll_changed), NULL); g_object_set_data (G_OBJECT (winMain), "canvas", canvas); screen = gtk_widget_get_screen(winMain); ui.screen_width = gdk_screen_get_width(screen); ui.screen_height = gdk_screen_get_height(screen); can_xinput = FALSE; dev_list = gdk_devices_list(); while (dev_list != NULL) { device = (GdkDevice *)dev_list->data; if (device != gdk_device_get_core_pointer() && device->num_axes >= 2) { /* get around a GDK bug: map the valuator range CORRECTLY to [0,1] */ #ifdef ENABLE_XINPUT_BUGFIX gdk_device_set_axis_use(device, 0, GDK_AXIS_IGNORE); gdk_device_set_axis_use(device, 1, GDK_AXIS_IGNORE); #endif gdk_device_set_mode(device, GDK_MODE_SCREEN); if (g_strrstr(device->name, "raser")) gdk_device_set_source(device, GDK_SOURCE_ERASER); can_xinput = TRUE; } dev_list = dev_list->next; } if (!can_xinput) gtk_widget_set_sensitive(GET_COMPONENT("optionsUseXInput"), FALSE); ui.use_xinput = ui.allow_xinput && can_xinput; gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsProgressiveBG")), ui.progressive_bg); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPrintRuling")), ui.print_ruling); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoloadPdfXoj")), ui.autoload_pdf_xoj); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutosaveXoj")), ui.autosave_enabled); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLeftHanded")), ui.left_handed); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsShortenMenus")), ui.shorten_menus); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoSavePrefs")), ui.auto_save_prefs); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonSwitchMapping")), ui.button_switch_mapping); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLargePenCursor")), ui.large_pencursor); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPenCursor")), ui.pen_cursor); hide_unimplemented(); update_undo_redo_enabled(); update_copy_paste_enabled(); update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]); gtk_widget_grab_focus(GTK_WIDGET(canvas)); // show everything... gtk_widget_show (winMain); update_cursor(); /* this will cause extension events to get enabled/disabled, but we need the windows to be mapped first */ gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsUseXInput")), ui.use_xinput); /* fix a bug in GTK+ 2.16 and 2.17: scrollbars shouldn't get extended input events from pointer motion when cursor moves into main window */ if (!gtk_check_version(2, 16, 0)) { g_signal_connect ( GET_COMPONENT("menubar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarMain"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarPen"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("statusbar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); } // load the MRU init_mru(); // and finally, open a file specified on the command line // (moved here because display parameters weren't initialized yet...) if (argc == 1) return; set_cursor_busy(TRUE); if (g_path_is_absolute(argv[1])) tmpfn = g_strdup(argv[1]); else { tmppath = g_get_current_dir(); tmpfn = g_build_filename(tmppath, argv[1], NULL); g_free(tmppath); } success = open_journal(tmpfn); g_free(tmpfn); set_cursor_busy(FALSE); if (!success) { w = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), argv[1]); gtk_dialog_run(GTK_DIALOG(w)); gtk_widget_destroy(w); } }
/* Internal function that builds the dialog */ static CustomReportDialog * gnc_ui_custom_report_internal(GncMainWindow * window) { GtkBuilder *builder; CustomReportDialog *crd; GtkTreeIter iter; GtkTreeModel *model; GtkWidget *no_report_notification; GtkWidget *scroll_window; GtkWidget *vscroll; GtkRequisition nat_sb; crd = g_new0(CustomReportDialog, 1); builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-custom-report.glade", "custom_report_dialog"); crd->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "custom_report_dialog")); crd->reportview = GTK_WIDGET(gtk_builder_get_object (builder, "custom_report_list_view")); scroll_window = GTK_WIDGET(gtk_builder_get_object (builder, "custom_report_sw")); no_report_notification = GTK_WIDGET(gtk_builder_get_object (builder, "label2")); set_reports_view_and_model(crd); crd->window = window; // get the vertical scroll bar width vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (scroll_window)); gtk_widget_get_preferred_size (vscroll, NULL, &nat_sb); // set the width of the dummy column to that of the scrollbar gtk_tree_view_column_set_fixed_width (crd->dummycol, nat_sb.width); gtk_window_set_transient_for (GTK_WINDOW (crd->dialog), GTK_WINDOW(window)); // Set the style context for this dialog so it can be easily manipulated with css gnc_widget_set_style_context (GTK_WIDGET(crd->dialog), "GncCustomReportDialog"); gnc_restore_window_size (GNC_PREFS_GROUP_REPORT_SAVED_CONFIGS, GTK_WINDOW(crd->dialog), GTK_WINDOW(window)); /* connect the signals */ gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, crd); gtk_widget_show_all(crd->dialog); /* check if there are currently saved reports available * by checking if there is a first element */ model = gtk_tree_view_get_model (GTK_TREE_VIEW (crd->reportview)); if (gtk_tree_model_get_iter_first (model, &iter)) { /* saved reports available -> hide the "no reports available" notification */ gtk_widget_hide(no_report_notification); } else { /* hide the scrolled window of the report list */ gtk_widget_hide(crd->reportview); } g_object_unref(G_OBJECT(builder)); return crd; }
static void inf_text_gtk_viewport_user_compute_user_area(InfTextGtkViewportUser* user) { InfTextGtkViewportPrivate* priv; GtkWidget* textview; GtkWidget* scrollbar; GtkTextIter iter; GdkRectangle rect; gint y; gint end_y; gint scroll_height; gint slider_size; gint stepper_size; gint stepper_spacing; gint border; GdkRectangle allocation; gint scroll_ox; gint scroll_oy; gint dy; priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(user->viewport); /* TODO: We might want to skip this if show-user-markers is false. */ textview = gtk_bin_get_child(GTK_BIN(priv->scroll)); scrollbar = gtk_scrolled_window_get_vscrollbar(priv->scroll); #if GTK_CHECK_VERSION(2,20,0) if(GTK_IS_TEXT_VIEW(textview) && scrollbar != NULL && gtk_widget_get_realized(textview)) #else if(GTK_IS_TEXT_VIEW(textview) && scrollbar != NULL && GTK_WIDGET_REALIZED(textview)) #endif { gtk_text_buffer_get_iter_at_offset( gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)), &iter, inf_text_user_get_caret_position(user->user) ); gtk_text_view_get_iter_location(GTK_TEXT_VIEW(textview), &iter, &rect); y = rect.y; gtk_text_buffer_get_end_iter( gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)), &iter ); gtk_text_view_get_iter_location(GTK_TEXT_VIEW(textview), &iter, &rect); end_y = rect.y; g_assert(end_y > 0 || y == 0); gtk_widget_style_get( scrollbar, "slider-width", &slider_size, "stepper-size", &stepper_size, "stepper-spacing", &stepper_spacing, "trough-border", &border, NULL ); #if GTK_CHECK_VERSION(2,18,0) gtk_widget_get_allocation(scrollbar, &allocation); #else allocation = scrollbar->allocation; #endif scroll_ox = border; scroll_oy = border + stepper_size + stepper_spacing; scroll_height = allocation.height - 2*scroll_oy; if(end_y > 0) y = y * scroll_height / end_y; user->rectangle.x = scroll_ox + allocation.x; user->rectangle.y = scroll_oy + allocation.y + y - slider_size/3; user->rectangle.width = slider_size; user->rectangle.height = slider_size*2/3; if(user->rectangle.y < scroll_oy + allocation.y) { dy = scroll_oy + allocation.y - user->rectangle.y; user->rectangle.y += dy; user->rectangle.height -= dy; } if(user->rectangle.y + user->rectangle.height > scroll_oy + allocation.y + scroll_height) { user->rectangle.height = scroll_oy + allocation.y + scroll_height - user->rectangle.y; } } else { user->rectangle.x = user->rectangle.y = 0; user->rectangle.width = user->rectangle.height = 0; } }