Comment utiliser g_type_register_dynamic ?

**Gaulouis** · 19/12/2022, 20h27

Bonjour,

Je souhaiterais utiliser la fonction g_type_register_dynamic
La documentation de GTypePlugin m'est encore énigmatique.

Quelqu'un aurait-il un exemple s'il vous plaît ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 *      gcc main.c -o main `pkg-config --cflags --libs gobject-2.0`
 */
#include <gmodule.h>
 
int
main (int argc, char *argv[])
{
 
    GType parent_type = G_TYPE_OBJECT;
    const gchar *type_name = "My-Object";
    GTypePlugin *plugin;
    GTypeFlags flags;
 
    GType type = g_type_register_dynamic (parent_type, type_name,
                         plugin,
                         flags);
 
    GObject *object = g_object_new(type, NULL);
 
    return 0;
}

**gerald3d** · 20/12/2022, 10h25

Bonjour Gaulouis.

Jamais utilisé ce type de fonction mais il me semble que pour le flag il te faut spécifier une valeur :
https://docs.gtk.org/gobject/flags.TypeFlags.html

Je ne sais pas exactement ce que tu veux faire mais en général le GType est généré lors de la création d’un nouvel objet ou d’une nouvelle interface.

**Gaulouis** · 20/12/2022, 16h11

Merci pour ta rapide réponse.

J'ai pris en compte ton aide (G_TYPE_FLAG_NONE).

Si tu as déjà utilisé la macro G_DEFINE_TYPE alors tu as déjà utilisé g_type_register_static_simple

Je voudrais créer de nouveau types dynamiquement (pendant l’exécution de mon programme)

Voici ma tentative qui se solde par une Erreur de segmentation (core dumped)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/**
 *      gcc use_g_type_register_dynamic.c -o main `pkg-config --cflags --libs gobject-2.0`
 */
#include <gmodule.h>
#include <glib-object.h>
 
 
typedef struct _MyTypeModule {
    GTypeModule parent;
} MyTypeModule;
 
typedef struct _MyTypeModuleClass {
    GTypeModuleClass parent_class;
} MyTypeModuleClass;
 
#define MY_TYPE_TYPE_MODULE              (my_type_module_get_type ())
#define MY_TYPE_MODULE(module)           (G_TYPE_CHECK_INSTANCE_CAST ((module), MY_TYPE_TYPE_MODULE, MyTypeModule))
#define MY_TYPE_MODULE_CLASS(class)      (G_TYPE_CHECK_CLASS_CAST ((class), MY_TYPE_TYPE_MODULE, MyTypeModuleClass))
#define MY_IS_TYPE_MODULE(module)        (G_TYPE_CHECK_INSTANCE_TYPE ((module), MY_TYPE_TYPE_MODULE))
#define MY_IS_TYPE_MODULE_CLASS(class)   (G_TYPE_CHECK_CLASS_TYPE ((class), MY_TYPE_TYPE_MODULE))
#define MY_TYPE_MODULE_GET_CLASS(module) (G_TYPE_INSTANCE_GET_CLASS ((module), MY_TYPE_TYPE_MODULE, MyTypeModuleClass))
 
G_DEFINE_TYPE (MyTypeModule, my_type_module, G_TYPE_TYPE_MODULE)
 
static MyTypeModule *global_type_module;
 
MyTypeModule*
my_type_module_get ()
{
    if (global_type_module == NULL) {
        global_type_module = g_object_new (MY_TYPE_TYPE_MODULE, NULL);
    }
 
    return global_type_module;
}
 
static gboolean
my_type_module_load (GTypeModule *self)
{
    return TRUE;
}
 
static void
my_type_module_unload (GTypeModule *self)
{
    //g_assert_not_reached ();
}
 
static void
my_type_module_class_init (MyTypeModuleClass *klass)
{
    GTypeModuleClass *type_module_class;
 
    type_module_class = G_TYPE_MODULE_CLASS (klass);
    type_module_class->load = my_type_module_load;
    type_module_class->unload = my_type_module_unload;
}
 
static void
my_type_module_init (MyTypeModule *self)
{
    /* Prevent the use count from ever dropping to zero */
    g_type_module_use (G_TYPE_MODULE (self));
}
 
int
main (int argc, char *argv[])
{
 
    GType parent_type = G_TYPE_OBJECT;
    const gchar *type_name = "My-Object";
    MyTypeModule *module = my_type_module_get();
    GTypePlugin *plugin = G_TYPE_PLUGIN(module);
    GTypeFlags flags = G_TYPE_FLAG_NONE;
 
    GType type = g_type_register_dynamic (parent_type, type_name,
                         plugin,
                         flags);
 
    GObject *obj = g_object_new(type, NULL);
    //g_type_from_name                    (const gchar *name);
    g_print("name = %s\n", g_type_name(type));
 
    return 0;
}

Toute aide serai la bienvenue.

Post-Edit:

En attendant de trouver un exemple avec g_type_register_dynamic, voici un example qui fonctionne avec g_type_module_register_type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/**
 *      gcc use_g_type_register_dynamic.c -o main `pkg-config --cflags --libs gobject-2.0`
 */
#include <gmodule.h>
#include <glib-object.h>
 
 
typedef struct _MyTypeModule {
    GTypeModule parent;
} MyTypeModule;
 
typedef struct _MyTypeModuleClass {
    GTypeModuleClass parent_class;
} MyTypeModuleClass;
 
#define MY_TYPE_TYPE_MODULE              (my_type_module_get_type ())
#define MY_TYPE_MODULE(module)           (G_TYPE_CHECK_INSTANCE_CAST ((module), MY_TYPE_TYPE_MODULE, MyTypeModule))
#define MY_TYPE_MODULE_CLASS(class)      (G_TYPE_CHECK_CLASS_CAST ((class), MY_TYPE_TYPE_MODULE, MyTypeModuleClass))
#define MY_IS_TYPE_MODULE(module)        (G_TYPE_CHECK_INSTANCE_TYPE ((module), MY_TYPE_TYPE_MODULE))
#define MY_IS_TYPE_MODULE_CLASS(class)   (G_TYPE_CHECK_CLASS_TYPE ((class), MY_TYPE_TYPE_MODULE))
#define MY_TYPE_MODULE_GET_CLASS(module) (G_TYPE_INSTANCE_GET_CLASS ((module), MY_TYPE_TYPE_MODULE, MyTypeModuleClass))
 
G_DEFINE_TYPE (MyTypeModule, my_type_module, G_TYPE_TYPE_MODULE)
 
static MyTypeModule *global_type_module;
 
MyTypeModule*
my_type_module_get ()
{
    if (global_type_module == NULL) {
        global_type_module = g_object_new (MY_TYPE_TYPE_MODULE, NULL);
    }
 
    return global_type_module;
}
 
static gboolean
my_type_module_load (GTypeModule *self)
{
    return TRUE;
}
 
static void
my_type_module_unload (GTypeModule *self)
{
    //g_assert_not_reached ();
}
 
static void
my_type_module_class_init (MyTypeModuleClass *klass)
{
    GTypeModuleClass *type_module_class;
 
    type_module_class = G_TYPE_MODULE_CLASS (klass);
    type_module_class->load = my_type_module_load;
    type_module_class->unload = my_type_module_unload;
}
 
static void
my_type_module_init (MyTypeModule *self)
{
    /* Prevent the use count from ever dropping to zero */
    g_type_module_use (G_TYPE_MODULE (self));
}
 
 
static void
my_object_class_init(GObjectClass *class,
                      gpointer      user_data)
{
	g_print("Class init: %s -> install properties %s\n", g_type_name_from_class((GTypeClass*)class), (char*)user_data);
}
 
static const char *global_class_data = "hello";
 
int
main (int argc, char *argv[])
{
 
 
    GType parent_type = G_TYPE_OBJECT;
    const gchar *type_name = "My-Object";
    GTypeInfo type_info = {
        0, /* class_size */
 
	(GBaseInitFunc) NULL,
	(GBaseFinalizeFunc) NULL,
 
	(GClassInitFunc) my_object_class_init,
	(GClassFinalizeFunc) NULL,
	global_class_data,//NULL, /* class_data */
 
	0,    /* instance_size */
	0,    /* n_preallocs */
	(GInstanceInitFunc) NULL,
    };
    type_info.class_size = sizeof(GObjectClass);
    type_info.instance_size = sizeof(GObject);
 
    MyTypeModule *module = my_type_module_get();
 
    GTypeModule *plugin = G_TYPE_MODULE(module);
    GTypeFlags flags = 0;//G_TYPE_FLAG_NONE;
 
    GType type = g_type_module_register_type (plugin,
                             parent_type,
                             type_name,
                             &type_info,
                             flags);
 
 
 
    const gchar *name = "My-Object";
    GType t = g_type_from_name(name);
    GObject *obj = g_object_new(type, NULL);
        g_print("name = %s\n", g_type_name_from_instance((GTypeInstance*)obj));
    g_object_unref(obj);
 
    return 0;
}

**gerald3d** · 20/12/2022, 19h00

Bon, j'ai commencé à décortiquer ton code. Comme il semble que la manière de construire un type est la même que celle pour construire un GObject voila le debut de ton code remanié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <gtk/gtk.h>
 
#include <gmodule.h>
#include <glib-object.h>
 
typedef struct _MyTypeModule {
    GTypeModule parent;
} MyTypeModule;
 
typedef struct _MyTypeModuleClass {
    GTypeModuleClass parent_class;
} MyTypeModuleClass;
 
#define MY_TYPE_MODULE              (my_type_module_get_type ())
 
G_DEFINE_TYPE (MyTypeModule, my_type_module, MY_TYPE_MODULE)

G_DEFINE_TYPE() crée pour toi toutes les macros nécessaires.

Le problème sur lequel je bloque maintenant est d'obtenir un GTypePlugin. Ta manière de procéder ne me semble pas la bonne.

Il faut que je creuse la question...

**Gaulouis** · 20/12/2022, 21h21

Merci pour le temps que tu prend pour résoudre mon problème.

Je crois qu'il faut aussi utiliser G_DECLARE_DERIVABLE_TYPE, un peu comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <gmodule.h>
#include <glib-object.h>
 
struct _MyTypeModule {
    GTypeModule parent;
};
 
struct _MyTypeModuleClass {
    GTypeModuleClass parent_class;
};
 
G_DECLARE_DERIVABLE_TYPE(MyTypeModule, my_type_module, MY, TYPE_MODULE, GTypeModule)
 
G_DEFINE_TYPE (MyTypeModule, my_type_module, G_TYPE_MODULE)
 
static void
my_type_module_class_init (MyTypeModuleClass *klass) { ??? }
 
static void
my_type_module_init (MyTypeModule *self){ ??? }

un GTypePlugin. Ta manière de procéder ne me semble pas la bonne.

Je vais continuer de creuser dans ce sens.

Dans la documentation de g_type_register_dynamic(GType parent_type, const gchar *type_name, GTypePlugin *plugin, GTypeFlags flags) un paramètre est

plugin GTypePlugin structure to retrieve the GTypeInfo from

Pour moi GTypeModule est abstrait et je dois fournir une implémentation.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

GObject *plugin = g_object_new(G_TYPE_TYPE_MODULE, NULL);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

GLib-GObject-ERROR **: 21:03:02.138: cannot create instance of abstract (non-instantiatable) type 'GTypeModule'

Je ne sais toujours pas comment obtenir ce fameux GTypeInfo...

**gerald3d** · 20/12/2022, 22h56

Voila le code source et le fichier d'entête d'une première déclaration d'un nouveau type. Mais ce type n'est pas encore reconnu comme étant un GtypePlugin ou un GtypeModule.

fichier mymodule.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/* MyModule
   A subclass of GtkDrawingArea to create a thumbnail with menu.
   (C) <2016>  <Gérald Dumas> <gerald.dumas@laposte.net>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
*/
 
 
#ifndef __MY_MODULE_H__
#define __MY_MODULE_H__
 
#include <glib-object.h>
 
G_BEGIN_DECLS
 
G_DECLARE_FINAL_TYPE (MyModule, my_module, MY, MODULE, GTypeModule)
typedef struct _MyModule MyModule;
 
#define MY_TYPE_MODULE (my_module_get_type ())
 
struct _MyModule {
  GTypeModule parent;
};
 
struct _MyModuleClass {
   GTypeModuleClass parent_class;
};
 
GType my_module_new (const gchar *type_name);
 
G_END_DECLS
 
 
#endif

fichier mymodule.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include "mymodule.h"
 
 
 
static void my_module_class_init (MyModuleClass *klass);
static void my_module_init (MyModule *self);
static gboolean my_type_module_load (GTypeModule *self);
static void my_type_module_unload (GTypeModule *self);
 
/* GType G_TYPE_MODULE = G_OBJECT_TYPE (GTypeModule); */
G_DEFINE_TYPE (MyModule, my_module, G_TYPE_TYPE_MODULE)
 
static GObject *object;
 
static void
my_module_class_init (MyModuleClass *klass)
{g_printerr ("Enter in %s\n", __func__);
  GTypeModuleClass *type_module_class;
 
  type_module_class = G_TYPE_MODULE_CLASS (klass);
  type_module_class->load = my_type_module_load;
  type_module_class->unload = my_type_module_unload;
}
 
static void
my_module_init (MyModule *self)
{g_print ("Enter in %s\n", __func__);
 /* Prevent the use count from ever dropping to zero */
  g_type_module_use (G_TYPE_MODULE (self));
}
 
static gboolean
my_type_module_load (GTypeModule *self)
{g_print ("Enter in %s\n", __func__);
  return TRUE;
}
 
static void
my_type_module_unload (GTypeModule *self)
{g_print ("Enter in %s\n", __func__);
    //g_assert_not_reached ();
}
 
 
 
/******************************************************************************/
 
GType
my_module_new (const gchar *type_name)
{
  if (!type_name) return G_TYPE_INVALID;
 
  object = g_object_new (MY_TYPE_MODULE, NULL);
 
  if (G_IS_OBJECT (object))
    g_type_module_set_name (G_TYPE_MODULE (object), type_name);
 
  return G_OBJECT_TYPE (object);
}

Le main.c exemple qui va avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <gtk/gtk.h>
#include "mymodule.h"
 
 
int main(int argc, char *argv[])
{
  GType type = my_module_new ("My-Object");
 
  g_print ("type name = %s\n", g_type_name (type));
 
  if (G_IS_TYPE_PLUGIN (g_type_get_plugin (type)))
    g_print ("type is a GTypePlugin\n");
 
  if (G_IS_TYPE_MODULE (g_type_get_plugin (type)))
    g_print ("type is a GTypeModule\n");
  /* g_print ("human type name : %s\n", G_TYPE_MODULE (g_type_get_plugin (type))->name); */
 
  return 0 ;
}

Ca compile et s'exécute mais est-ce fonctionnel, je ne le crois pas encore.

**Gaulouis** · 24/12/2022, 12h28

J'ai trouvé ma réponse ici :
https://github.com/GNOME/glib/blob/m...emodule.c#L436

Comment utiliser g_type_register_dynamic ?

GTK+

Discussions similaires

Partager

Partager