LCOV - code coverage report
Current view: top level - gi - object.h (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 72.7 % 33 24
Test Date: 2024-04-29 05:18:28 Functions: 86.7 % 15 13
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 37.5 % 8 3

             Branch data     Line data    Source code
       1                 :             : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :             : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :             : // SPDX-FileCopyrightText: 2008 litl, LLC
       4                 :             : 
       5                 :             : #ifndef GI_OBJECT_H_
       6                 :             : #define GI_OBJECT_H_
       7                 :             : 
       8                 :             : #include <config.h>
       9                 :             : 
      10                 :             : #include <stddef.h>  // for size_t
      11                 :             : #include <stdint.h>  // for uint32_t
      12                 :             : 
      13                 :             : #include <functional>
      14                 :             : #include <vector>
      15                 :             : 
      16                 :             : #include <girepository.h>
      17                 :             : #include <glib-object.h>
      18                 :             : #include <glib.h>
      19                 :             : 
      20                 :             : #include <js/AllocPolicy.h>
      21                 :             : #include <js/GCHashTable.h>  // for GCHashMap
      22                 :             : #include <js/HashTable.h>    // for DefaultHasher
      23                 :             : #include <js/Id.h>
      24                 :             : #include <js/PropertySpec.h>
      25                 :             : #include <js/RootingAPI.h>
      26                 :             : #include <js/TypeDecls.h>
      27                 :             : #include <mozilla/HashFunctions.h>  // for HashGeneric, HashNumber
      28                 :             : #include <mozilla/Likely.h>         // for MOZ_LIKELY
      29                 :             : 
      30                 :             : #include "gi/value.h"
      31                 :             : #include "gi/wrapperutils.h"
      32                 :             : #include "gjs/jsapi-util-root.h"
      33                 :             : #include "gjs/jsapi-util.h"
      34                 :             : #include "gjs/macros.h"
      35                 :             : #include "util/log.h"
      36                 :             : 
      37                 :             : class GjsAtoms;
      38                 :             : class JSTracer;
      39                 :             : namespace JS {
      40                 :             : class CallArgs;
      41                 :             : }
      42                 :             : namespace Gjs {
      43                 :             : namespace Test {
      44                 :             : struct ObjectInstance;
      45                 :             : }
      46                 :             : }
      47                 :             : class ObjectInstance;
      48                 :             : class ObjectPrototype;
      49                 :             : 
      50                 :             : /*
      51                 :             :  * ObjectBase:
      52                 :             :  *
      53                 :             :  * Specialization of GIWrapperBase for GObject instances. See the documentation
      54                 :             :  * in wrapperutils.h.
      55                 :             :  *
      56                 :             :  * It's important that ObjectBase and ObjectInstance not grow in size without a
      57                 :             :  * very good reason. There can be tens, maybe hundreds of thousands of these
      58                 :             :  * objects alive in a typical gnome-shell run, so even 8 more bytes will add up.
      59                 :             :  * It's less critical that ObjectPrototype stay small, since only one of these
      60                 :             :  * is allocated per GType.
      61                 :             :  */
      62                 :             : class ObjectBase
      63                 :             :     : public GIWrapperBase<ObjectBase, ObjectPrototype, ObjectInstance> {
      64                 :             :     friend class GIWrapperBase<ObjectBase, ObjectPrototype, ObjectInstance>;
      65                 :             : 
      66                 :             :  protected:
      67                 :        2239 :     explicit ObjectBase(ObjectPrototype* proto = nullptr)
      68                 :        2239 :         : GIWrapperBase(proto) {}
      69                 :             : 
      70                 :             :  public:
      71                 :             :     using SignalMatchFunc = guint(gpointer, GSignalMatchType, guint, GQuark,
      72                 :             :                                   GClosure*, gpointer, gpointer);
      73                 :             :     static constexpr GjsDebugTopic DEBUG_TOPIC = GJS_DEBUG_GOBJECT;
      74                 :             :     static constexpr const char* DEBUG_TAG = "GObject";
      75                 :             : 
      76                 :             :     static const struct JSClassOps class_ops;
      77                 :             :     static const struct JSClass klass;
      78                 :             :     static JSFunctionSpec proto_methods[];
      79                 :             :     static JSPropertySpec proto_properties[];
      80                 :             : 
      81                 :             :     static GObject* to_c_ptr(JSContext* cx, JS::HandleObject obj) = delete;
      82                 :             :     GJS_JSAPI_RETURN_CONVENTION
      83                 :             :     static bool to_c_ptr(JSContext* cx, JS::HandleObject obj, GObject** ptr);
      84                 :             :     GJS_JSAPI_RETURN_CONVENTION
      85                 :             :     static bool transfer_to_gi_argument(JSContext* cx, JS::HandleObject obj,
      86                 :             :                                         GIArgument* arg,
      87                 :             :                                         GIDirection transfer_direction,
      88                 :             :                                         GITransfer transfer_ownership,
      89                 :             :                                         GType expected_gtype,
      90                 :             :                                         GIBaseInfo* expected_info = nullptr);
      91                 :             : 
      92                 :             :  private:
      93                 :             :     // This is used in debug methods only.
      94                 :             :     [[nodiscard]] const void* jsobj_addr() const;
      95                 :             : 
      96                 :             :     /* Helper methods */
      97                 :             : 
      98                 :             :  protected:
      99                 :        7600 :     void debug_lifecycle(const char* message) const {
     100                 :        7600 :         GIWrapperBase::debug_lifecycle(jsobj_addr(), message);
     101                 :        7600 :     }
     102                 :             : 
     103                 :             :     [[nodiscard]] bool id_is_never_lazy(jsid name, const GjsAtoms& atoms);
     104                 :             :     [[nodiscard]] bool is_custom_js_class();
     105                 :             : 
     106                 :             :  public:
     107                 :             :     void type_query_dynamic_safe(GTypeQuery* query);
     108                 :             : 
     109                 :             :     GJS_JSAPI_RETURN_CONVENTION
     110                 :             :     static bool typecheck(JSContext* cx, JS::HandleObject obj,
     111                 :             :                           GIObjectInfo* expected_info, GType expected_gtype);
     112                 :         280 :     [[nodiscard]] static bool typecheck(JSContext* cx, JS::HandleObject obj,
     113                 :             :                                         GIObjectInfo* expected_info,
     114                 :             :                                         GType expected_gtype,
     115                 :             :                                         GjsTypecheckNoThrow no_throw) {
     116                 :         280 :         return GIWrapperBase::typecheck(cx, obj, expected_info, expected_gtype,
     117                 :         280 :                                         no_throw);
     118                 :             :     }
     119                 :             : 
     120                 :             :     /* JSClass operations */
     121                 :             : 
     122                 :             :     static bool add_property(JSContext* cx, JS::HandleObject obj,
     123                 :             :                              JS::HandleId id, JS::HandleValue value);
     124                 :             : 
     125                 :             :     /* JS property getters/setters */
     126                 :             : 
     127                 :             :  public:
     128                 :             :     GJS_JSAPI_RETURN_CONVENTION
     129                 :             :     static bool prop_getter(JSContext* cx, unsigned argc, JS::Value* vp);
     130                 :             :     GJS_JSAPI_RETURN_CONVENTION
     131                 :             :     static bool field_getter(JSContext* cx, unsigned argc, JS::Value* vp);
     132                 :             :     GJS_JSAPI_RETURN_CONVENTION
     133                 :             :     static bool prop_setter(JSContext* cx, unsigned argc, JS::Value* vp);
     134                 :             :     GJS_JSAPI_RETURN_CONVENTION
     135                 :             :     static bool field_setter(JSContext* cx, unsigned argc, JS::Value* vp);
     136                 :             : 
     137                 :             :     /* JS methods */
     138                 :             : 
     139                 :             :     GJS_JSAPI_RETURN_CONVENTION
     140                 :             :     static bool connect(JSContext* cx, unsigned argc, JS::Value* vp);
     141                 :             :     GJS_JSAPI_RETURN_CONVENTION
     142                 :             :     static bool connect_after(JSContext* cx, unsigned argc, JS::Value* vp);
     143                 :             :     GJS_JSAPI_RETURN_CONVENTION
     144                 :             :     static bool connect_object(JSContext* cx, unsigned argc, JS::Value* vp);
     145                 :             :     GJS_JSAPI_RETURN_CONVENTION
     146                 :             :     static bool emit(JSContext* cx, unsigned argc, JS::Value* vp);
     147                 :             :     GJS_JSAPI_RETURN_CONVENTION
     148                 :             :     static bool signal_find(JSContext* cx, unsigned argc, JS::Value* vp);
     149                 :             :     template <SignalMatchFunc(*MATCH_FUNC)>
     150                 :             :     GJS_JSAPI_RETURN_CONVENTION static bool signals_action(JSContext* cx,
     151                 :             :                                                            unsigned argc,
     152                 :             :                                                            JS::Value* vp);
     153                 :             :     GJS_JSAPI_RETURN_CONVENTION
     154                 :             :     static bool to_string(JSContext* cx, unsigned argc, JS::Value* vp);
     155                 :             :     GJS_JSAPI_RETURN_CONVENTION
     156                 :             :     static bool init_gobject(JSContext* cx, unsigned argc, JS::Value* vp);
     157                 :             :     GJS_JSAPI_RETURN_CONVENTION
     158                 :             :     static bool hook_up_vfunc(JSContext* cx, unsigned argc, JS::Value* vp);
     159                 :             : 
     160                 :             :     /* Quarks */
     161                 :             : 
     162                 :             :  protected:
     163                 :             :     [[nodiscard]] static GQuark instance_strings_quark();
     164                 :             : 
     165                 :             :  public:
     166                 :             :     [[nodiscard]] static GQuark custom_type_quark();
     167                 :             :     [[nodiscard]] static GQuark custom_property_quark();
     168                 :             :     [[nodiscard]] static GQuark disposed_quark();
     169                 :             : };
     170                 :             : 
     171                 :             : // See https://bugzilla.mozilla.org/show_bug.cgi?id=1614220
     172                 :             : struct IdHasher {
     173                 :             :     typedef jsid Lookup;
     174                 :       13670 :     static mozilla::HashNumber hash(jsid id) {
     175         [ +  + ]:       13670 :         if (MOZ_LIKELY(id.isString()))
     176                 :       13161 :             return js::DefaultHasher<JSString*>::hash(id.toString());
     177         [ +  - ]:         509 :         if (id.isSymbol())
     178                 :         509 :             return js::DefaultHasher<JS::Symbol*>::hash(id.toSymbol());
     179                 :           0 :         return mozilla::HashGeneric(id.asRawBits());
     180                 :             :     }
     181                 :        6570 :     static bool match(jsid id1, jsid id2) { return id1 == id2; }
     182                 :             : };
     183                 :             : 
     184                 :             : class ObjectPrototype
     185                 :             :     : public GIWrapperPrototype<ObjectBase, ObjectPrototype, ObjectInstance> {
     186                 :             :     friend class GIWrapperPrototype<ObjectBase, ObjectPrototype,
     187                 :             :                                     ObjectInstance>;
     188                 :             :     friend class GIWrapperBase<ObjectBase, ObjectPrototype, ObjectInstance>;
     189                 :             : 
     190                 :             :     using FieldCache =
     191                 :             :         JS::GCHashMap<JS::Heap<JSString*>, GjsAutoFieldInfo,
     192                 :             :                       js::DefaultHasher<JSString*>, js::SystemAllocPolicy>;
     193                 :             :     using NegativeLookupCache =
     194                 :             :         JS::GCHashSet<JS::Heap<jsid>, IdHasher, js::SystemAllocPolicy>;
     195                 :             : 
     196                 :             :     FieldCache m_field_cache;
     197                 :             :     NegativeLookupCache m_unresolvable_cache;
     198                 :             :     // a list of vfunc GClosures installed on this prototype, used when tracing
     199                 :             :     std::vector<GClosure*> m_vfuncs;
     200                 :             :     // a list of interface types explicitly associated with this prototype,
     201                 :             :     // by gjs_add_interface
     202                 :             :     std::vector<GType> m_interface_gtypes;
     203                 :             : 
     204                 :             :     ObjectPrototype(GIObjectInfo* info, GType gtype);
     205                 :             :     ~ObjectPrototype();
     206                 :             : 
     207                 :             :     static constexpr InfoType::Tag info_type_tag = InfoType::Object;
     208                 :             : 
     209                 :             :  public:
     210                 :             :     [[nodiscard]] static ObjectPrototype* for_gtype(GType gtype);
     211                 :             : 
     212                 :             :     /* Helper methods */
     213                 :             :  private:
     214                 :             :     GJS_JSAPI_RETURN_CONVENTION
     215                 :             :     bool get_parent_proto(JSContext* cx, JS::MutableHandleObject proto) const;
     216                 :             :     GJS_JSAPI_RETURN_CONVENTION
     217                 :             :     bool get_parent_constructor(JSContext* cx,
     218                 :             :                                 JS::MutableHandleObject constructor) const;
     219                 :             : 
     220                 :             :     [[nodiscard]] bool is_vfunc_unchanged(GIVFuncInfo* info);
     221                 :             :     static void vfunc_invalidated_notify(void* data, GClosure* closure);
     222                 :             : 
     223                 :             :     GJS_JSAPI_RETURN_CONVENTION
     224                 :             :     bool lazy_define_gobject_property(JSContext* cx, JS::HandleObject obj,
     225                 :             :                                       JS::HandleId id, GParamSpec*,
     226                 :             :                                       bool* resolved, const char* name);
     227                 :             : 
     228                 :             :     enum ResolveWhat { ConsiderOnlyMethods, ConsiderMethodsAndProperties };
     229                 :             :     GJS_JSAPI_RETURN_CONVENTION
     230                 :             :     bool resolve_no_info(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
     231                 :             :                          bool* resolved, const char* name,
     232                 :             :                          ResolveWhat resolve_props);
     233                 :             :     GJS_JSAPI_RETURN_CONVENTION
     234                 :             :     bool uncached_resolve(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
     235                 :             :                           const char* name, bool* resolved);
     236                 :             : 
     237                 :             :  public:
     238                 :             :     void set_interfaces(GType* interface_gtypes, uint32_t n_interface_gtypes);
     239                 :             :     void set_type_qdata(void);
     240                 :             :     GJS_JSAPI_RETURN_CONVENTION
     241                 :             :     GParamSpec* find_param_spec_from_id(JSContext*,
     242                 :             :                                         GjsAutoTypeClass<GObjectClass> const&,
     243                 :             :                                         JS::HandleString key);
     244                 :             :     GJS_JSAPI_RETURN_CONVENTION
     245                 :             :     GIFieldInfo* lookup_cached_field_info(JSContext* cx, JS::HandleString key);
     246                 :             :     GJS_JSAPI_RETURN_CONVENTION
     247                 :             :     bool props_to_g_parameters(JSContext*,
     248                 :             :                                GjsAutoTypeClass<GObjectClass> const&,
     249                 :             :                                JS::HandleObject props,
     250                 :             :                                std::vector<const char*>* names,
     251                 :             :                                AutoGValueVector* values);
     252                 :             : 
     253                 :             :     GJS_JSAPI_RETURN_CONVENTION
     254                 :             :     static bool define_class(JSContext* cx, JS::HandleObject in_object,
     255                 :             :                              GIObjectInfo* info, GType gtype,
     256                 :             :                              GType* interface_gtypes,
     257                 :             :                              uint32_t n_interface_gtypes,
     258                 :             :                              JS::MutableHandleObject constructor,
     259                 :             :                              JS::MutableHandleObject prototype);
     260                 :             : 
     261                 :           0 :     void ref_vfuncs(void) {
     262         [ #  # ]:           0 :         for (GClosure* closure : m_vfuncs)
     263                 :           0 :             g_closure_ref(closure);
     264                 :           0 :     }
     265                 :           0 :     void unref_vfuncs(void) {
     266         [ #  # ]:           0 :         for (GClosure* closure : m_vfuncs)
     267                 :           0 :             g_closure_unref(closure);
     268                 :           0 :     }
     269                 :             : 
     270                 :             :     /* JSClass operations */
     271                 :             :  private:
     272                 :             :     GJS_JSAPI_RETURN_CONVENTION
     273                 :             :     bool resolve_impl(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
     274                 :             :                       bool* resolved);
     275                 :             : 
     276                 :             :     GJS_JSAPI_RETURN_CONVENTION
     277                 :             :     bool new_enumerate_impl(JSContext* cx, JS::HandleObject obj,
     278                 :             :                             JS::MutableHandleIdVector properties,
     279                 :             :                             bool only_enumerable);
     280                 :             :     void trace_impl(JSTracer* tracer);
     281                 :             : 
     282                 :             :     /* JS methods */
     283                 :             :  public:
     284                 :             :     GJS_JSAPI_RETURN_CONVENTION
     285                 :             :     bool hook_up_vfunc_impl(JSContext* cx, const JS::CallArgs& args);
     286                 :             : };
     287                 :             : 
     288                 :             : class ObjectInstance : public GIWrapperInstance<ObjectBase, ObjectPrototype,
     289                 :             :                                                 ObjectInstance, GObject> {
     290                 :             :     friend class GIWrapperInstance<ObjectBase, ObjectPrototype, ObjectInstance,
     291                 :             :                                    GObject>;
     292                 :             :     friend class GIWrapperBase<ObjectBase, ObjectPrototype, ObjectInstance>;
     293                 :             :     friend class ObjectBase;  // for add_property, prop_getter, etc.
     294                 :             :     friend struct Gjs::Test::ObjectInstance;
     295                 :             : 
     296                 :             :     // GIWrapperInstance::m_ptr may be null in ObjectInstance.
     297                 :             : 
     298                 :             :     GjsMaybeOwned m_wrapper;
     299                 :             :     // a list of all GClosures installed on this object (from signal connections
     300                 :             :     // and scope-notify callbacks passed to methods), used when tracing
     301                 :             :     std::vector<GClosure*> m_closures;
     302                 :             : 
     303                 :             :     bool m_wrapper_finalized : 1;
     304                 :             :     bool m_gobj_disposed : 1;
     305                 :             :     bool m_gobj_finalized : 1;
     306                 :             : 
     307                 :             :     /* True if this object has visible JS state, and thus its lifecycle is
     308                 :             :      * managed using toggle references. False if this object just keeps a
     309                 :             :      * hard ref on the underlying GObject, and may be finalized at will. */
     310                 :             :     bool m_uses_toggle_ref : 1;
     311                 :             : 
     312                 :             :     static bool s_weak_pointer_callback;
     313                 :             : 
     314                 :             :     /* Constructors */
     315                 :             : 
     316                 :             :  private:
     317                 :             :     ObjectInstance(ObjectPrototype* prototype, JS::HandleObject obj);
     318                 :             :     ~ObjectInstance();
     319                 :             : 
     320                 :             :     GJS_JSAPI_RETURN_CONVENTION
     321                 :             :     static ObjectInstance* new_for_gobject(JSContext* cx, GObject* gobj);
     322                 :             : 
     323                 :             :     // Extra method to get an existing ObjectInstance from qdata
     324                 :             : 
     325                 :             :  public:
     326                 :             :     [[nodiscard]] static ObjectInstance* for_gobject(GObject* gobj);
     327                 :             : 
     328                 :             :     /* Accessors */
     329                 :             : 
     330                 :             :  private:
     331                 :        3186 :     [[nodiscard]] bool has_wrapper() const { return !!m_wrapper; }
     332                 :             : 
     333                 :             :  public:
     334                 :        2731 :     [[nodiscard]] JSObject* wrapper() const { return m_wrapper.get(); }
     335                 :             : 
     336                 :             :     /* Methods to manipulate the JS object wrapper */
     337                 :             : 
     338                 :             :  private:
     339                 :        1845 :     void discard_wrapper(void) { m_wrapper.reset(); }
     340                 :        1607 :     void switch_to_rooted(JSContext* cx) { m_wrapper.switch_to_rooted(cx); }
     341                 :        1466 :     void switch_to_unrooted(JSContext* cx) { m_wrapper.switch_to_unrooted(cx); }
     342                 :        1544 :     [[nodiscard]] bool update_after_gc(JSTracer* trc) {
     343                 :        1544 :         return m_wrapper.update_after_gc(trc);
     344                 :             :     }
     345                 :        9107 :     [[nodiscard]] bool wrapper_is_rooted() const { return m_wrapper.rooted(); }
     346                 :             :     void release_native_object(void);
     347                 :             :     void associate_js_gobject(JSContext* cx, JS::HandleObject obj,
     348                 :             :                               GObject* gobj);
     349                 :             :     void disassociate_js_gobject(void);
     350                 :             :     void handle_context_dispose(void);
     351                 :             :     [[nodiscard]] bool weak_pointer_was_finalized(JSTracer* trc);
     352                 :             :     static void ensure_weak_pointer_callback(JSContext* cx);
     353                 :             :     static void update_heap_wrapper_weak_pointers(JSTracer* trc,
     354                 :             :                                                   JS::Compartment*, void* data);
     355                 :             : 
     356                 :             :  public:
     357                 :             :     void toggle_down(void);
     358                 :             :     void toggle_up(void);
     359                 :             : 
     360                 :             :     GJS_JSAPI_RETURN_CONVENTION
     361                 :             :     static JSObject* wrapper_from_gobject(JSContext* cx, GObject* ptr);
     362                 :             : 
     363                 :             :     GJS_JSAPI_RETURN_CONVENTION
     364                 :             :     static bool set_value_from_gobject(JSContext* cx, GObject*,
     365                 :             :                                        JS::MutableHandleValue);
     366                 :             : 
     367                 :             :     /* Methods to manipulate the list of closures */
     368                 :             : 
     369                 :             :  private:
     370                 :             :     void invalidate_closures();
     371                 :             :     static void closure_invalidated_notify(void* data, GClosure* closure);
     372                 :             : 
     373                 :             :  public:
     374                 :             :     GJS_JSAPI_RETURN_CONVENTION bool associate_closure(JSContext*, GClosure*);
     375                 :             : 
     376                 :             :     /* Helper methods */
     377                 :             : 
     378                 :             :  private:
     379                 :             :     void set_object_qdata(void);
     380                 :             :     void unset_object_qdata(void);
     381                 :             :     void track_gobject_finalization();
     382                 :             :     void ignore_gobject_finalization();
     383                 :             :     void check_js_object_finalized(void);
     384                 :             :     void ensure_uses_toggle_ref(JSContext*);
     385                 :             :     [[nodiscard]] bool check_gobject_disposed_or_finalized(
     386                 :             :         const char* for_what) const;
     387                 :             :     [[nodiscard]] bool check_gobject_finalized(const char* for_what) const;
     388                 :             :     GJS_JSAPI_RETURN_CONVENTION
     389                 :             :     bool signal_match_arguments_from_object(
     390                 :             :         JSContext* cx, JS::HandleObject props_obj, GSignalMatchType* mask_out,
     391                 :             :         unsigned* signal_id_out, GQuark* detail_out,
     392                 :             :         JS::MutableHandleObject callable_out);
     393                 :             : 
     394                 :             :  public:
     395                 :          58 :     static GObject* copy_ptr(JSContext*, GType, void* ptr) {
     396                 :          58 :         return G_OBJECT(g_object_ref(G_OBJECT(ptr)));
     397                 :             :     }
     398                 :             : 
     399                 :             :     GJS_JSAPI_RETURN_CONVENTION
     400                 :             :     bool init_custom_class_from_gobject(JSContext* cx, JS::HandleObject wrapper,
     401                 :             :                                         GObject* gobj);
     402                 :             : 
     403                 :             :     static void associate_string(GObject* obj, char* str);
     404                 :             : 
     405                 :             :     /* Methods to manipulate the linked list of instances */
     406                 :             : 
     407                 :             :  private:
     408                 :             :     static std::vector<ObjectInstance*> s_wrapped_gobject_list;
     409                 :             :     void link(void);
     410                 :             :     void unlink(void);
     411                 :             :     [[nodiscard]] static size_t num_wrapped_gobjects() {
     412                 :             :         return s_wrapped_gobject_list.size();
     413                 :             :     }
     414                 :             :     using Action = std::function<void(ObjectInstance*)>;
     415                 :             :     using Predicate = std::function<bool(ObjectInstance*)>;
     416                 :             :     static void remove_wrapped_gobjects_if(const Predicate& predicate,
     417                 :             :                                            const Action& action);
     418                 :             : 
     419                 :             :  public:
     420                 :             :     static void prepare_shutdown(void);
     421                 :             : 
     422                 :             :     /* JSClass operations */
     423                 :             : 
     424                 :             :  private:
     425                 :             :     GJS_JSAPI_RETURN_CONVENTION
     426                 :             :     bool add_property_impl(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
     427                 :             :                            JS::HandleValue value);
     428                 :             :     void finalize_impl(JS::GCContext*, JSObject* obj);
     429                 :             :     void trace_impl(JSTracer* trc);
     430                 :             : 
     431                 :             :     /* JS property getters/setters */
     432                 :             : 
     433                 :             :  private:
     434                 :             :     GJS_JSAPI_RETURN_CONVENTION
     435                 :             :     bool prop_getter_impl(JSContext* cx, GParamSpec*,
     436                 :             :                           JS::MutableHandleValue rval);
     437                 :             :     GJS_JSAPI_RETURN_CONVENTION
     438                 :             :     bool field_getter_impl(JSContext* cx, JS::HandleString name,
     439                 :             :                            JS::MutableHandleValue rval);
     440                 :             :     GJS_JSAPI_RETURN_CONVENTION
     441                 :             :     bool prop_setter_impl(JSContext* cx, GParamSpec*, JS::HandleValue value);
     442                 :             :     GJS_JSAPI_RETURN_CONVENTION
     443                 :             :     bool field_setter_not_impl(JSContext* cx, JS::HandleString name);
     444                 :             : 
     445                 :             :     // JS constructor
     446                 :             : 
     447                 :             :     GJS_JSAPI_RETURN_CONVENTION
     448                 :             :     bool constructor_impl(JSContext* cx, JS::HandleObject obj,
     449                 :             :                           const JS::CallArgs& args);
     450                 :             : 
     451                 :             :     /* JS methods */
     452                 :             : 
     453                 :             :  private:
     454                 :             :     GJS_JSAPI_RETURN_CONVENTION
     455                 :             :     bool connect_impl(JSContext* cx, const JS::CallArgs& args, bool after,
     456                 :             :                       bool object = false);
     457                 :             :     GJS_JSAPI_RETURN_CONVENTION
     458                 :             :     bool emit_impl(JSContext* cx, const JS::CallArgs& args);
     459                 :             :     GJS_JSAPI_RETURN_CONVENTION
     460                 :             :     bool signal_find_impl(JSContext* cx, const JS::CallArgs& args);
     461                 :             :     template <SignalMatchFunc(*MATCH_FUNC)>
     462                 :             :     GJS_JSAPI_RETURN_CONVENTION bool signals_action_impl(
     463                 :             :         JSContext* cx, const JS::CallArgs& args);
     464                 :             :     GJS_JSAPI_RETURN_CONVENTION
     465                 :             :     bool init_impl(JSContext* cx, const JS::CallArgs& args,
     466                 :             :                    JS::HandleObject obj);
     467                 :             :     [[nodiscard]] const char* to_string_kind() const;
     468                 :             : 
     469                 :             :     GJS_JSAPI_RETURN_CONVENTION
     470                 :             :     bool typecheck_impl(JSContext* cx, GIBaseInfo* expected_info,
     471                 :             :                         GType expected_type) const;
     472                 :             : 
     473                 :             :     /* Notification callbacks */
     474                 :             :     void gobj_dispose_notify(void);
     475                 :             :     static void wrapped_gobj_dispose_notify(void* data, GObject*);
     476                 :             :     static void wrapped_gobj_toggle_notify(void* instance, GObject* gobj,
     477                 :             :                                            gboolean is_last_ref);
     478                 :             : 
     479                 :             :  public:
     480                 :             :     static void context_dispose_notify(void* data,
     481                 :             :                                        GObject* where_the_object_was);
     482                 :             : };
     483                 :             : 
     484                 :             : GJS_JSAPI_RETURN_CONVENTION
     485                 :             : bool gjs_lookup_object_constructor(JSContext             *context,
     486                 :             :                                    GType                  gtype,
     487                 :             :                                    JS::MutableHandleValue value_p);
     488                 :             : 
     489                 :             : void gjs_object_clear_toggles(void);
     490                 :             : void gjs_object_shutdown_toggle_queue(void);
     491                 :             : 
     492                 :             : #endif  // GI_OBJECT_H_
        

Generated by: LCOV version 2.0-1