:right-sidebar: True

Expression
===================================================================

.. currentmodule:: gi.repository.Gtk





.. class:: Expression(*args, **kwargs)
   :no-contents-entry:



Subclasses: :class:`~gi.repository.Gtk.CClosureExpression`, :class:`~gi.repository.Gtk.ClosureExpression`, :class:`~gi.repository.Gtk.ConstantExpression`, :class:`~gi.repository.Gtk.ObjectExpression`, :class:`~gi.repository.Gtk.PropertyExpression`




:Constructors:

::

    Expression(**properties)





Methods
-------

.. rst-class:: interim-class

.. class:: Expression
   :no-index:


   .. method:: bind(target: ~gi.repository.GObject.Object, property: str, this_: ~gi.repository.GObject.Object | None = None) -> ~gi.repository.Gtk.ExpressionWatch

      Bind ``target``'s property named ``property`` to ``self``.

      The value that ``self`` evaluates to is set via ``:func:`~gi.repository.GObject.GObject.Object.set``` on
      ``target``. This is repeated whenever ``self`` changes to ensure that
      the object's property stays synchronized with ``self``.

      If ``self``'s evaluation fails, ``target``'s ``property`` is not updated.
      You can ensure that this doesn't happen by using a fallback
      expression.

      Note that this function takes ownership of ``self``. If you want
      to keep it around, you should :obj:`~gi.repository.Gtk.Expression.ref` it beforehand.







      :param target: the target object to bind to


      :param property: name of the property on ``target`` to bind to


      :param this_: the this argument for
         the evaluation of ``self``





   .. method:: evaluate(this_: ~gi.repository.GObject.Object | None, value: ~typing.Any) -> bool

      Evaluates the given expression and on success stores the result
      in ``value``.

      The ``GType`` of ``value`` will be the type given by
      :obj:`~gi.repository.Gtk.Expression.get_value_type`.

      It is possible that expressions cannot be evaluated - for example
      when the expression references objects that have been destroyed or
      set to ``NULL``. In that case ``value`` will remain empty and ``FALSE``
      will be returned.







      :param this_: the this argument for the evaluation


      :param value: an empty ``GValue``





   .. method:: get_value_type() -> type

      Gets the ``GType`` that this expression evaluates to.

      This type is constant and will not change over the lifetime
      of this expression.










   .. method:: is_static() -> bool

      Checks if the expression is static.

      A static expression will never change its result when
      :obj:`~gi.repository.Gtk.Expression.evaluate` is called on it with the same arguments.

      That means a call to :obj:`~gi.repository.Gtk.Expression.watch` is not necessary because
      it will never trigger a notify.










   .. method:: watch(this_: ~gi.repository.GObject.Object | None, notify: ~typing.Callable[[...], None], *user_data: ~typing.Any) -> ~gi.repository.Gtk.ExpressionWatch

      Watch the given ``expression`` for changes.

      The ``notify`` function will be called whenever the evaluation of ``self``
      may have changed.

      GTK cannot guarantee that the evaluation did indeed change when the ``notify``
      gets invoked, but it guarantees the opposite: When it did in fact change,
      the ``notify`` will be invoked.







      :param this_: the ``this`` argument to
         watch


      :param notify: callback to invoke when the expression changes


      :param user_data: user data to pass to the ``notify`` callback