gtk/auto/

places_sidebar.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{
    Adjustment, Align, Bin, Buildable, Container, CornerType, PlacesOpenFlags, PolicyType,
    ResizeMode, ScrolledWindow, ShadowType, Widget, ffi,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`PlacesSidebar`][crate::PlacesSidebar] is a widget that displays a list of frequently-used places in the
    /// file system: the user’s home directory, the user’s bookmarks, and volumes and drives.
    /// This widget is used as a sidebar in [`FileChooser`][crate::FileChooser] and may be used by file managers
    /// and similar programs.
    ///
    /// The places sidebar displays drives and volumes, and will automatically mount
    /// or unmount them when the user selects them.
    ///
    /// Applications can hook to various signals in the places sidebar to customize
    /// its behavior. For example, they can add extra commands to the context menu
    /// of the sidebar.
    ///
    /// While bookmarks are completely in control of the user, the places sidebar also
    /// allows individual applications to provide extra shortcut folders that are unique
    /// to each application. For example, a Paint program may want to add a shortcut
    /// for a Clipart folder. You can do this with [`add_shortcut()`][Self::add_shortcut()].
    ///
    /// To make use of the places sidebar, an application at least needs to connect
    /// to the [`open-location`][struct@crate::PlacesSidebar#open-location] signal. This is emitted when the
    /// user selects in the sidebar a location to open. The application should also
    /// call [`set_location()`][Self::set_location()] when it changes the currently-viewed
    /// location.
    ///
    /// # CSS nodes
    ///
    /// GtkPlacesSidebar uses a single CSS node with name placessidebar and style
    /// class .sidebar.
    ///
    /// Among the children of the places sidebar, the following style classes can
    /// be used:
    /// - .sidebar-new-bookmark-row for the 'Add new bookmark' row
    /// - .sidebar-placeholder-row for a row that is a placeholder
    /// - .has-open-popup when a popup is open for a row
    ///
    /// ## Properties
    ///
    ///
    /// #### `local-only`
    ///  Readable | Writable
    ///
    ///
    /// #### `location`
    ///  Readable | Writable
    ///
    ///
    /// #### `open-flags`
    ///  Readable | Writable
    ///
    ///
    /// #### `populate-all`
    ///  If :populate-all is [`true`], the [`populate-popup`][struct@crate::PlacesSidebar#populate-popup] signal
    /// is also emitted for popovers.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `show-connect-to-server`
    ///  Readable | Writable
    ///
    ///
    /// #### `show-desktop`
    ///  Readable | Writable
    ///
    ///
    /// #### `show-enter-location`
    ///  Readable | Writable
    ///
    ///
    /// #### `show-other-locations`
    ///  Readable | Writable
    ///
    ///
    /// #### `show-recent`
    ///  Readable | Writable
    ///
    ///
    /// #### `show-starred-location`
    ///  Readable | Writable
    ///
    ///
    /// #### `show-trash`
    ///  Readable | Writable
    /// <details><summary><h4>ScrolledWindow</h4></summary>
    ///
    ///
    /// #### `hadjustment`
    ///  Readable | Writable | Construct
    ///
    ///
    /// #### `hscrollbar-policy`
    ///  Readable | Writable
    ///
    ///
    /// #### `kinetic-scrolling`
    ///  Whether kinetic scrolling is enabled or not. Kinetic scrolling
    /// only applies to devices with source `GDK_SOURCE_TOUCHSCREEN`.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `max-content-height`
    ///  The maximum content height of `scrolled_window`, or -1 if not set.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `max-content-width`
    ///  The maximum content width of `scrolled_window`, or -1 if not set.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `min-content-height`
    ///  The minimum content height of `scrolled_window`, or -1 if not set.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `min-content-width`
    ///  The minimum content width of `scrolled_window`, or -1 if not set.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `overlay-scrolling`
    ///  Whether overlay scrolling is enabled or not. If it is, the
    /// scrollbars are only added as traditional widgets when a mouse
    /// is present. Otherwise, they are overlayed on top of the content,
    /// as narrow indicators.
    ///
    /// Note that overlay scrolling can also be globally disabled, with
    /// the [`gtk-overlay-scrolling`][struct@crate::Settings#gtk-overlay-scrolling] setting.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `propagate-natural-height`
    ///  Whether the natural height of the child should be calculated and propagated
    /// through the scrolled window’s requested natural height.
    ///
    /// This is useful in cases where an attempt should be made to allocate exactly
    /// enough space for the natural size of the child.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `propagate-natural-width`
    ///  Whether the natural width of the child should be calculated and propagated
    /// through the scrolled window’s requested natural width.
    ///
    /// This is useful in cases where an attempt should be made to allocate exactly
    /// enough space for the natural size of the child.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `shadow-type`
    ///  Readable | Writable
    ///
    ///
    /// #### `vadjustment`
    ///  Readable | Writable | Construct
    ///
    ///
    /// #### `vscrollbar-policy`
    ///  Readable | Writable
    ///
    ///
    /// #### `window-placement`
    ///  Readable | Writable
    ///
    ///
    /// #### `window-placement-set`
    ///  Whether "window-placement" should be used to determine the location
    /// of the contents with respect to the scrollbars.
    ///
    /// Readable | Writable
    /// </details>
    /// <details><summary><h4>Container</h4></summary>
    ///
    ///
    /// #### `border-width`
    ///  Readable | Writable
    ///
    ///
    /// #### `child`
    ///  Writable
    ///
    ///
    /// #### `resize-mode`
    ///  Readable | Writable
    /// </details>
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `app-paintable`
    ///  Readable | Writable
    ///
    ///
    /// #### `can-default`
    ///  Readable | Writable
    ///
    ///
    /// #### `can-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `composite-child`
    ///  Readable
    ///
    ///
    /// #### `double-buffered`
    ///  Whether the widget is double buffered.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `events`
    ///  Readable | Writable
    ///
    ///
    /// #### `expand`
    ///  Whether to expand in both directions. Setting this sets both [`hexpand`][struct@crate::Widget#hexpand] and [`vexpand`][struct@crate::Widget#vexpand]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
    /// GtkComboBox) implemented this property individually.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space, see [`Align`][crate::Align]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `has-default`
    ///  Readable | Writable
    ///
    ///
    /// #### `has-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of [`query-tooltip`][struct@crate::Widget#query-tooltip] on `widget`.
    /// A value of [`true`] indicates that `widget` can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to determine
    /// whether it will provide a tooltip or not.
    ///
    /// Note that setting this property to [`true`] for the first time will change
    /// the event masks of the GdkWindows of this widget to include leave-notify
    /// and motion-notify events. This cannot and will not be undone when the
    /// property is set to [`false`] again.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `height-request`
    ///  Readable | Writable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally. See [`WidgetExt::set_hexpand()`][crate::prelude::WidgetExt::set_hexpand()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the [`hexpand`][struct@crate::Widget#hexpand] property. See [`WidgetExt::is_hexpand_set()`][crate::prelude::WidgetExt::is_hexpand_set()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `is-focus`
    ///  Readable | Writable
    ///
    ///
    /// #### `margin`
    ///  Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-end`
    ///  Margin on end of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-left`
    ///  Margin on left side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-right`
    ///  Margin on right side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-start`
    ///  Margin on start of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-top`
    ///  Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `name`
    ///  Readable | Writable
    ///
    ///
    /// #### `no-show-all`
    ///  Readable | Writable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget. See [`WidgetExt::set_opacity()`][crate::prelude::WidgetExt::set_opacity()] for
    /// more details about window opacity.
    ///
    /// Before 3.8 this was only available in GtkWindow
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `parent`
    ///  Readable | Writable
    ///
    ///
    /// #### `receives-default`
    ///  Readable | Writable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget. See [`WidgetExt::scale_factor()`][crate::prelude::WidgetExt::scale_factor()] for
    /// more details about widget scaling.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Readable | Writable
    ///
    ///
    /// #### `style`
    ///  The style of the widget, which contains information about how it will look (colors, etc).
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with the [Pango text markup language][PangoMarkupFormat].
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: [`has-tooltip`][struct@crate::Widget#has-tooltip]
    /// will automatically be set to [`true`] and there will be taken care of
    /// [`query-tooltip`][struct@crate::Widget#query-tooltip] in the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and [`tooltip-markup`][struct@crate::Widget#tooltip-markup]
    /// are set, the last one wins.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: [`has-tooltip`][struct@crate::Widget#has-tooltip]
    /// will automatically be set to [`true`] and there will be taken care of
    /// [`query-tooltip`][struct@crate::Widget#query-tooltip] in the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and [`tooltip-markup`][struct@crate::Widget#tooltip-markup]
    /// are set, the last one wins.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space, see [`Align`][crate::Align]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically. See [`WidgetExt::set_vexpand()`][crate::prelude::WidgetExt::set_vexpand()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the [`vexpand`][struct@crate::Widget#vexpand] property. See [`WidgetExt::is_vexpand_set()`][crate::prelude::WidgetExt::is_vexpand_set()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `visible`
    ///  Readable | Writable
    ///
    ///
    /// #### `width-request`
    ///  Readable | Writable
    ///
    ///
    /// #### `window`
    ///  The widget's window if it is realized, [`None`] otherwise.
    ///
    /// Readable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `drag-action-ask`
    ///  The places sidebar emits this signal when it needs to ask the application
    /// to pop up a menu to ask the user for which drag action to perform.
    ///
    ///
    ///
    ///
    /// #### `drag-action-requested`
    ///  When the user starts a drag-and-drop operation and the sidebar needs
    /// to ask the application for which drag action to perform, then the
    /// sidebar will emit this signal.
    ///
    /// The application can evaluate the `context` for customary actions, or
    /// it can check the type of the files indicated by `source_file_list` against the
    /// possible actions for the destination `dest_file`.
    ///
    /// The drag action to use must be the return value of the signal handler.
    ///
    ///
    ///
    ///
    /// #### `drag-perform-drop`
    ///  The places sidebar emits this signal when the user completes a
    /// drag-and-drop operation and one of the sidebar's items is the
    /// destination. This item is in the `dest_file`, and the
    /// `source_file_list` has the list of files that are dropped into it and
    /// which should be copied/moved/etc. based on the specified `action`.
    ///
    ///
    ///
    ///
    /// #### `mount`
    ///  The places sidebar emits this signal when it starts a new operation
    /// because the user clicked on some location that needs mounting.
    /// In this way the application using the [`PlacesSidebar`][crate::PlacesSidebar] can track the
    /// progress of the operation and, for example, show a notification.
    ///
    ///
    ///
    ///
    /// #### `open-location`
    ///  The places sidebar emits this signal when the user selects a location
    /// in it. The calling application should display the contents of that
    /// location; for example, a file manager should show a list of files in
    /// the specified location.
    ///
    ///
    ///
    ///
    /// #### `populate-popup`
    ///  The places sidebar emits this signal when the user invokes a contextual
    /// popup on one of its items. In the signal handler, the application may
    /// add extra items to the menu as appropriate. For example, a file manager
    /// may want to add a "Properties" command to the menu.
    ///
    /// It is not necessary to store the `selected_item` for each menu item;
    /// during their callbacks, the application can use [`PlacesSidebar::location()`][crate::PlacesSidebar::location()]
    /// to get the file to which the item refers.
    ///
    /// The `selected_item` argument may be [`None`] in case the selection refers to
    /// a volume. In this case, `selected_volume` will be non-[`None`]. In this case,
    /// the calling application will have to `g_object_ref()` the `selected_volume` and
    /// keep it around to use it in the callback.
    ///
    /// The `container` and all its contents are destroyed after the user
    /// dismisses the popup. The popup is re-created (and thus, this signal is
    /// emitted) every time the user activates the contextual menu.
    ///
    /// Before 3.18, the `container` always was a [`Menu`][crate::Menu], and you were expected
    /// to add your items as `GtkMenuItems`. Since 3.18, the popup may be implemented
    /// as a [`Popover`][crate::Popover], in which case `container` will be something else, e.g. a
    /// [`Box`][crate::Box], to which you may add `GtkModelButtons` or other widgets, such as
    /// `GtkEntries`, `GtkSpinButtons`, etc. If your application can deal with this
    /// situation, you can set [`populate-all`][struct@crate::PlacesSidebar#populate-all] to [`true`] to request
    /// that this signal is emitted for populating popovers as well.
    ///
    ///
    ///
    ///
    /// #### `show-connect-to-server`
    ///  The places sidebar emits this signal when it needs the calling
    /// application to present an way to connect directly to a network server.
    /// For example, the application may bring up a dialog box asking for
    /// a URL like "sftp://ftp.example.com". It is up to the application to create
    /// the corresponding mount by using, for example, [`FileExtManual::mount_enclosing_volume()`][crate::gio::prelude::FileExtManual::mount_enclosing_volume()].
    ///
    ///
    ///
    ///
    /// #### `show-enter-location`
    ///  The places sidebar emits this signal when it needs the calling
    /// application to present an way to directly enter a location.
    /// For example, the application may bring up a dialog box asking for
    /// a URL like "http://http.example.com".
    ///
    ///
    ///
    ///
    /// #### `show-error-message`
    ///  The places sidebar emits this signal when it needs the calling
    /// application to present an error message. Most of these messages
    /// refer to mounting or unmounting media, for example, when a drive
    /// cannot be started for some reason.
    ///
    ///
    ///
    ///
    /// #### `show-other-locations`
    ///  The places sidebar emits this signal when it needs the calling
    /// application to present a way to show other locations e.g. drives
    /// and network access points.
    /// For example, the application may bring up a page showing persistent
    /// volumes and discovered network addresses.
    ///
    ///
    ///
    ///
    /// #### `show-other-locations-with-flags`
    ///  The places sidebar emits this signal when it needs the calling
    /// application to present a way to show other locations e.g. drives
    /// and network access points.
    /// For example, the application may bring up a page showing persistent
    /// volumes and discovered network addresses.
    ///
    ///
    ///
    ///
    /// #### `show-starred-location`
    ///  The places sidebar emits this signal when it needs the calling
    /// application to present a way to show the starred files. In GNOME,
    /// starred files are implemented by setting the nao:predefined-tag-favorite
    /// tag in the tracker database.
    ///
    ///
    ///
    ///
    /// #### `unmount`
    ///  The places sidebar emits this signal when it starts a new operation
    /// because the user for example ejected some drive or unmounted a mount.
    /// In this way the application using the [`PlacesSidebar`][crate::PlacesSidebar] can track the
    /// progress of the operation and, for example, show a notification.
    ///
    ///
    /// <details><summary><h4>ScrolledWindow</h4></summary>
    ///
    ///
    /// #### `edge-overshot`
    ///  The ::edge-overshot signal is emitted whenever user initiated scrolling
    /// makes the scrolled window firmly surpass (i.e. with some edge resistance)
    /// the lower or upper limits defined by the adjustment in that orientation.
    ///
    /// A similar behavior without edge resistance is provided by the
    /// [`edge-reached`][struct@crate::ScrolledWindow#edge-reached] signal.
    ///
    /// Note: The `pos` argument is LTR/RTL aware, so callers should be aware too
    /// if intending to provide behavior on horizontal edges.
    ///
    ///
    ///
    ///
    /// #### `edge-reached`
    ///  The ::edge-reached signal is emitted whenever user-initiated scrolling
    /// makes the scrolled window exactly reach the lower or upper limits
    /// defined by the adjustment in that orientation.
    ///
    /// A similar behavior with edge resistance is provided by the
    /// [`edge-overshot`][struct@crate::ScrolledWindow#edge-overshot] signal.
    ///
    /// Note: The `pos` argument is LTR/RTL aware, so callers should be aware too
    /// if intending to provide behavior on horizontal edges.
    ///
    ///
    ///
    ///
    /// #### `move-focus-out`
    ///  The ::move-focus-out signal is a
    /// [keybinding signal][GtkBindingSignal] which gets
    /// emitted when focus is moved away from the scrolled window by a
    /// keybinding. The [`move-focus`][struct@crate::Widget#move-focus] signal is emitted with
    /// `direction_type` on this scrolled window’s toplevel parent in the
    /// container hierarchy. The default bindings for this signal are
    /// `Ctrl + Tab` to move forward and `Ctrl + Shift + Tab` to move backward.
    ///
    /// Action
    ///
    ///
    /// #### `scroll-child`
    ///  The ::scroll-child signal is a
    /// [keybinding signal][GtkBindingSignal]
    /// which gets emitted when a keybinding that scrolls is pressed.
    /// The horizontal or vertical adjustment is updated which triggers a
    /// signal that the scrolled window’s child may listen to and scroll itself.
    ///
    /// Action
    /// </details>
    /// <details><summary><h4>Container</h4></summary>
    ///
    ///
    /// #### `add`
    ///
    ///
    ///
    /// #### `check-resize`
    ///
    ///
    ///
    /// #### `remove`
    ///
    ///
    ///
    /// #### `set-focus-child`
    ///
    /// </details>
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `accel-closures-changed`
    ///
    ///
    ///
    /// #### `button-press-event`
    ///  The ::button-press-event signal will be emitted when a button
    /// (typically from a mouse) is pressed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the
    /// widget needs to enable the [`gdk::EventMask::BUTTON_PRESS_MASK`][crate::gdk::EventMask::BUTTON_PRESS_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `button-release-event`
    ///  The ::button-release-event signal will be emitted when a button
    /// (typically from a mouse) is released.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the
    /// widget needs to enable the [`gdk::EventMask::BUTTON_RELEASE_MASK`][crate::gdk::EventMask::BUTTON_RELEASE_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `can-activate-accel`
    ///  Determines whether an accelerator that activates the signal
    /// identified by `signal_id` can currently be activated.
    /// This signal is present to allow applications and derived
    /// widgets to override the default [`Widget`][crate::Widget] handling
    /// for determining whether an accelerator can be activated.
    ///
    ///
    ///
    ///
    /// #### `child-notify`
    ///  The ::child-notify signal is emitted for each
    /// [child property][child-properties] that has
    /// changed on an object. The signal's detail holds the property name.
    ///
    /// Detailed
    ///
    ///
    /// #### `composited-changed`
    ///  The ::composited-changed signal is emitted when the composited
    /// status of `widgets` screen changes.
    /// See [`Screen::is_composited()`][crate::gdk::Screen::is_composited()].
    ///
    /// Action
    ///
    ///
    /// #### `configure-event`
    ///  The ::configure-event signal will be emitted when the size, position or
    /// stacking of the `widget`'s window has changed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `damage-event`
    ///  Emitted when a redirected window belonging to `widget` gets drawn into.
    /// The region/area members of the event shows what area of the redirected
    /// drawable was drawn into.
    ///
    ///
    ///
    ///
    /// #### `delete-event`
    ///  The ::delete-event signal is emitted if a user requests that
    /// a toplevel window is closed. The default handler for this signal
    /// destroys the window. Connecting [`WidgetExtManual::hide_on_delete()`][crate::prelude::WidgetExtManual::hide_on_delete()] to
    /// this signal will cause the window to be hidden instead, so that
    /// it can later be shown again without reconstructing it.
    ///
    ///
    ///
    ///
    /// #### `destroy`
    ///  Signals that all holders of a reference to the widget should release
    /// the reference that they hold. May result in finalization of the widget
    /// if all references are released.
    ///
    /// This signal is not suitable for saving widget state.
    ///
    ///
    ///
    ///
    /// #### `destroy-event`
    ///  The ::destroy-event signal is emitted when a [`gdk::Window`][crate::gdk::Window] is destroyed.
    /// You rarely get this signal, because most widgets disconnect themselves
    /// from their window before they destroy it, so no widget owns the
    /// window at destroy time.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `direction-changed`
    ///  The ::direction-changed signal is emitted when the text direction
    /// of a widget changes.
    ///
    ///
    ///
    ///
    /// #### `drag-begin`
    ///  The ::drag-begin signal is emitted on the drag source when a drag is
    /// started. A typical reason to connect to this signal is to set up a
    /// custom drag icon with e.g. [`WidgetExt::drag_source_set_icon_pixbuf()`][crate::prelude::WidgetExt::drag_source_set_icon_pixbuf()].
    ///
    /// Note that some widgets set up a drag icon in the default handler of
    /// this signal, so you may have to use `g_signal_connect_after()` to
    /// override what the default handler did.
    ///
    ///
    ///
    ///
    /// #### `drag-data-delete`
    ///  The ::drag-data-delete signal is emitted on the drag source when a drag
    /// with the action [`gdk::DragAction::MOVE`][crate::gdk::DragAction::MOVE] is successfully completed. The signal
    /// handler is responsible for deleting the data that has been dropped. What
    /// "delete" means depends on the context of the drag operation.
    ///
    ///
    ///
    ///
    /// #### `drag-data-get`
    ///  The ::drag-data-get signal is emitted on the drag source when the drop
    /// site requests the data which is dragged. It is the responsibility of
    /// the signal handler to fill `data` with the data in the format which
    /// is indicated by `info`. See [`SelectionData::set()`][crate::SelectionData::set()] and
    /// [`SelectionData::set_text()`][crate::SelectionData::set_text()].
    ///
    ///
    ///
    ///
    /// #### `drag-data-received`
    ///  The ::drag-data-received signal is emitted on the drop site when the
    /// dragged data has been received. If the data was received in order to
    /// determine whether the drop will be accepted, the handler is expected
    /// to call `gdk_drag_status()` and not finish the drag.
    /// If the data was received in response to a [`drag-drop`][struct@crate::Widget#drag-drop] signal
    /// (and this is the last target to be received), the handler for this
    /// signal is expected to process the received data and then call
    /// `gtk_drag_finish()`, setting the `success` parameter depending on
    /// whether the data was processed successfully.
    ///
    /// Applications must create some means to determine why the signal was emitted
    /// and therefore whether to call `gdk_drag_status()` or `gtk_drag_finish()`.
    ///
    /// The handler may inspect the selected action with
    /// [`DragContext::selected_action()`][crate::gdk::DragContext::selected_action()] before calling
    /// `gtk_drag_finish()`, e.g. to implement [`gdk::DragAction::ASK`][crate::gdk::DragAction::ASK] as
    /// shown in the following example:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// void
    /// drag_data_received (GtkWidget          *widget,
    ///                     GdkDragContext     *context,
    ///                     gint                x,
    ///                     gint                y,
    ///                     GtkSelectionData   *data,
    ///                     guint               info,
    ///                     guint               time)
    /// {
    ///   if ((data->length >= 0) && (data->format == 8))
    ///     {
    ///       GdkDragAction action;
    ///
    ///       // handle data here
    ///
    ///       action = gdk_drag_context_get_selected_action (context);
    ///       if (action == GDK_ACTION_ASK)
    ///         {
    ///           GtkWidget *dialog;
    ///           gint response;
    ///
    ///           dialog = gtk_message_dialog_new (NULL,
    ///                                            GTK_DIALOG_MODAL |
    ///                                            GTK_DIALOG_DESTROY_WITH_PARENT,
    ///                                            GTK_MESSAGE_INFO,
    ///                                            GTK_BUTTONS_YES_NO,
    ///                                            "Move the data ?\n");
    ///           response = gtk_dialog_run (GTK_DIALOG (dialog));
    ///           gtk_widget_destroy (dialog);
    ///
    ///           if (response == GTK_RESPONSE_YES)
    ///             action = GDK_ACTION_MOVE;
    ///           else
    ///             action = GDK_ACTION_COPY;
    ///          }
    ///
    ///       gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time);
    ///     }
    ///   else
    ///     gtk_drag_finish (context, FALSE, FALSE, time);
    ///  }
    /// ```
    ///
    ///
    ///
    ///
    /// #### `drag-drop`
    ///  The ::drag-drop signal is emitted on the drop site when the user drops
    /// the data onto the widget. The signal handler must determine whether
    /// the cursor position is in a drop zone or not. If it is not in a drop
    /// zone, it returns [`false`] and no further processing is necessary.
    /// Otherwise, the handler returns [`true`]. In this case, the handler must
    /// ensure that `gtk_drag_finish()` is called to let the source know that
    /// the drop is done. The call to `gtk_drag_finish()` can be done either
    /// directly or in a [`drag-data-received`][struct@crate::Widget#drag-data-received] handler which gets
    /// triggered by calling [`WidgetExt::drag_get_data()`][crate::prelude::WidgetExt::drag_get_data()] to receive the data for one
    /// or more of the supported targets.
    ///
    ///
    ///
    ///
    /// #### `drag-end`
    ///  The ::drag-end signal is emitted on the drag source when a drag is
    /// finished. A typical reason to connect to this signal is to undo
    /// things done in [`drag-begin`][struct@crate::Widget#drag-begin].
    ///
    ///
    ///
    ///
    /// #### `drag-failed`
    ///  The ::drag-failed signal is emitted on the drag source when a drag has
    /// failed. The signal handler may hook custom code to handle a failed DnD
    /// operation based on the type of error, it returns [`true`] is the failure has
    /// been already handled (not showing the default "drag operation failed"
    /// animation), otherwise it returns [`false`].
    ///
    ///
    ///
    ///
    /// #### `drag-leave`
    ///  The ::drag-leave signal is emitted on the drop site when the cursor
    /// leaves the widget. A typical reason to connect to this signal is to
    /// undo things done in [`drag-motion`][struct@crate::Widget#drag-motion], e.g. undo highlighting
    /// with [`WidgetExt::drag_unhighlight()`][crate::prelude::WidgetExt::drag_unhighlight()].
    ///
    ///
    /// Likewise, the [`drag-leave`][struct@crate::Widget#drag-leave] signal is also emitted before the
    /// ::drag-drop signal, for instance to allow cleaning up of a preview item
    /// created in the [`drag-motion`][struct@crate::Widget#drag-motion] signal handler.
    ///
    ///
    ///
    ///
    /// #### `drag-motion`
    ///  The ::drag-motion signal is emitted on the drop site when the user
    /// moves the cursor over the widget during a drag. The signal handler
    /// must determine whether the cursor position is in a drop zone or not.
    /// If it is not in a drop zone, it returns [`false`] and no further processing
    /// is necessary. Otherwise, the handler returns [`true`]. In this case, the
    /// handler is responsible for providing the necessary information for
    /// displaying feedback to the user, by calling `gdk_drag_status()`.
    ///
    /// If the decision whether the drop will be accepted or rejected can't be
    /// made based solely on the cursor position and the type of the data, the
    /// handler may inspect the dragged data by calling [`WidgetExt::drag_get_data()`][crate::prelude::WidgetExt::drag_get_data()] and
    /// defer the `gdk_drag_status()` call to the [`drag-data-received`][struct@crate::Widget#drag-data-received]
    /// handler. Note that you must pass [`DestDefaults::DROP`][crate::DestDefaults::DROP],
    /// [`DestDefaults::MOTION`][crate::DestDefaults::MOTION] or [`DestDefaults::ALL`][crate::DestDefaults::ALL] to [`WidgetExtManual::drag_dest_set()`][crate::prelude::WidgetExtManual::drag_dest_set()]
    /// when using the drag-motion signal that way.
    ///
    /// Also note that there is no drag-enter signal. The drag receiver has to
    /// keep track of whether he has received any drag-motion signals since the
    /// last [`drag-leave`][struct@crate::Widget#drag-leave] and if not, treat the drag-motion signal as
    /// an "enter" signal. Upon an "enter", the handler will typically highlight
    /// the drop site with [`WidgetExt::drag_highlight()`][crate::prelude::WidgetExt::drag_highlight()].
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// drag_motion (GtkWidget      *widget,
    ///              GdkDragContext *context,
    ///              gint            x,
    ///              gint            y,
    ///              guint           time)
    /// {
    ///   GdkAtom target;
    ///
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (!private_data->drag_highlight)
    ///    {
    ///      private_data->drag_highlight = 1;
    ///      gtk_drag_highlight (widget);
    ///    }
    ///
    ///   target = gtk_drag_dest_find_target (widget, context, NULL);
    ///   if (target == GDK_NONE)
    ///     gdk_drag_status (context, 0, time);
    ///   else
    ///    {
    ///      private_data->pending_status
    ///         = gdk_drag_context_get_suggested_action (context);
    ///      gtk_drag_get_data (widget, context, target, time);
    ///    }
    ///
    ///   return TRUE;
    /// }
    ///
    /// static void
    /// drag_data_received (GtkWidget        *widget,
    ///                     GdkDragContext   *context,
    ///                     gint              x,
    ///                     gint              y,
    ///                     GtkSelectionData *selection_data,
    ///                     guint             info,
    ///                     guint             time)
    /// {
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (private_data->suggested_action)
    ///    {
    ///      private_data->suggested_action = 0;
    ///
    ///      // We are getting this data due to a request in drag_motion,
    ///      // rather than due to a request in drag_drop, so we are just
    ///      // supposed to call gdk_drag_status(), not actually paste in
    ///      // the data.
    ///
    ///      str = gtk_selection_data_get_text (selection_data);
    ///      if (!data_is_acceptable (str))
    ///        gdk_drag_status (context, 0, time);
    ///      else
    ///        gdk_drag_status (context,
    ///                         private_data->suggested_action,
    ///                         time);
    ///    }
    ///   else
    ///    {
    ///      // accept the drop
    ///    }
    /// }
    /// ```
    ///
    ///
    ///
    ///
    /// #### `draw`
    ///  This signal is emitted when a widget is supposed to render itself.
    /// The `widget`'s top left corner must be painted at the origin of
    /// the passed in context and be sized to the values returned by
    /// [`WidgetExt::allocated_width()`][crate::prelude::WidgetExt::allocated_width()] and
    /// [`WidgetExt::allocated_height()`][crate::prelude::WidgetExt::allocated_height()].
    ///
    /// Signal handlers connected to this signal can modify the cairo
    /// context passed as `cr` in any way they like and don't need to
    /// restore it. The signal emission takes care of calling `cairo_save()`
    /// before and `cairo_restore()` after invoking the handler.
    ///
    /// The signal handler will get a `cr` with a clip region already set to the
    /// widget's dirty region, i.e. to the area that needs repainting. Complicated
    /// widgets that want to avoid redrawing themselves completely can get the full
    /// extents of the clip region with `gdk_cairo_get_clip_rectangle()`, or they can
    /// get a finer-grained representation of the dirty region with
    /// `cairo_copy_clip_rectangle_list()`.
    ///
    ///
    ///
    ///
    /// #### `enter-notify-event`
    ///  The ::enter-notify-event will be emitted when the pointer enters
    /// the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::ENTER_NOTIFY_MASK`][crate::gdk::EventMask::ENTER_NOTIFY_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `event`
    ///  The GTK+ main loop will emit three signals for each GDK event delivered
    /// to a widget: one generic ::event signal, another, more specific,
    /// signal that matches the type of event delivered (e.g.
    /// [`key-press-event`][struct@crate::Widget#key-press-event]) and finally a generic
    /// [`event-after`][struct@crate::Widget#event-after] signal.
    ///
    ///
    ///
    ///
    /// #### `event-after`
    ///  After the emission of the [`event`][struct@crate::Widget#event] signal and (optionally)
    /// the second more specific signal, ::event-after will be emitted
    /// regardless of the previous two signals handlers return values.
    ///
    ///
    ///
    ///
    /// #### `focus`
    ///
    ///
    ///
    /// #### `focus-in-event`
    ///  The ::focus-in-event signal will be emitted when the keyboard focus
    /// enters the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::FOCUS_CHANGE_MASK`][crate::gdk::EventMask::FOCUS_CHANGE_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `focus-out-event`
    ///  The ::focus-out-event signal will be emitted when the keyboard focus
    /// leaves the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::FOCUS_CHANGE_MASK`][crate::gdk::EventMask::FOCUS_CHANGE_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `grab-broken-event`
    ///  Emitted when a pointer or keyboard grab on a window belonging
    /// to `widget` gets broken.
    ///
    /// On X11, this happens when the grab window becomes unviewable
    /// (i.e. it or one of its ancestors is unmapped), or if the same
    /// application grabs the pointer or keyboard again.
    ///
    ///
    ///
    ///
    /// #### `grab-focus`
    ///  Action
    ///
    ///
    /// #### `grab-notify`
    ///  The ::grab-notify signal is emitted when a widget becomes
    /// shadowed by a GTK+ grab (not a pointer or keyboard grab) on
    /// another widget, or when it becomes unshadowed due to a grab
    /// being removed.
    ///
    /// A widget is shadowed by a [`WidgetExt::grab_add()`][crate::prelude::WidgetExt::grab_add()] when the topmost
    /// grab widget in the grab stack of its window group is not
    /// its ancestor.
    ///
    ///
    ///
    ///
    /// #### `hide`
    ///  The ::hide signal is emitted when `widget` is hidden, for example with
    /// [`WidgetExt::hide()`][crate::prelude::WidgetExt::hide()].
    ///
    ///
    ///
    ///
    /// #### `hierarchy-changed`
    ///  The ::hierarchy-changed signal is emitted when the
    /// anchored state of a widget changes. A widget is
    /// “anchored” when its toplevel
    /// ancestor is a [`Window`][crate::Window]. This signal is emitted when
    /// a widget changes from un-anchored to anchored or vice-versa.
    ///
    ///
    ///
    ///
    /// #### `key-press-event`
    ///  The ::key-press-event signal is emitted when a key is pressed. The signal
    /// emission will reoccur at the key-repeat rate when the key is kept pressed.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::KEY_PRESS_MASK`][crate::gdk::EventMask::KEY_PRESS_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `key-release-event`
    ///  The ::key-release-event signal is emitted when a key is released.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::KEY_RELEASE_MASK`][crate::gdk::EventMask::KEY_RELEASE_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `keynav-failed`
    ///  Gets emitted if keyboard navigation fails.
    /// See [`WidgetExt::keynav_failed()`][crate::prelude::WidgetExt::keynav_failed()] for details.
    ///
    ///
    ///
    ///
    /// #### `leave-notify-event`
    ///  The ::leave-notify-event will be emitted when the pointer leaves
    /// the `widget`'s window.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::LEAVE_NOTIFY_MASK`][crate::gdk::EventMask::LEAVE_NOTIFY_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `map`
    ///  The ::map signal is emitted when `widget` is going to be mapped, that is
    /// when the widget is visible (which is controlled with
    /// [`WidgetExt::set_visible()`][crate::prelude::WidgetExt::set_visible()]) and all its parents up to the toplevel widget
    /// are also visible. Once the map has occurred, [`map-event`][struct@crate::Widget#map-event] will
    /// be emitted.
    ///
    /// The ::map signal can be used to determine whether a widget will be drawn,
    /// for instance it can resume an animation that was stopped during the
    /// emission of [`unmap`][struct@crate::Widget#unmap].
    ///
    ///
    ///
    ///
    /// #### `map-event`
    ///  The ::map-event signal will be emitted when the `widget`'s window is
    /// mapped. A window is mapped when it becomes visible on the screen.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `mnemonic-activate`
    ///  The default handler for this signal activates `widget` if `group_cycling`
    /// is [`false`], or just makes `widget` grab focus if `group_cycling` is [`true`].
    ///
    ///
    ///
    ///
    /// #### `motion-notify-event`
    ///  The ::motion-notify-event signal is emitted when the pointer moves
    /// over the widget's [`gdk::Window`][crate::gdk::Window].
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget
    /// needs to enable the [`gdk::EventMask::POINTER_MOTION_MASK`][crate::gdk::EventMask::POINTER_MOTION_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `move-focus`
    ///  Action
    ///
    ///
    /// #### `parent-set`
    ///  The ::parent-set signal is emitted when a new parent
    /// has been set on a widget.
    ///
    ///
    ///
    ///
    /// #### `popup-menu`
    ///  This signal gets emitted whenever a widget should pop up a context
    /// menu. This usually happens through the standard key binding mechanism;
    /// by pressing a certain key while a widget is focused, the user can cause
    /// the widget to pop up a menu. For example, the [`Entry`][crate::Entry] widget creates
    /// a menu with clipboard commands. See the
    /// [Popup Menu Migration Checklist][checklist-popup-menu]
    /// for an example of how to use this signal.
    ///
    /// Action
    ///
    ///
    /// #### `property-notify-event`
    ///  The ::property-notify-event signal will be emitted when a property on
    /// the `widget`'s window has been changed or deleted.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROPERTY_CHANGE_MASK`][crate::gdk::EventMask::PROPERTY_CHANGE_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `proximity-in-event`
    ///  To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROXIMITY_IN_MASK`][crate::gdk::EventMask::PROXIMITY_IN_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `proximity-out-event`
    ///  To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::PROXIMITY_OUT_MASK`][crate::gdk::EventMask::PROXIMITY_OUT_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `query-tooltip`
    ///  Emitted when [`has-tooltip`][struct@crate::Widget#has-tooltip] is [`true`] and the hover timeout
    /// has expired with the cursor hovering "above" `widget`; or emitted when `widget` got
    /// focus in keyboard mode.
    ///
    /// Using the given coordinates, the signal handler should determine
    /// whether a tooltip should be shown for `widget`. If this is the case
    /// [`true`] should be returned, [`false`] otherwise. Note that if
    /// `keyboard_mode` is [`true`], the values of `x` and `y` are undefined and
    /// should not be used.
    ///
    /// The signal handler is free to manipulate `tooltip` with the therefore
    /// destined function calls.
    ///
    ///
    ///
    ///
    /// #### `realize`
    ///  The ::realize signal is emitted when `widget` is associated with a
    /// [`gdk::Window`][crate::gdk::Window], which means that [`WidgetExt::realize()`][crate::prelude::WidgetExt::realize()] has been called or the
    /// widget has been mapped (that is, it is going to be drawn).
    ///
    ///
    ///
    ///
    /// #### `screen-changed`
    ///  The ::screen-changed signal gets emitted when the
    /// screen of a widget has changed.
    ///
    ///
    ///
    ///
    /// #### `scroll-event`
    ///  The ::scroll-event signal is emitted when a button in the 4 to 7
    /// range is pressed. Wheel mice are usually configured to generate
    /// button press events for buttons 4 and 5 when the wheel is turned.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::SCROLL_MASK`][crate::gdk::EventMask::SCROLL_MASK] mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `selection-clear-event`
    ///  The ::selection-clear-event signal will be emitted when the
    /// the `widget`'s window has lost ownership of a selection.
    ///
    ///
    ///
    ///
    /// #### `selection-get`
    ///
    ///
    ///
    /// #### `selection-notify-event`
    ///
    ///
    ///
    /// #### `selection-received`
    ///
    ///
    ///
    /// #### `selection-request-event`
    ///  The ::selection-request-event signal will be emitted when
    /// another client requests ownership of the selection owned by
    /// the `widget`'s window.
    ///
    ///
    ///
    ///
    /// #### `show`
    ///  The ::show signal is emitted when `widget` is shown, for example with
    /// [`WidgetExt::show()`][crate::prelude::WidgetExt::show()].
    ///
    ///
    ///
    ///
    /// #### `show-help`
    ///  Action
    ///
    ///
    /// #### `size-allocate`
    ///
    ///
    ///
    /// #### `state-changed`
    ///  The ::state-changed signal is emitted when the widget state changes.
    /// See `gtk_widget_get_state()`.
    ///
    ///
    ///
    ///
    /// #### `state-flags-changed`
    ///  The ::state-flags-changed signal is emitted when the widget state
    /// changes, see [`WidgetExt::state_flags()`][crate::prelude::WidgetExt::state_flags()].
    ///
    ///
    ///
    ///
    /// #### `style-set`
    ///  The ::style-set signal is emitted when a new style has been set
    /// on a widget. Note that style-modifying functions like
    /// `gtk_widget_modify_base()` also cause this signal to be emitted.
    ///
    /// Note that this signal is emitted for changes to the deprecated
    /// `GtkStyle`. To track changes to the [`StyleContext`][crate::StyleContext] associated
    /// with a widget, use the [`style-updated`][struct@crate::Widget#style-updated] signal.
    ///
    ///
    ///
    ///
    /// #### `style-updated`
    ///  The ::style-updated signal is a convenience signal that is emitted when the
    /// [`changed`][struct@crate::StyleContext#changed] signal is emitted on the `widget`'s associated
    /// [`StyleContext`][crate::StyleContext] as returned by [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()].
    ///
    /// Note that style-modifying functions like `gtk_widget_override_color()` also
    /// cause this signal to be emitted.
    ///
    ///
    ///
    ///
    /// #### `touch-event`
    ///
    ///
    ///
    /// #### `unmap`
    ///  The ::unmap signal is emitted when `widget` is going to be unmapped, which
    /// means that either it or any of its parents up to the toplevel widget have
    /// been set as hidden.
    ///
    /// As ::unmap indicates that a widget will not be shown any longer, it can be
    /// used to, for example, stop an animation on the widget.
    ///
    ///
    ///
    ///
    /// #### `unmap-event`
    ///  The ::unmap-event signal will be emitted when the `widget`'s window is
    /// unmapped. A window is unmapped when it becomes invisible on the screen.
    ///
    /// To receive this signal, the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `unrealize`
    ///  The ::unrealize signal is emitted when the [`gdk::Window`][crate::gdk::Window] associated with
    /// `widget` is destroyed, which means that [`WidgetExt::unrealize()`][crate::prelude::WidgetExt::unrealize()] has been
    /// called or the widget has been unmapped (that is, it is going to be
    /// hidden).
    ///
    ///
    ///
    ///
    /// #### `visibility-notify-event`
    ///  The ::visibility-notify-event will be emitted when the `widget`'s
    /// window is obscured or unobscured.
    ///
    /// To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget needs
    /// to enable the [`gdk::EventMask::VISIBILITY_NOTIFY_MASK`][crate::gdk::EventMask::VISIBILITY_NOTIFY_MASK] mask.
    ///
    ///
    ///
    ///
    /// #### `window-state-event`
    ///  The ::window-state-event will be emitted when the state of the
    /// toplevel window associated to the `widget` changes.
    ///
    /// To receive this signal the [`gdk::Window`][crate::gdk::Window] associated to the widget
    /// needs to enable the [`gdk::EventMask::STRUCTURE_MASK`][crate::gdk::EventMask::STRUCTURE_MASK] mask. GDK will enable
    /// this mask automatically for all new windows.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`ScrolledWindowExt`][trait@crate::prelude::ScrolledWindowExt], [`BinExt`][trait@crate::prelude::BinExt], [`ContainerExt`][trait@crate::prelude::ContainerExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ContainerExtManual`][trait@crate::prelude::ContainerExtManual], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`BuildableExtManual`][trait@crate::prelude::BuildableExtManual]
    #[doc(alias = "GtkPlacesSidebar")]
    pub struct PlacesSidebar(Object<ffi::GtkPlacesSidebar, ffi::GtkPlacesSidebarClass>) @extends ScrolledWindow, Bin, Container, Widget, @implements Buildable;

    match fn {
        type_ => || ffi::gtk_places_sidebar_get_type(),
    }
}

impl PlacesSidebar {
    /// Creates a new [`PlacesSidebar`][crate::PlacesSidebar] widget.
    ///
    /// The application should connect to at least the
    /// [`open-location`][struct@crate::PlacesSidebar#open-location] signal to be notified
    /// when the user makes a selection in the sidebar.
    ///
    /// # Returns
    ///
    /// a newly created [`PlacesSidebar`][crate::PlacesSidebar]
    #[doc(alias = "gtk_places_sidebar_new")]
    pub fn new() -> PlacesSidebar {
        assert_initialized_main_thread!();
        unsafe { Widget::from_glib_none(ffi::gtk_places_sidebar_new()).unsafe_cast() }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`PlacesSidebar`] objects.
    ///
    /// This method returns an instance of [`PlacesSidebarBuilder`](crate::builders::PlacesSidebarBuilder) which can be used to create [`PlacesSidebar`] objects.
    pub fn builder() -> PlacesSidebarBuilder {
        PlacesSidebarBuilder::new()
    }

    /// Applications may want to present some folders in the places sidebar if
    /// they could be immediately useful to users. For example, a drawing
    /// program could add a “/usr/share/clipart” location when the sidebar is
    /// being used in an “Insert Clipart” dialog box.
    ///
    /// This function adds the specified `location` to a special place for immutable
    /// shortcuts. The shortcuts are application-specific; they are not shared
    /// across applications, and they are not persistent. If this function
    /// is called multiple times with different locations, then they are added
    /// to the sidebar’s list in the same order as the function is called.
    /// ## `location`
    /// location to add as an application-specific shortcut
    #[doc(alias = "gtk_places_sidebar_add_shortcut")]
    pub fn add_shortcut(&self, location: &impl IsA<gio::File>) {
        unsafe {
            ffi::gtk_places_sidebar_add_shortcut(
                self.to_glib_none().0,
                location.as_ref().to_glib_none().0,
            );
        }
    }

    /// Returns the value previously set with [`set_local_only()`][Self::set_local_only()].
    ///
    /// # Returns
    ///
    /// [`true`] if the sidebar will only show local files.
    #[doc(alias = "gtk_places_sidebar_get_local_only")]
    #[doc(alias = "get_local_only")]
    #[doc(alias = "local-only")]
    pub fn is_local_only(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_local_only(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the currently selected location in the `self`. This can be [`None`] when
    /// nothing is selected, for example, when [`set_location()`][Self::set_location()] has
    /// been called with a location that is not among the sidebar’s list of places to
    /// show.
    ///
    /// You can use this function to get the selection in the `self`. Also, if you
    /// connect to the [`populate-popup`][struct@crate::PlacesSidebar#populate-popup] signal, you can use this
    /// function to get the location that is being referred to during the callbacks
    /// for your menu items.
    ///
    /// # Returns
    ///
    /// a [`gio::File`][crate::gio::File] with the selected location, or
    /// [`None`] if nothing is visually selected.
    #[doc(alias = "gtk_places_sidebar_get_location")]
    #[doc(alias = "get_location")]
    pub fn location(&self) -> Option<gio::File> {
        unsafe { from_glib_full(ffi::gtk_places_sidebar_get_location(self.to_glib_none().0)) }
    }

    /// This function queries the bookmarks added by the user to the places sidebar,
    /// and returns one of them. This function is used by [`FileChooser`][crate::FileChooser] to implement
    /// the “Alt-1”, “Alt-2”, etc. shortcuts, which activate the cooresponding bookmark.
    /// ## `n`
    /// index of the bookmark to query
    ///
    /// # Returns
    ///
    /// The bookmark specified by the index `n`, or
    /// [`None`] if no such index exist. Note that the indices start at 0, even though
    /// the file chooser starts them with the keyboard shortcut "Alt-1".
    #[doc(alias = "gtk_places_sidebar_get_nth_bookmark")]
    #[doc(alias = "get_nth_bookmark")]
    pub fn nth_bookmark(&self, n: i32) -> Option<gio::File> {
        unsafe {
            from_glib_full(ffi::gtk_places_sidebar_get_nth_bookmark(
                self.to_glib_none().0,
                n,
            ))
        }
    }

    /// Gets the open flags.
    ///
    /// # Returns
    ///
    /// the [`PlacesOpenFlags`][crate::PlacesOpenFlags] of `self`
    #[doc(alias = "gtk_places_sidebar_get_open_flags")]
    #[doc(alias = "get_open_flags")]
    #[doc(alias = "open-flags")]
    pub fn open_flags(&self) -> PlacesOpenFlags {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_open_flags(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the value previously set with [`set_show_desktop()`][Self::set_show_desktop()]
    ///
    /// # Returns
    ///
    /// [`true`] if the sidebar will display a builtin shortcut to the desktop folder.
    #[doc(alias = "gtk_places_sidebar_get_show_desktop")]
    #[doc(alias = "get_show_desktop")]
    #[doc(alias = "show-desktop")]
    pub fn shows_desktop(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_show_desktop(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the value previously set with [`set_show_enter_location()`][Self::set_show_enter_location()]
    ///
    /// # Returns
    ///
    /// [`true`] if the sidebar will display an “Enter Location” item.
    #[doc(alias = "gtk_places_sidebar_get_show_enter_location")]
    #[doc(alias = "get_show_enter_location")]
    #[doc(alias = "show-enter-location")]
    pub fn shows_enter_location(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_show_enter_location(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the value previously set with [`set_show_other_locations()`][Self::set_show_other_locations()]
    ///
    /// # Returns
    ///
    /// [`true`] if the sidebar will display an “Other Locations” item.
    #[doc(alias = "gtk_places_sidebar_get_show_other_locations")]
    #[doc(alias = "get_show_other_locations")]
    #[doc(alias = "show-other-locations")]
    pub fn shows_other_locations(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_show_other_locations(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the value previously set with [`set_show_recent()`][Self::set_show_recent()]
    ///
    /// # Returns
    ///
    /// [`true`] if the sidebar will display a builtin shortcut for recent files
    #[doc(alias = "gtk_places_sidebar_get_show_recent")]
    #[doc(alias = "get_show_recent")]
    #[doc(alias = "show-recent")]
    pub fn shows_recent(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_show_recent(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the value previously set with [`set_show_starred_location()`][Self::set_show_starred_location()]
    ///
    /// # Returns
    ///
    /// [`true`] if the sidebar will display a Starred item.
    #[doc(alias = "gtk_places_sidebar_get_show_starred_location")]
    #[doc(alias = "get_show_starred_location")]
    #[doc(alias = "show-starred-location")]
    pub fn shows_starred_location(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_show_starred_location(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the value previously set with [`set_show_trash()`][Self::set_show_trash()]
    ///
    /// # Returns
    ///
    /// [`true`] if the sidebar will display a “Trash” item.
    #[doc(alias = "gtk_places_sidebar_get_show_trash")]
    #[doc(alias = "get_show_trash")]
    #[doc(alias = "show-trash")]
    pub fn shows_trash(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_places_sidebar_get_show_trash(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the list of shortcuts.
    ///
    /// # Returns
    ///
    ///
    ///  A `GSList` of [`gio::File`][crate::gio::File] of the locations that have been added as
    ///  application-specific shortcuts with [`add_shortcut()`][Self::add_shortcut()].
    ///  To free this list, you can use
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// g_slist_free_full (list, (GDestroyNotify) g_object_unref);
    /// ```
    #[doc(alias = "gtk_places_sidebar_list_shortcuts")]
    pub fn list_shortcuts(&self) -> Vec<gio::File> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_places_sidebar_list_shortcuts(
                self.to_glib_none().0,
            ))
        }
    }

    /// Removes an application-specific shortcut that has been previously been
    /// inserted with [`add_shortcut()`][Self::add_shortcut()]. If the `location` is not a
    /// shortcut in the sidebar, then nothing is done.
    /// ## `location`
    /// location to remove
    #[doc(alias = "gtk_places_sidebar_remove_shortcut")]
    pub fn remove_shortcut(&self, location: &impl IsA<gio::File>) {
        unsafe {
            ffi::gtk_places_sidebar_remove_shortcut(
                self.to_glib_none().0,
                location.as_ref().to_glib_none().0,
            );
        }
    }

    /// Make the GtkPlacesSidebar show drop targets, so it can show the available
    /// drop targets and a "new bookmark" row. This improves the Drag-and-Drop
    /// experience of the user and allows applications to show all available
    /// drop targets at once.
    ///
    /// This needs to be called when the application is aware of an ongoing drag
    /// that might target the sidebar. The drop-targets-visible state will be unset
    /// automatically if the drag finishes in the GtkPlacesSidebar. You only need
    /// to unset the state when the drag ends on some other widget on your application.
    /// ## `visible`
    /// whether to show the valid targets or not.
    /// ## `context`
    /// drag context used to ask the source about the action that wants to
    ///  perform, so hints are more accurate.
    #[doc(alias = "gtk_places_sidebar_set_drop_targets_visible")]
    pub fn set_drop_targets_visible(&self, visible: bool, context: &gdk::DragContext) {
        unsafe {
            ffi::gtk_places_sidebar_set_drop_targets_visible(
                self.to_glib_none().0,
                visible.into_glib(),
                context.to_glib_none().0,
            );
        }
    }

    /// Sets whether the `self` should only show local files.
    /// ## `local_only`
    /// whether to show only local files
    #[doc(alias = "gtk_places_sidebar_set_local_only")]
    #[doc(alias = "local-only")]
    pub fn set_local_only(&self, local_only: bool) {
        unsafe {
            ffi::gtk_places_sidebar_set_local_only(self.to_glib_none().0, local_only.into_glib());
        }
    }

    /// Sets the location that is being shown in the widgets surrounding the
    /// `self`, for example, in a folder view in a file manager. In turn, the
    /// `self` will highlight that location if it is being shown in the list of
    /// places, or it will unhighlight everything if the `location` is not among the
    /// places in the list.
    /// ## `location`
    /// location to select, or [`None`] for no current path
    #[doc(alias = "gtk_places_sidebar_set_location")]
    #[doc(alias = "location")]
    pub fn set_location(&self, location: Option<&impl IsA<gio::File>>) {
        unsafe {
            ffi::gtk_places_sidebar_set_location(
                self.to_glib_none().0,
                location.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the way in which the calling application can open new locations from
    /// the places sidebar. For example, some applications only open locations
    /// “directly” into their main view, while others may support opening locations
    /// in a new notebook tab or a new window.
    ///
    /// This function is used to tell the places `self` about the ways in which the
    /// application can open new locations, so that the sidebar can display (or not)
    /// the “Open in new tab” and “Open in new window” menu items as appropriate.
    ///
    /// When the [`open-location`][struct@crate::PlacesSidebar#open-location] signal is emitted, its flags
    /// argument will be set to one of the `flags` that was passed in
    /// [`set_open_flags()`][Self::set_open_flags()].
    ///
    /// Passing 0 for `flags` will cause [`PlacesOpenFlags::NORMAL`][crate::PlacesOpenFlags::NORMAL] to always be sent
    /// to callbacks for the “open-location” signal.
    /// ## `flags`
    /// Bitmask of modes in which the calling application can open locations
    #[doc(alias = "gtk_places_sidebar_set_open_flags")]
    #[doc(alias = "open-flags")]
    pub fn set_open_flags(&self, flags: PlacesOpenFlags) {
        unsafe {
            ffi::gtk_places_sidebar_set_open_flags(self.to_glib_none().0, flags.into_glib());
        }
    }

    /// Sets whether the `self` should show an item for the Desktop folder.
    /// The default value for this option is determined by the desktop
    /// environment and the user’s configuration, but this function can be
    /// used to override it on a per-application basis.
    /// ## `show_desktop`
    /// whether to show an item for the Desktop folder
    #[doc(alias = "gtk_places_sidebar_set_show_desktop")]
    #[doc(alias = "show-desktop")]
    pub fn set_show_desktop(&self, show_desktop: bool) {
        unsafe {
            ffi::gtk_places_sidebar_set_show_desktop(
                self.to_glib_none().0,
                show_desktop.into_glib(),
            );
        }
    }

    /// Sets whether the `self` should show an item for entering a location;
    /// this is off by default. An application may want to turn this on if manually
    /// entering URLs is an expected user action.
    ///
    /// If you enable this, you should connect to the
    /// [`show-enter-location`][struct@crate::PlacesSidebar#show-enter-location] signal.
    /// ## `show_enter_location`
    /// whether to show an item to enter a location
    #[doc(alias = "gtk_places_sidebar_set_show_enter_location")]
    #[doc(alias = "show-enter-location")]
    pub fn set_show_enter_location(&self, show_enter_location: bool) {
        unsafe {
            ffi::gtk_places_sidebar_set_show_enter_location(
                self.to_glib_none().0,
                show_enter_location.into_glib(),
            );
        }
    }

    /// Sets whether the `self` should show an item for the application to show
    /// an Other Locations view; this is off by default. When set to [`true`], persistent
    /// devices such as hard drives are hidden, otherwise they are shown in the sidebar.
    /// An application may want to turn this on if it implements a way for the user to
    /// see and interact with drives and network servers directly.
    ///
    /// If you enable this, you should connect to the
    /// [`show-other-locations`][struct@crate::PlacesSidebar#show-other-locations] signal.
    /// ## `show_other_locations`
    /// whether to show an item for the Other Locations view
    #[doc(alias = "gtk_places_sidebar_set_show_other_locations")]
    #[doc(alias = "show-other-locations")]
    pub fn set_show_other_locations(&self, show_other_locations: bool) {
        unsafe {
            ffi::gtk_places_sidebar_set_show_other_locations(
                self.to_glib_none().0,
                show_other_locations.into_glib(),
            );
        }
    }

    /// Sets whether the `self` should show an item for recent files.
    /// The default value for this option is determined by the desktop
    /// environment, but this function can be used to override it on a
    /// per-application basis.
    /// ## `show_recent`
    /// whether to show an item for recent files
    #[doc(alias = "gtk_places_sidebar_set_show_recent")]
    #[doc(alias = "show-recent")]
    pub fn set_show_recent(&self, show_recent: bool) {
        unsafe {
            ffi::gtk_places_sidebar_set_show_recent(self.to_glib_none().0, show_recent.into_glib());
        }
    }

    /// If you enable this, you should connect to the
    /// [`show-starred-location`][struct@crate::PlacesSidebar#show-starred-location] signal.
    /// ## `show_starred_location`
    /// whether to show an item for Starred files
    #[doc(alias = "gtk_places_sidebar_set_show_starred_location")]
    #[doc(alias = "show-starred-location")]
    pub fn set_show_starred_location(&self, show_starred_location: bool) {
        unsafe {
            ffi::gtk_places_sidebar_set_show_starred_location(
                self.to_glib_none().0,
                show_starred_location.into_glib(),
            );
        }
    }

    /// Sets whether the `self` should show an item for the Trash location.
    /// ## `show_trash`
    /// whether to show an item for the Trash location
    #[doc(alias = "gtk_places_sidebar_set_show_trash")]
    #[doc(alias = "show-trash")]
    pub fn set_show_trash(&self, show_trash: bool) {
        unsafe {
            ffi::gtk_places_sidebar_set_show_trash(self.to_glib_none().0, show_trash.into_glib());
        }
    }

    /// If :populate-all is [`true`], the [`populate-popup`][struct@crate::PlacesSidebar#populate-popup] signal
    /// is also emitted for popovers.
    #[doc(alias = "populate-all")]
    pub fn populates_all(&self) -> bool {
        ObjectExt::property(self, "populate-all")
    }

    /// If :populate-all is [`true`], the [`populate-popup`][struct@crate::PlacesSidebar#populate-popup] signal
    /// is also emitted for popovers.
    #[doc(alias = "populate-all")]
    pub fn set_populate_all(&self, populate_all: bool) {
        ObjectExt::set_property(self, "populate-all", populate_all)
    }

    #[doc(alias = "show-connect-to-server")]
    pub fn shows_connect_to_server(&self) -> bool {
        ObjectExt::property(self, "show-connect-to-server")
    }

    #[doc(alias = "show-connect-to-server")]
    pub fn set_show_connect_to_server(&self, show_connect_to_server: bool) {
        ObjectExt::set_property(self, "show-connect-to-server", show_connect_to_server)
    }

    /// The places sidebar emits this signal when it needs to ask the application
    /// to pop up a menu to ask the user for which drag action to perform.
    /// ## `actions`
    /// Possible drag actions that need to be asked for.
    ///
    /// # Returns
    ///
    /// the final drag action that the sidebar should pass to the drag side
    /// of the drag-and-drop operation.
    #[doc(alias = "drag-action-ask")]
    pub fn connect_drag_action_ask<F: Fn(&Self, i32) -> i32 + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn drag_action_ask_trampoline<
            F: Fn(&PlacesSidebar, i32) -> i32 + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            actions: std::ffi::c_int,
            f: glib::ffi::gpointer,
        ) -> std::ffi::c_int {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), actions)
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"drag-action-ask".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    drag_action_ask_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The places sidebar emits this signal when it starts a new operation
    /// because the user clicked on some location that needs mounting.
    /// In this way the application using the [`PlacesSidebar`][crate::PlacesSidebar] can track the
    /// progress of the operation and, for example, show a notification.
    /// ## `mount_operation`
    /// the [`gio::MountOperation`][crate::gio::MountOperation] that is going to start.
    #[doc(alias = "mount")]
    pub fn connect_mount<F: Fn(&Self, &gio::MountOperation) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn mount_trampoline<
            F: Fn(&PlacesSidebar, &gio::MountOperation) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            mount_operation: *mut gio::ffi::GMountOperation,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), &from_glib_borrow(mount_operation))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"mount".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    mount_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The places sidebar emits this signal when the user selects a location
    /// in it. The calling application should display the contents of that
    /// location; for example, a file manager should show a list of files in
    /// the specified location.
    /// ## `location`
    /// [`gio::File`][crate::gio::File] to which the caller should switch.
    /// ## `open_flags`
    /// a single value from [`PlacesOpenFlags`][crate::PlacesOpenFlags] specifying how the `location` should be opened.
    #[doc(alias = "open-location")]
    pub fn connect_open_location<F: Fn(&Self, &gio::File, PlacesOpenFlags) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn open_location_trampoline<
            F: Fn(&PlacesSidebar, &gio::File, PlacesOpenFlags) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            location: *mut gio::ffi::GFile,
            open_flags: ffi::GtkPlacesOpenFlags,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    &from_glib_borrow(this),
                    &from_glib_borrow(location),
                    from_glib(open_flags),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"open-location".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    open_location_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    //#[doc(alias = "populate-popup")]
    //pub fn connect_populate_popup<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Ignored selected_volume: Gio.Volume
    //}

    /// The places sidebar emits this signal when it needs the calling
    /// application to present an way to directly enter a location.
    /// For example, the application may bring up a dialog box asking for
    /// a URL like "http://http.example.com".
    #[doc(alias = "show-enter-location")]
    pub fn connect_show_enter_location<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn show_enter_location_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"show-enter-location".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    show_enter_location_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The places sidebar emits this signal when it needs the calling
    /// application to present an error message. Most of these messages
    /// refer to mounting or unmounting media, for example, when a drive
    /// cannot be started for some reason.
    /// ## `primary`
    /// primary message with a summary of the error to show.
    /// ## `secondary`
    /// secondary message with details of the error to show.
    #[doc(alias = "show-error-message")]
    pub fn connect_show_error_message<F: Fn(&Self, &str, &str) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn show_error_message_trampoline<
            F: Fn(&PlacesSidebar, &str, &str) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            primary: *mut std::ffi::c_char,
            secondary: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    &from_glib_borrow(this),
                    &glib::GString::from_glib_borrow(primary),
                    &glib::GString::from_glib_borrow(secondary),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"show-error-message".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    show_error_message_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The places sidebar emits this signal when it needs the calling
    /// application to present a way to show other locations e.g. drives
    /// and network access points.
    /// For example, the application may bring up a page showing persistent
    /// volumes and discovered network addresses.
    /// ## `open_flags`
    /// a single value from [`PlacesOpenFlags`][crate::PlacesOpenFlags] specifying how it should be opened.
    #[doc(alias = "show-other-locations-with-flags")]
    pub fn connect_show_other_locations_with_flags<F: Fn(&Self, PlacesOpenFlags) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn show_other_locations_with_flags_trampoline<
            F: Fn(&PlacesSidebar, PlacesOpenFlags) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            open_flags: ffi::GtkPlacesOpenFlags,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), from_glib(open_flags))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"show-other-locations-with-flags".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    show_other_locations_with_flags_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The places sidebar emits this signal when it needs the calling
    /// application to present a way to show the starred files. In GNOME,
    /// starred files are implemented by setting the nao:predefined-tag-favorite
    /// tag in the tracker database.
    /// ## `open_flags`
    /// a single value from [`PlacesOpenFlags`][crate::PlacesOpenFlags] specifying how the
    ///  starred file should be opened.
    #[doc(alias = "show-starred-location")]
    pub fn connect_show_starred_location<F: Fn(&Self, PlacesOpenFlags) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn show_starred_location_trampoline<
            F: Fn(&PlacesSidebar, PlacesOpenFlags) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            open_flags: ffi::GtkPlacesOpenFlags,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), from_glib(open_flags))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"show-starred-location".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    show_starred_location_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The places sidebar emits this signal when it starts a new operation
    /// because the user for example ejected some drive or unmounted a mount.
    /// In this way the application using the [`PlacesSidebar`][crate::PlacesSidebar] can track the
    /// progress of the operation and, for example, show a notification.
    /// ## `mount_operation`
    /// the [`gio::MountOperation`][crate::gio::MountOperation] that is going to start.
    #[doc(alias = "unmount")]
    pub fn connect_unmount<F: Fn(&Self, &gio::MountOperation) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn unmount_trampoline<
            F: Fn(&PlacesSidebar, &gio::MountOperation) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            mount_operation: *mut gio::ffi::GMountOperation,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), &from_glib_borrow(mount_operation))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"unmount".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    unmount_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "local-only")]
    pub fn connect_local_only_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_local_only_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::local-only".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_local_only_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "location")]
    pub fn connect_location_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_location_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::location".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_location_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "open-flags")]
    pub fn connect_open_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_open_flags_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::open-flags".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_open_flags_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "populate-all")]
    pub fn connect_populate_all_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_populate_all_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::populate-all".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_populate_all_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-connect-to-server")]
    pub fn connect_show_connect_to_server_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_connect_to_server_trampoline<
            F: Fn(&PlacesSidebar) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::show-connect-to-server".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_connect_to_server_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-desktop")]
    pub fn connect_show_desktop_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_desktop_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::show-desktop".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_desktop_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-enter-location")]
    pub fn connect_show_enter_location_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_enter_location_trampoline<
            F: Fn(&PlacesSidebar) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::show-enter-location".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_enter_location_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-other-locations")]
    pub fn connect_show_other_locations_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_other_locations_trampoline<
            F: Fn(&PlacesSidebar) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::show-other-locations".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_other_locations_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-recent")]
    pub fn connect_show_recent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_recent_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::show-recent".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_recent_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-starred-location")]
    pub fn connect_show_starred_location_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_starred_location_trampoline<
            F: Fn(&PlacesSidebar) + 'static,
        >(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::show-starred-location".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_starred_location_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-trash")]
    pub fn connect_show_trash_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_trash_trampoline<F: Fn(&PlacesSidebar) + 'static>(
            this: *mut ffi::GtkPlacesSidebar,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::show-trash".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_trash_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl Default for PlacesSidebar {
    fn default() -> Self {
        Self::new()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`PlacesSidebar`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct PlacesSidebarBuilder {
    builder: glib::object::ObjectBuilder<'static, PlacesSidebar>,
}

impl PlacesSidebarBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    pub fn local_only(self, local_only: bool) -> Self {
        Self {
            builder: self.builder.property("local-only", local_only),
        }
    }

    pub fn location(self, location: &impl IsA<gio::File>) -> Self {
        Self {
            builder: self.builder.property("location", location.clone().upcast()),
        }
    }

    pub fn open_flags(self, open_flags: PlacesOpenFlags) -> Self {
        Self {
            builder: self.builder.property("open-flags", open_flags),
        }
    }

    /// If :populate-all is [`true`], the [`populate-popup`][struct@crate::PlacesSidebar#populate-popup] signal
    /// is also emitted for popovers.
    pub fn populate_all(self, populate_all: bool) -> Self {
        Self {
            builder: self.builder.property("populate-all", populate_all),
        }
    }

    pub fn show_connect_to_server(self, show_connect_to_server: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("show-connect-to-server", show_connect_to_server),
        }
    }

    pub fn show_desktop(self, show_desktop: bool) -> Self {
        Self {
            builder: self.builder.property("show-desktop", show_desktop),
        }
    }

    pub fn show_enter_location(self, show_enter_location: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("show-enter-location", show_enter_location),
        }
    }

    pub fn show_other_locations(self, show_other_locations: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("show-other-locations", show_other_locations),
        }
    }

    pub fn show_recent(self, show_recent: bool) -> Self {
        Self {
            builder: self.builder.property("show-recent", show_recent),
        }
    }

    pub fn show_starred_location(self, show_starred_location: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("show-starred-location", show_starred_location),
        }
    }

    pub fn show_trash(self, show_trash: bool) -> Self {
        Self {
            builder: self.builder.property("show-trash", show_trash),
        }
    }

    pub fn hadjustment(self, hadjustment: &impl IsA<Adjustment>) -> Self {
        Self {
            builder: self
                .builder
                .property("hadjustment", hadjustment.clone().upcast()),
        }
    }

    pub fn hscrollbar_policy(self, hscrollbar_policy: PolicyType) -> Self {
        Self {
            builder: self
                .builder
                .property("hscrollbar-policy", hscrollbar_policy),
        }
    }

    /// Whether kinetic scrolling is enabled or not. Kinetic scrolling
    /// only applies to devices with source `GDK_SOURCE_TOUCHSCREEN`.
    pub fn kinetic_scrolling(self, kinetic_scrolling: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("kinetic-scrolling", kinetic_scrolling),
        }
    }

    /// The maximum content height of `scrolled_window`, or -1 if not set.
    pub fn max_content_height(self, max_content_height: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("max-content-height", max_content_height),
        }
    }

    /// The maximum content width of `scrolled_window`, or -1 if not set.
    pub fn max_content_width(self, max_content_width: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("max-content-width", max_content_width),
        }
    }

    /// The minimum content height of `scrolled_window`, or -1 if not set.
    pub fn min_content_height(self, min_content_height: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("min-content-height", min_content_height),
        }
    }

    /// The minimum content width of `scrolled_window`, or -1 if not set.
    pub fn min_content_width(self, min_content_width: i32) -> Self {
        Self {
            builder: self
                .builder
                .property("min-content-width", min_content_width),
        }
    }

    /// Whether overlay scrolling is enabled or not. If it is, the
    /// scrollbars are only added as traditional widgets when a mouse
    /// is present. Otherwise, they are overlayed on top of the content,
    /// as narrow indicators.
    ///
    /// Note that overlay scrolling can also be globally disabled, with
    /// the [`gtk-overlay-scrolling`][struct@crate::Settings#gtk-overlay-scrolling] setting.
    pub fn overlay_scrolling(self, overlay_scrolling: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("overlay-scrolling", overlay_scrolling),
        }
    }

    /// Whether the natural height of the child should be calculated and propagated
    /// through the scrolled window’s requested natural height.
    ///
    /// This is useful in cases where an attempt should be made to allocate exactly
    /// enough space for the natural size of the child.
    pub fn propagate_natural_height(self, propagate_natural_height: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("propagate-natural-height", propagate_natural_height),
        }
    }

    /// Whether the natural width of the child should be calculated and propagated
    /// through the scrolled window’s requested natural width.
    ///
    /// This is useful in cases where an attempt should be made to allocate exactly
    /// enough space for the natural size of the child.
    pub fn propagate_natural_width(self, propagate_natural_width: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("propagate-natural-width", propagate_natural_width),
        }
    }

    pub fn shadow_type(self, shadow_type: ShadowType) -> Self {
        Self {
            builder: self.builder.property("shadow-type", shadow_type),
        }
    }

    pub fn vadjustment(self, vadjustment: &impl IsA<Adjustment>) -> Self {
        Self {
            builder: self
                .builder
                .property("vadjustment", vadjustment.clone().upcast()),
        }
    }

    pub fn vscrollbar_policy(self, vscrollbar_policy: PolicyType) -> Self {
        Self {
            builder: self
                .builder
                .property("vscrollbar-policy", vscrollbar_policy),
        }
    }

    pub fn window_placement(self, window_placement: CornerType) -> Self {
        Self {
            builder: self.builder.property("window-placement", window_placement),
        }
    }

    pub fn border_width(self, border_width: u32) -> Self {
        Self {
            builder: self.builder.property("border-width", border_width),
        }
    }

    pub fn child(self, child: &impl IsA<Widget>) -> Self {
        Self {
            builder: self.builder.property("child", child.clone().upcast()),
        }
    }

    pub fn resize_mode(self, resize_mode: ResizeMode) -> Self {
        Self {
            builder: self.builder.property("resize-mode", resize_mode),
        }
    }

    pub fn app_paintable(self, app_paintable: bool) -> Self {
        Self {
            builder: self.builder.property("app-paintable", app_paintable),
        }
    }

    pub fn can_default(self, can_default: bool) -> Self {
        Self {
            builder: self.builder.property("can-default", can_default),
        }
    }

    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    pub fn events(self, events: gdk::EventMask) -> Self {
        Self {
            builder: self.builder.property("events", events),
        }
    }

    /// Whether to expand in both directions. Setting this sets both [`hexpand`][struct@crate::Widget#hexpand] and [`vexpand`][struct@crate::Widget#vexpand]
    pub fn expand(self, expand: bool) -> Self {
        Self {
            builder: self.builder.property("expand", expand),
        }
    }

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
    /// GtkComboBox) implemented this property individually.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// How to distribute horizontal space if widget gets extra space, see [`Align`][crate::Align]
    pub fn halign(self, halign: Align) -> Self {
        Self {
            builder: self.builder.property("halign", halign),
        }
    }

    pub fn has_default(self, has_default: bool) -> Self {
        Self {
            builder: self.builder.property("has-default", has_default),
        }
    }

    pub fn has_focus(self, has_focus: bool) -> Self {
        Self {
            builder: self.builder.property("has-focus", has_focus),
        }
    }

    /// Enables or disables the emission of [`query-tooltip`][struct@crate::Widget#query-tooltip] on `widget`.
    /// A value of [`true`] indicates that `widget` can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to determine
    /// whether it will provide a tooltip or not.
    ///
    /// Note that setting this property to [`true`] for the first time will change
    /// the event masks of the GdkWindows of this widget to include leave-notify
    /// and motion-notify events. This cannot and will not be undone when the
    /// property is set to [`false`] again.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally. See [`WidgetExt::set_hexpand()`][crate::prelude::WidgetExt::set_hexpand()].
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the [`hexpand`][struct@crate::Widget#hexpand] property. See [`WidgetExt::is_hexpand_set()`][crate::prelude::WidgetExt::is_hexpand_set()].
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    pub fn is_focus(self, is_focus: bool) -> Self {
        Self {
            builder: self.builder.property("is-focus", is_focus),
        }
    }

    /// Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    pub fn margin(self, margin: i32) -> Self {
        Self {
            builder: self.builder.property("margin", margin),
        }
    }

    /// Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_bottom(self, margin_bottom: i32) -> Self {
        Self {
            builder: self.builder.property("margin-bottom", margin_bottom),
        }
    }

    /// Margin on end of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_end(self, margin_end: i32) -> Self {
        Self {
            builder: self.builder.property("margin-end", margin_end),
        }
    }

    /// Margin on start of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_start(self, margin_start: i32) -> Self {
        Self {
            builder: self.builder.property("margin-start", margin_start),
        }
    }

    /// Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_top(self, margin_top: i32) -> Self {
        Self {
            builder: self.builder.property("margin-top", margin_top),
        }
    }

    pub fn name(self, name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("name", name.into()),
        }
    }

    pub fn no_show_all(self, no_show_all: bool) -> Self {
        Self {
            builder: self.builder.property("no-show-all", no_show_all),
        }
    }

    /// The requested opacity of the widget. See [`WidgetExt::set_opacity()`][crate::prelude::WidgetExt::set_opacity()] for
    /// more details about window opacity.
    ///
    /// Before 3.8 this was only available in GtkWindow
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    pub fn parent(self, parent: &impl IsA<Container>) -> Self {
        Self {
            builder: self.builder.property("parent", parent.clone().upcast()),
        }
    }

    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    pub fn sensitive(self, sensitive: bool) -> Self {
        Self {
            builder: self.builder.property("sensitive", sensitive),
        }
    }

    /// Sets the text of tooltip to be the given string, which is marked up
    /// with the [Pango text markup language][PangoMarkupFormat].
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: [`has-tooltip`][struct@crate::Widget#has-tooltip]
    /// will automatically be set to [`true`] and there will be taken care of
    /// [`query-tooltip`][struct@crate::Widget#query-tooltip] in the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and [`tooltip-markup`][struct@crate::Widget#tooltip-markup]
    /// are set, the last one wins.
    pub fn tooltip_markup(self, tooltip_markup: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("tooltip-markup", tooltip_markup.into()),
        }
    }

    /// Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: [`has-tooltip`][struct@crate::Widget#has-tooltip]
    /// will automatically be set to [`true`] and there will be taken care of
    /// [`query-tooltip`][struct@crate::Widget#query-tooltip] in the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and [`tooltip-markup`][struct@crate::Widget#tooltip-markup]
    /// are set, the last one wins.
    pub fn tooltip_text(self, tooltip_text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("tooltip-text", tooltip_text.into()),
        }
    }

    /// How to distribute vertical space if widget gets extra space, see [`Align`][crate::Align]
    pub fn valign(self, valign: Align) -> Self {
        Self {
            builder: self.builder.property("valign", valign),
        }
    }

    /// Whether to expand vertically. See [`WidgetExt::set_vexpand()`][crate::prelude::WidgetExt::set_vexpand()].
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the [`vexpand`][struct@crate::Widget#vexpand] property. See [`WidgetExt::is_vexpand_set()`][crate::prelude::WidgetExt::is_vexpand_set()].
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`PlacesSidebar`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> PlacesSidebar {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}