Struct sourceview4::View

source ·

pub struct View { /* private fields */ }

Expand description

Properties

`background-pattern`

Draw a specific background pattern on the view.

Readable | Writeable

`completion`

The completion object associated with the view

Readable

`indent-width`

Width of an indentation step expressed in number of spaces.

Readable | Writeable

`insert-spaces-instead-of-tabs`

Readable | Writeable

`right-margin-position`

Position of the right margin.

Readable | Writeable

`show-line-marks`

Whether to display line mark pixbufs

Readable | Writeable

`show-line-numbers`

Whether to display line numbers

Readable | Writeable

`show-right-margin`

Whether to display the right margin.

Readable | Writeable

`smart-backspace`

Whether smart Backspace should be used.

Readable | Writeable

`smart-home-end`

Set the behavior of the HOME and END keys.

Readable | Writeable

`space-drawer`

The SpaceDrawer object associated with the view.

Readable

`tab-width`

Width of a tab character expressed in number of spaces.

Readable | Writeable

TextView

`bottom-margin`

The bottom margin for text in the text view.

Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme.

Don’t confuse this property with margin-bottom.

Readable | Writeable

`im-module`

Which IM (input method) module should be used for this text_view. See GtkIMContext.

Setting this to a non-None value overrides the system-wide IM module setting. See the GtkSettings GtkSettings:gtk-im-module property.

Readable | Writeable

`input-hints`

Additional hints (beyond input-purpose) that allow input methods to fine-tune their behaviour.

Readable | Writeable

`input-purpose`

The purpose of this text field.

This property can be used by on-screen keyboards and other input methods to adjust their behaviour.

Readable | Writeable

`left-margin`

The default left margin for text in the text view. Tags in the buffer may override the default.

Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme.

Don’t confuse this property with margin-left.

Readable | Writeable

`populate-all`

If :populate-all is true, the populate-popup signal is also emitted for touch popups.

Readable | Writeable

`right-margin`

The default right margin for text in the text view. Tags in the buffer may override the default.

Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme.

Don’t confuse this property with margin-right.

Readable | Writeable

`top-margin`

The top margin for text in the text view.

Note that this property is confusingly named. In CSS terms, the value set here is padding, and it is applied in addition to the padding from the theme.

Don’t confuse this property with margin-top.

Readable | Writeable

Container

Widget

`double-buffered`

Whether the widget is double buffered.

Readable | Writeable

`expand`

Whether to expand in both directions. Setting this sets both hexpand and vexpand

Readable | Writeable

`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 | Writeable

`halign`

How to distribute horizontal space if widget gets extra space, see gtk::Align

Readable | Writeable

Enables or disables the emission of 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 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 | Writeable

`height-request`

Readable | Writeable

`hexpand`

Whether to expand horizontally. See [WidgetExtManual::set_hexpand()][crate::gtk::prelude::WidgetExtManual::set_hexpand()].

Readable | Writeable

`hexpand-set`

Whether to use the hexpand property. See [WidgetExtManual::is_hexpand_set()][crate::gtk::prelude::WidgetExtManual::is_hexpand_set()].

Readable | Writeable

`is-focus`

Readable | Writeable

`margin`

Sets all four sides’ margin at once. If read, returns max margin on any side.

Readable | Writeable

`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 [WidgetExtManual::set_size_request()][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.

Readable | Writeable

`margin-end`

Margin on end of widget, horizontally. This property supports left-to-right and right-to-left text directions.

Readable | Writeable

`margin-left`

Margin on left side of widget.

Readable | Writeable

`margin-right`

Margin on right side of widget.

Readable | Writeable

`margin-start`

Margin on start of widget, horizontally. This property supports left-to-right and right-to-left text directions.

Readable | Writeable

`margin-top`

Margin on top side of widget.

Readable | Writeable

`name`

Readable | Writeable

`no-show-all`

Readable | Writeable

`opacity`

The requested opacity of the widget. See [WidgetExtManual::set_opacity()][crate::gtk::prelude::WidgetExtManual::set_opacity()] for more details about window opacity.

Before 3.8 this was only available in GtkWindow

Readable | Writeable

`parent`

Readable | Writeable

`receives-default`

Readable | Writeable

`scale-factor`

The scale factor of the widget. See [WidgetExtManual::scale_factor()][crate::gtk::prelude::WidgetExtManual::scale_factor()] for more details about widget scaling.

Readable

`sensitive`

Readable | Writeable

`style`

The style of the widget, which contains information about how it will look (colors, etc).

Readable | Writeable

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().

This is a convenience property which will take care of getting the tooltip shown if the given string is not None: has-tooltip will automatically be set to true and there will be taken care of query-tooltip in the default signal handler.

Note that if both tooltip-text and tooltip-markup are set, the last one wins.

Readable | Writeable

Sets the text of tooltip to be the given string.

Also see Tooltip::set_text().

Note that if both tooltip-text and tooltip-markup are set, the last one wins.

Readable | Writeable

`valign`

How to distribute vertical space if widget gets extra space, see gtk::Align

Readable | Writeable

`vexpand`

Whether to expand vertically. See [WidgetExtManual::set_vexpand()][crate::gtk::prelude::WidgetExtManual::set_vexpand()].

Readable | Writeable

`vexpand-set`

Whether to use the vexpand property. See [WidgetExtManual::is_vexpand_set()][crate::gtk::prelude::WidgetExtManual::is_vexpand_set()].

Readable | Writeable

`visible`

Readable | Writeable

`width-request`

Readable | Writeable

`window`

The widget’s window if it is realized, None otherwise.

Readable

Scrollable

`hadjustment`

Horizontal gtk::Adjustment of the scrollable widget. This adjustment is shared between the scrollable widget and its parent.

Readable | Writeable | Construct

`hscroll-policy`

Determines whether horizontal scrolling should start once the scrollable widget is allocated less than its minimum width or less than its natural width.

Readable | Writeable

`vadjustment`

Verical gtk::Adjustment of the scrollable widget. This adjustment is shared between the scrollable widget and its parent.

Readable | Writeable | Construct

`vscroll-policy`

Determines whether vertical scrolling should start once the scrollable widget is allocated less than its minimum height or less than its natural height.

Readable | Writeable

Signals

`change-case`

Keybinding signal to change case of the text at the current cursor position.

Action

`change-number`

Keybinding signal to edit a number at the current cursor position.

Action

`join-lines`

Keybinding signal to join the lines currently selected.

Action

`line-mark-activated`

Emitted when a line mark has been activated (for instance when there was a button press in the line marks gutter). You can use iter to determine on which line the activation took place.

`move-lines`

The ::move-lines signal is a keybinding which gets emitted when the user initiates moving a line. The default binding key is Alt+Up/Down arrow. And moves the currently selected lines, or the current line up or down by one line.

Action

`move-to-matching-bracket`

Keybinding signal to move the cursor to the matching bracket.

Action

`move-words`

The ::move-words signal is a keybinding which gets emitted when the user initiates moving a word. The default binding key is Alt+Left/Right Arrow and moves the current selection, or the current word by one word.

Action

`redo`

Action

`show-completion`

The ::show-completion signal is a key binding signal which gets emitted when the user requests a completion, by pressing <keycombo>``<keycap>Control</keycap>``<keycap>space</keycap>``</keycombo>.

This will create a CompletionContext with the activation type as CompletionActivation::USER_REQUESTED.

Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to activate the completion by another means, for example with another key binding or a menu entry.

Action

`smart-home-end`

Emitted when a the cursor was moved according to the smart home end setting. The signal is emitted after the cursor is moved, but during the GtkTextView::move-cursor action. This can be used to find out whether the cursor was moved by a normal home/end or by a smart home/end.

`undo`

Action

TextView

`backspace`

The ::backspace signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it.

The default bindings for this signal are Backspace and Shift-Backspace.

Action

`copy-clipboard`

The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard.

The default bindings for this signal are Ctrl-c and Ctrl-Insert.

Action

`cut-clipboard`

The ::cut-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cut the selection to the clipboard.

The default bindings for this signal are Ctrl-x and Shift-Delete.

Action

`delete-from-cursor`

The ::delete-from-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a text deletion.

If the type_ is GTK_DELETE_CHARS, GTK+ deletes the selection if there is one, otherwise it deletes the requested number of characters.

The default bindings for this signal are Delete for deleting a character, Ctrl-Delete for deleting a word and Ctrl-Backspace for deleting a word backwords.

Action

`extend-selection`

The ::extend-selection signal is emitted when the selection needs to be extended at location.

`insert-at-cursor`

The ::insert-at-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates the insertion of a fixed string at the cursor.

This signal has no default bindings.

Action

`insert-emoji`

The ::insert-emoji signal is a [keybinding signal][GtkBindingSignal] which gets emitted to present the Emoji chooser for the text_view.

The default bindings for this signal are Ctrl-. and Ctrl-;

Action

`move-cursor`

The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in text_view, this signal causes the viewport to be moved instead.

Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically.

The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here.

Arrow keys move by individual characters/lines
Ctrl-arrow key combinations move by words/paragraphs
Home/End keys move to the ends of the buffer
PageUp/PageDown keys move vertically by pages
Ctrl-PageUp/PageDown keys move horizontally by pages

Action

`move-viewport`

The ::move-viewport signal is a [keybinding signal][GtkBindingSignal] which can be bound to key combinations to allow the user to move the viewport, i.e. change what part of the text view is visible in a containing scrolled window.

There are no default bindings for this signal.

Action

`paste-clipboard`

The ::paste-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to paste the contents of the clipboard into the text view.

The default bindings for this signal are Ctrl-v and Shift-Insert.

Action

The ::populate-popup signal gets emitted before showing the context menu of the text view.

If you need to add items to the context menu, connect to this signal and append your items to the popup, which will be a GtkMenu in this case.

If populate-all is true, this signal will also be emitted to populate touch popups. In this case, popup will be a different container, e.g. a GtkToolbar.

The signal handler should not make assumptions about the type of widget, but check whether popup is a GtkMenu or GtkToolbar or another kind of container.

`preedit-changed`

If an input method is used, the typed text will not immediately be committed to the buffer. So if you are interested in the text, connect to this signal.

This signal is only emitted if the text at the given position is actually editable.

Action

`select-all`

The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select or unselect the complete contents of the text view.

The default bindings for this signal are Ctrl-a and Ctrl-/ for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.

Action

`set-anchor`

The ::set-anchor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates setting the “anchor” mark. The “anchor” mark gets placed at the same position as the “insert” mark.

This signal has no default bindings.

Action

`toggle-cursor-visible`

The ::toggle-cursor-visible signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the cursor-visible property.

The default binding for this signal is F7.

Action

`toggle-overwrite`

The ::toggle-overwrite signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the overwrite mode of the text view.

The default bindings for this signal is Insert.

Action

Container

`add`

`check-resize`

`remove`

`set-focus-child`

Widget

`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 GdkWindow associated to the widget needs to enable the 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 GdkWindow associated to the widget needs to enable the 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 gtk::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 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 GdkWindow associated to the widget needs to enable the 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() 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 GdkWindow 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 GdkWindow associated to the widget needs to enable the 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. [WidgetExtManual::drag_source_set_icon_pixbuf()][crate::gtk::prelude::WidgetExtManual::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_ACTION_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 gtk_selection_data_set() and gtk_selection_data_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 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 gdk_drag_context_get_selected_action() before calling gtk_drag_finish(), e.g. to implement GDK_ACTION_ASK as shown in the following example:

⚠️ The following code is in 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 handler which gets triggered by calling [WidgetExtManual::drag_get_data()][crate::gtk::prelude::WidgetExtManual::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.

`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, e.g. undo highlighting with [WidgetExtManual::drag_unhighlight()][crate::gtk::prelude::WidgetExtManual::drag_unhighlight()].

Likewise, the 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 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 [WidgetExtManual::drag_get_data()][crate::gtk::prelude::WidgetExtManual::drag_get_data()] and defer the gdk_drag_status() call to the drag-data-received handler. Note that you must pass GTK_DEST_DEFAULT_DROP, GTK_DEST_DEFAULT_MOTION or GTK_DEST_DEFAULT_ALL to 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 and if not, treat the drag-motion signal as an “enter” signal. Upon an “enter”, the handler will typically highlight the drop site with [WidgetExtManual::drag_highlight()][crate::gtk::prelude::WidgetExtManual::drag_highlight()].

⚠️ The following code is in 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 [WidgetExtManual::allocated_width()][crate::gtk::prelude::WidgetExtManual::allocated_width()] and [WidgetExtManual::allocated_height()][crate::gtk::prelude::WidgetExtManual::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 GdkWindow associated to the widget needs to enable the 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) and finally a generic event-after signal.

`event-after`

After the emission of the 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 GdkWindow associated to the widget needs to enable the 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 GdkWindow associated to the widget needs to enable the 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 [WidgetExtManual::grab_add()][crate::gtk::prelude::WidgetExtManual::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 [WidgetExtManual::hide()][crate::gtk::prelude::WidgetExtManual::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 gtk::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 GdkWindow associated to the widget needs to enable the 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 GdkWindow associated to the widget needs to enable the 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 [WidgetExtManual::keynav_failed()][crate::gtk::prelude::WidgetExtManual::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 GdkWindow associated to the widget needs to enable the 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 [WidgetExtManual::set_visible()][crate::gtk::prelude::WidgetExtManual::set_visible()]) and all its parents up to the toplevel widget are also visible. Once the map has occurred, 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.

`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 GdkWindow associated to the widget needs to enable the 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 GdkWindow.

To receive this signal, the GdkWindow associated to the widget needs to enable the 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.

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 GtkEntry 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 GdkWindow associated to the widget needs to enable the gdk::EventMask::PROPERTY_CHANGE_MASK mask.

`proximity-in-event`

To receive this signal the GdkWindow associated to the widget needs to enable the 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 GdkWindow associated to the widget needs to enable the gdk::EventMask::PROXIMITY_OUT_MASK mask.

This signal will be sent to the grab widget if there is one.

Emitted when 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 GdkWindow, which means that [WidgetExtManual::realize()][crate::gtk::prelude::WidgetExtManual::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 GdkWindow associated to the widget needs to enable the 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 [WidgetExtManual::show()][crate::gtk::prelude::WidgetExtManual::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 [WidgetExtManual::state_flags()][crate::gtk::prelude::WidgetExtManual::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 GtkStyleContext associated with a widget, use the style-updated signal.

`style-updated`

The ::style-updated signal is a convenience signal that is emitted when the GtkStyleContext::changed signal is emitted on the widget’s associated GtkStyleContext as returned by [WidgetExtManual::style_context()][crate::gtk::prelude::WidgetExtManual::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 GdkWindow associated to the widget needs to enable the gdk::EventMask::STRUCTURE_MASK mask. GDK will enable this mask automatically for all new windows.

`unrealize`

The ::unrealize signal is emitted when the GdkWindow associated with widget is destroyed, which means that [WidgetExtManual::unrealize()][crate::gtk::prelude::WidgetExtManual::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 GdkWindow associated to the widget needs to enable the 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 GdkWindow associated to the widget needs to enable the gdk::EventMask::STRUCTURE_MASK mask. GDK will enable this mask automatically for all new windows.

Implements

ViewExt, gtk::prelude::TextViewExt, gtk::prelude::ContainerExt, gtk::prelude::WidgetExt, gtk::prelude::BuildableExt, gtk::prelude::ScrollableExt