summaryrefslogtreecommitdiff
path: root/plugins/pychrysalide
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/pychrysalide')
-rw-r--r--plugins/pychrysalide/analysis/content.c31
-rw-r--r--plugins/pychrysalide/analysis/content.h3
-rw-r--r--plugins/pychrysalide/format/symbol.c1
-rw-r--r--plugins/pychrysalide/glibext/buffercache.c947
-rw-r--r--plugins/pychrysalide/glibext/buffercache.h3
-rw-r--r--plugins/pychrysalide/glibext/bufferline.c24
-rw-r--r--plugins/pychrysalide/glibext/constants.c100
-rw-r--r--plugins/pychrysalide/glibext/constants.h6
-rw-r--r--plugins/pychrysalide/glibext/linegen.c734
-rw-r--r--plugins/pychrysalide/glibext/linegen.h3
-rw-r--r--plugins/pychrysalide/helpers.c45
-rw-r--r--plugins/pychrysalide/helpers.h5
12 files changed, 1729 insertions, 173 deletions
diff --git a/plugins/pychrysalide/analysis/content.c b/plugins/pychrysalide/analysis/content.c
index a0eb11c..8a404ed 100644
--- a/plugins/pychrysalide/analysis/content.c
+++ b/plugins/pychrysalide/analysis/content.c
@@ -813,3 +813,34 @@ int convert_to_binary_content(PyObject *arg, void *dst)
return result;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : arg = argument quelconque à tenter de convertir. *
+* dst = destination des valeurs récupérées en cas de succès. *
+* *
+* Description : Tente de convertir en contenu binaire ou NULL. *
+* *
+* Retour : Bilan de l'opération, voire indications supplémentaires. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+int convert_to_binary_content_or_none(PyObject *arg, void *dst)
+{
+ int result; /* Bilan à retourner */
+
+ if (arg == Py_None)
+ {
+ *((GBinContent **)dst) = NULL;
+ result = 1;
+ }
+
+ else
+ result = convert_to_binary_content(arg, dst);
+
+ return result;
+
+}
diff --git a/plugins/pychrysalide/analysis/content.h b/plugins/pychrysalide/analysis/content.h
index e56e29f..fab6b1b 100644
--- a/plugins/pychrysalide/analysis/content.h
+++ b/plugins/pychrysalide/analysis/content.h
@@ -40,6 +40,9 @@ bool ensure_python_binary_content_is_registered(void);
/* Tente de convertir en contenu binaire. */
int convert_to_binary_content(PyObject *, void *);
+/* Tente de convertir en contenu binaire ou NULL. */
+int convert_to_binary_content_or_none(PyObject *, void *);
+
#endif /* _PLUGINS_PYCHRYSALIDE_ANALYSIS_CONTENT_H */
diff --git a/plugins/pychrysalide/format/symbol.c b/plugins/pychrysalide/format/symbol.c
index 6f1c1d2..71832cb 100644
--- a/plugins/pychrysalide/format/symbol.c
+++ b/plugins/pychrysalide/format/symbol.c
@@ -306,6 +306,7 @@ static int py_binary_symbol_init(PyObject *self, PyObject *args, PyObject *kwds)
}
+
/* ---------------------------------------------------------------------------------- */
/* FONCTIONNALITES BASIQUES POUR SYMBOLES */
/* ---------------------------------------------------------------------------------- */
diff --git a/plugins/pychrysalide/glibext/buffercache.c b/plugins/pychrysalide/glibext/buffercache.c
index 9ce06c1..fec5844 100644
--- a/plugins/pychrysalide/glibext/buffercache.c
+++ b/plugins/pychrysalide/glibext/buffercache.c
@@ -28,63 +28,897 @@
#include <pygobject.h>
-#include <glibext/gbuffercache.h>
+#include <glibext/gbuffercache-int.h>
+#include <plugins/dt.h>
+#include "constants.h"
+#include "bufferline.h"
+#include "linegen.h"
#include "../access.h"
#include "../helpers.h"
-#include "../arch/vmpa.h"
+#include "../analysis/content.h"
-#if 0
-/* Retrouve une ligne au sein d'un tampon avec une adresse. */
-static PyObject *py_code_buffer_find_line_by_addr(PyObject *, PyObject *);
+/* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */
+/* Accompagne la création d'une instance dérivée en Python. */
+static PyObject *py_buffer_cache_new(PyTypeObject *, PyObject *, PyObject *);
+
+/* Initialise une instance sur la base du dérivé de GObject. */
+static int py_buffer_cache_init(PyObject *, PyObject *, PyObject *);
+
+
+
+/* -------------------------- TAMPON POUR CODE DESASSEMBLE -------------------------- */
+
+
+/* Insère un générateur dans des lignes à une position donnée. */
+static PyObject *py_buffer_cache_insert_at(PyObject *, PyObject *);
+
+/* Retire une ligne du tampon. */
+static PyObject *py_buffer_cache_delete_at(PyObject *, PyObject *);
+
+/* Retire un type de générateur de lignes. */
+static PyObject *py_buffer_cache_delete_type_at(PyObject *, PyObject *);
+
+/* Ajoute en fin de tampon un générateur de lignes. */
+static PyObject *py_buffer_cache_append(PyObject *, PyObject *);
+
+/* Etend un tampon avec un générateur de lignes unique. */
+static PyObject *py_buffer_cache_extend_with(PyObject *, PyObject *);
+
+/* Réduit le tampon à une quantité de lignes précise. */
+static PyObject *py_buffer_cache_truncate(PyObject *, PyObject *);
+
+/* Détermine l'ensemble des propriétés attachées à une ligne. */
+static PyObject *py_buffer_cache_get_line_flags(PyObject *, PyObject *);
+
+/* Retrouve une ligne au sein d'un tampon avec un indice. */
+static PyObject *py_buffer_cache_find_line_by_index(PyObject *, PyObject *);
+
+/* Avance autant que possible vers une ligne idéale. */
+static PyObject *py_buffer_cache_look_for_flag(PyObject *, PyObject *);
+
+/* Indique l'éventuel contenu binaire associé au cache. */
+static PyObject *py_buffer_cache_get_content(PyObject *, void *);
+
+/* Fournit la hauteur d'impression d'une ligne visualisée. */
+static PyObject *py_buffer_cache_get_line_height(PyObject *, void *);
+
+/* Fournit la taille réservée pour la marge gauche. */
+static PyObject *py_buffer_cache_get_left_margin(PyObject *, void *);
+
+/* Fournit la position de départ pour l'impression de texte. */
+static PyObject *py_buffer_cache_get_text_position(PyObject *, void *);
+
+/* Compte le nombre de lignes rassemblées dans un tampon. */
+static PyObject *py_buffer_cache_get_lines_count(PyObject *, void *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* GLUE POUR CREATION DEPUIS PYTHON */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type du nouvel objet à mettre en place. *
+* args = éventuelle liste d'arguments. *
+* kwds = éventuel dictionnaire de valeurs mises à disposition. *
+* *
+* Description : Accompagne la création d'une instance dérivée en Python. *
+* *
+* Retour : Nouvel objet Python mis en place ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+ PyObject *result; /* Objet à retourner */
+ PyTypeObject *base; /* Type de base à dériver */
+ bool first_time; /* Evite les multiples passages*/
+ GType gtype; /* Nouveau type de processeur */
+ bool status; /* Bilan d'un enregistrement */
+
+ /* Validations diverses */
+
+ base = get_python_buffer_cache_type();
+
+ if (type == base)
+ goto simple_way;
+
+ /* Mise en place d'un type dédié */
+
+ first_time = (g_type_from_name(type->tp_name) == 0);
+
+ gtype = build_dynamic_type(G_TYPE_BUFFER_CACHE, type->tp_name, NULL, NULL, NULL);
+
+ if (first_time)
+ {
+ status = register_class_for_dynamic_pygobject(gtype, type, base);
+
+ if (!status)
+ {
+ result = NULL;
+ goto exit;
+ }
+
+ }
+
+ /* On crée, et on laisse ensuite la main à PyGObject_Type.tp_init() */
+
+ simple_way:
+
+ result = PyType_GenericNew(type, args, kwds);
+
+ exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet à initialiser (théoriquement). *
+* args = arguments fournis à l'appel. *
+* kwds = arguments de type key=val fournis. *
+* *
+* Description : Initialise une instance sur la base du dérivé de GObject. *
+* *
+* Retour : 0. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static int py_buffer_cache_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+ GBinContent *content; /* Instance GLib du contenu */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Version GLib du tampon */
+
+#define BUFFER_CACHE_DOC \
+ "The BufferCache object manages a group of lines intended to get" \
+ " printed onto the screen or into a file.\n" \
+ "\n" \
+ "These lines are cached and rebuilt when needed.\n" \
+ "\n" \
+ "Instances can be created using the following constructor:\n" \
+ "\n" \
+ " BufferCache(content=None)" \
+ "\n" \
+ "Where content is a pychrysalide.analysis.BinContent instance, if" \
+ " defined. This content is provided to lines as argument when the" \
+ " lines get printed, so it may not be always useful and thus can be" \
+ " discarded when creating a new buffer cache." \
+
+ /* Récupération des paramètres */
+
+ content = NULL;
+
+ ret = PyArg_ParseTuple(args, "|O&", convert_to_binary_content_or_none, &content);
+ if (!ret) return -1;
+
+ /* Initialisation d'un objet GLib */
+
+ ret = forward_pygobjet_init(self);
+ if (ret == -1) return -1;
+
+ /* Eléments de base */
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ if (content != NULL)
+ {
+ cache->content = content;
+ g_object_ref(G_OBJECT(content));
+ }
+
+ return 0;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* TAMPON POUR CODE DESASSEMBLE */
+/* ---------------------------------------------------------------------------------- */
+
/******************************************************************************
* *
* Paramètres : self = classe représentant un tampon de code. *
* args = arguments fournis à l'appel. *
* *
-* Description : Retrouve une ligne au sein d'un tampon avec une adresse. *
+* Description : Insère un générateur dans des lignes à une position donnée. *
* *
-* Retour : Instance de la ligne trouvée. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-static PyObject *py_code_buffer_find_line_by_addr(PyObject *self, PyObject *args)
+static PyObject *py_buffer_cache_insert_at(PyObject *self, PyObject *args)
{
PyObject *result; /* Trouvailles à retourner */
- PyObject *py_vmpa; /* Localisation version Python */
+ size_t index; /* Indice de ligne à supprimer */
+ GLineGenerator *generator; /* Générateur à associer */
+ BufferLineFlags flags; /* Particularités nominales */
+ int before; /* Insertion avant ? */
+ int after; /* Insertion après ? */
int ret; /* Bilan de lecture des args. */
- vmpa2t *addr; /* Adresse visée par l'opérat° */
- GBuffercache *buffer; /* Version native */
- GBufferLine *line; /* Ligne trouvée */
+ GBufferCache *cache; /* Tampon natif à consulter */
+
+#define BUFFER_CACHE_INSERT_AT_METHOD PYTHON_METHOD_DEF \
+( \
+ insert_at, "$self, index, generator, /, flags=" \
+ "pychrysalide.glibext.BufferLine.BufferLineFlags.NONE," \
+ " before=False, after=False", \
+ METH_VARARGS, py_buffer_cache, \
+ "Add an extra content generator to a given line.\n" \
+ "\n" \
+ "The new content generator for the line at, before or after" \
+ " the provided index is a pychrysalide.glibext.LineGenerator" \
+ " instance. Nominal properties can be set for this line as" \
+ " extra pychrysalide.glibext.BufferLine.BufferLineFlags" \
+ " values.\n" \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
- ret = PyArg_ParseTuple(args, "O", &py_vmpa);
+ flags = BLF_NONE;
+ before = 0;
+ after = 0;
+
+ ret = PyArg_ParseTuple(args, "nO&|O&pp", &index, convert_to_line_generator, &generator,
+ convert_to_buffer_line_flags, &flags, &before, &after);
if (!ret) return NULL;
- ret = PyObject_IsInstance(py_vmpa, (PyObject *)get_python_vmpa_type());
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ g_buffer_cache_insert_at(cache, index, generator, flags, before, after);
+
+ result = Py_None;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Retire une ligne du tampon. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_delete_at(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ size_t index; /* Indice de ligne à supprimer */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Tampon natif à consulter */
+
+#define BUFFER_CACHE_DELETE_AT_METHOD PYTHON_METHOD_DEF \
+( \
+ delete_at, "$self, index, /", \
+ METH_VARARGS, py_buffer_cache, \
+ "Delete the line at the *index* position from a buffer cache.\n" \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ ret = PyArg_ParseTuple(args, "n", &index);
if (!ret) return NULL;
- addr = get_internal_vmpa(py_vmpa);
- if (addr == NULL) return NULL;
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ g_buffer_cache_delete_at(cache, index);
+
+ result = Py_None;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Retire un type de générateur de lignes. *
+* *
+* Retour : Générateur éventuellement trouvé ou NULL si aucun. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_delete_type_at(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ size_t index; /* Indice de ligne à supprimer */
+ PyObject *py_gtype; /* Version Python d'un GType */
+ int before; /* Insertion avant ? */
+ int after; /* Insertion après ? */
+ int ret; /* Bilan de lecture des args. */
+ GType gtype; /* Type de générateur visé */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ GLineGenerator *generator; /* Générateur retiré ou NULL */
+
+#define BUFFER_CACHE_DELETE_TYPE_AT_METHOD PYTHON_METHOD_DEF \
+( \
+ delete_type_at, "$self, index, gtype, /, before=False, after=False", \
+ METH_VARARGS, py_buffer_cache, \
+ "Delete the first generator of a given type found inside a line of a" \
+ " buffer cache.\n" \
+ "\n" \
+ "The target type has to be a gobject.GType, usually provided by the" \
+ " *__gtype__* attribute of a generator interface. The generator is" \
+ " deleted from the line at, before or after the provided index.\n" \
+ "\n" \
+ "The function returns the deleted generator as a" \
+ " pychrysalide.glibext.LineGenerator instance, or None if none found.\n"\
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ before = 0;
+ after = 0;
+
+ ret = PyArg_ParseTuple(args, "nO|pp", &index, &py_gtype, &before, &after);
+ if (!ret) return NULL;
- buffer = G_CODE_BUFFER(pygobject_get(self));
+ gtype = pyg_type_from_object(py_gtype);
+ if (gtype == 0) return NULL;
- line = g_code_buffer_find_line_by_addr(buffer, addr, 0, NULL);
- if (line == NULL) Py_RETURN_NONE;
+ cache = G_BUFFER_CACHE(pygobject_get(self));
- result = pygobject_new(G_OBJECT(line));
+ generator = g_buffer_cache_delete_type_at(cache, index, gtype, before, after);
+
+ if (generator != NULL)
+ {
+ result = pygobject_new(G_OBJECT(generator));
+ g_object_unref(G_OBJECT(generator));
+ }
+
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Ajoute en fin de tampon un générateur de lignes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_append(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ GLineGenerator *generator; /* Générateur à associer */
+ BufferLineFlags flags; /* Particularités nominales */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Tampon natif à consulter */
+
+#define BUFFER_CACHE_APPEND_METHOD PYTHON_METHOD_DEF \
+( \
+ append, "$self, generator, /, flags=" \
+ "pychrysalide.glibext.BufferLine.BufferLineFlags.NONE", \
+ METH_VARARGS, py_buffer_cache, \
+ "Append a new line at the end of a buffer cache.\n" \
+ "\n" \
+ "The content generator for this new line is a" \
+ " pychrysalide.glibext.LineGenerator instance. Nominal" \
+ " properties can be set for the line as extra" \
+ " pychrysalide.glibext.BufferLine.BufferLineFlags values.\n" \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ flags = BLF_NONE;
+
+ ret = PyArg_ParseTuple(args, "O&|O&", convert_to_line_generator, &generator,
+ convert_to_buffer_line_flags, &flags);
+ if (!ret) return NULL;
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ g_buffer_cache_append(cache, generator, flags);
+
+ result = Py_None;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Etend un tampon avec un générateur de lignes unique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_extend_with(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ size_t count; /* Quantité de lignes à créer */
+ GLineGenerator *generator; /* Générateur à associer */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Tampon natif à consulter */
+
+#define BUFFER_CACHE_EXTEND_WITH_METHOD PYTHON_METHOD_DEF \
+( \
+ extend_with, "$self, count, generator, /", \
+ METH_VARARGS, py_buffer_cache, \
+ "Extend the buffer cache so it will contain *count* lines.\n" \
+ "\n" \
+ "The *count* number should be greater than the current line" \
+ " quantity, otherwise the call makes no sense. The generator" \
+ " is a pychrysalide.glibext.LineGenerator instance used to" \
+ " produce the extra new lines on demand." \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ ret = PyArg_ParseTuple(args, "nO&", &count, convert_to_line_generator, &generator);
+ if (!ret) return NULL;
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ g_buffer_cache_extend_with(cache, count, generator);
+
+ result = Py_None;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Réduit le tampon à une quantité de lignes précise. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_truncate(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ size_t max; /* Nombre de lignes au maximum */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Tampon natif à consulter */
+
+#define BUFFER_CACHE_TRUNCATE_METHOD PYTHON_METHOD_DEF \
+( \
+ truncate, "$self, max, /", \
+ METH_VARARGS, py_buffer_cache, \
+ "Shrink the buffer cache so it will contain at most *max* lines.\n" \
+ "\n" \
+ "The *max* number should be lesser than the current line quantity," \
+ " otherwise no effect will happen." \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ ret = PyArg_ParseTuple(args, "n", &max);
+ if (!ret) return NULL;
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ g_buffer_cache_truncate(cache, max);
+
+ result = Py_None;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Détermine l'ensemble des propriétés attachées à une ligne. *
+* *
+* Retour : Somme de toutes les propriétés enregistrées. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_get_line_flags(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ size_t index; /* Indice de la ligne visée */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ BufferLineFlags flags; /* Fanions conservés */
+
+#define BUFFER_CACHE_GET_LINE_FLAGS_METHOD PYTHON_METHOD_DEF \
+( \
+ get_line_flags, "$self, index, /", \
+ METH_VARARGS, py_buffer_cache, \
+ "Provide the optional flags assigned to a given buffer line. The" \
+ " line is located using the *index* argument.\n" \
+ "\n" \
+ "The result is a pychrysalide.glibext.BufferLine.BufferLineFlags" \
+ " value.\n" \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ ret = PyArg_ParseTuple(args, "n", &index);
+ if (!ret) return NULL;
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ flags = g_buffer_cache_get_line_flags(cache, index);
+
+ result = cast_with_constants_group_from_type(get_python_buffer_line_type(), "BufferLineFlags", flags);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Retrouve une ligne au sein d'un tampon avec un indice. *
+* *
+* Retour : Line retrouvée ou None en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_find_line_by_index(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ size_t index; /* Indice de la ligne visée */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ GBufferLine *line; /* Ligne trouvée ? */
+
+#define BUFFER_CACHE_FIND_LINE_BY_INDEX_METHOD PYTHON_METHOD_DEF \
+( \
+ find_line_by_index, "$self, index, /", \
+ METH_VARARGS, py_buffer_cache, \
+ "Retrieve the line contained in a buffer cache at a given index.\n" \
+ "\n" \
+ "The result is a pychrysalide.glibext.BufferLine instance or" \
+ " None.\n" \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ ret = PyArg_ParseTuple(args, "n", &index);
+ if (!ret) return NULL;
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ line = g_buffer_cache_find_line_by_index(cache, index);
+
+ if (line != NULL)
+ {
+ result = pygobject_new(G_OBJECT(line));
+ g_object_unref(G_OBJECT(line));
+ }
+
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un tampon de code. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Avance autant que possible vers une ligne idéale. *
+* *
+* Retour : Indice de la ligne recherchée, si elle existe. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_look_for_flag(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ size_t index; /* Indice de la ligne visée */
+ BufferLineFlags flag; /* Particularité à retrouver */
+ int ret; /* Bilan de lecture des args. */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ size_t found; /* Indice de la ligne trouvée */
+
+#define BUFFER_CACHE_LOOK_FOR_FLAG_METHOD PYTHON_METHOD_DEF \
+( \
+ look_for_flag, "$self, index, flag, /", \
+ METH_VARARGS, py_buffer_cache, \
+ "Iterate the buffer cache lines from a starting index until a" \
+ " line with flags matching the provided flag is met.\n" \
+ "\n" \
+ "The *flag* argument has to be a" \
+ " pychrysalide.glibext.BufferLine.BufferLineFlags value.\n" \
+ "\n" \
+ "The result is an index equal or greater than the starting index" \
+ " or, if no match is found, the number of lines in the buffer" \
+ " cache.\n" \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ ret = PyArg_ParseTuple(args, "nO&", &index, convert_to_buffer_line_flags, &flag);
+ if (!ret) return NULL;
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ found = g_buffer_cache_look_for_flag(cache, index, flag);
+
+ result = PyLong_FromSize_t(found);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Indique l'éventuel contenu binaire associé au cache. *
+* *
+* Retour : Eventuel contenu renseigné ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_get_content(PyObject *self, void *closure)
+{
+ PyObject *result; /* Contenu binaire à retourner */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ GBinContent *content; /* Contenu éventuel à renvoyer */
+
+#define BUFFER_CACHE_CONTENT_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ content, py_buffer_cache, \
+ "Binary content linked to the buffer cache, as a" \
+ " pychrysalide.analysis.BinContent instance, or None." \
+)
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ content = g_buffer_cache_get_content(cache);
+
+ if (content != NULL)
+ {
+ result = pygobject_new(G_OBJECT(content));
+ g_object_unref(G_OBJECT(content));
+ }
+
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit la hauteur d'impression d'une ligne visualisée. *
+* *
+* Retour : Hauteur de ligne en pixels. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_get_line_height(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ gint height; /* Valeur obtenue du cache */
+
+#define BUFFER_CACHE_LINE_HEIGHT_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ line_height, py_buffer_cache, \
+ "Height of a line printed from the buffer cache." \
+)
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ height = g_buffer_cache_get_line_height(cache);
+
+ result = PyLong_FromLong(height);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit la taille réservée pour la marge gauche. *
+* *
+* Retour : Largeur en pixels. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_get_left_margin(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ gint width; /* Valeur obtenue du cache */
+
+#define BUFFER_CACHE_LEFT_MARGIN_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ left_margin, py_buffer_cache, \
+ "Width of the left margin inside of a buffer cache output." \
+)
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ width = g_buffer_cache_get_left_margin(cache);
+
+ result = PyLong_FromLong(width);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit la position de départ pour l'impression de texte. *
+* *
+* Retour : Position en pixels. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_get_text_position(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ gint pos; /* Valeur obtenue du cache */
+
+#define BUFFER_CACHE_TEXT_POSITION_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ text_position, py_buffer_cache, \
+ "Starting position of the text on the left of a buffer cache output." \
+)
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ pos = g_buffer_cache_get_text_position(cache);
+
+ result = PyLong_FromLong(pos);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Compte le nombre de lignes rassemblées dans un tampon. *
+* *
+* Retour : Nombre de lignes constituant le tampon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_buffer_cache_get_lines_count(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBufferCache *cache; /* Tampon natif à consulter */
+ size_t count; /* Décompte de première main */
+
+#define BUFFER_CACHE_LINES_COUNT_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ lines_count, py_buffer_cache, \
+ "Count the number of lines contained in a buffer cache.\n" \
+ "\n" \
+ "An access lock has to be held for the cache; see the" \
+ " pychrysalide.glibext.BufferCache.lock() function." \
+)
+
+ cache = G_BUFFER_CACHE(pygobject_get(self));
+
+ count = g_buffer_cache_count_lines(cache);
+
+ result = PyLong_FromSize_t(count);
return result;
}
-#endif
/******************************************************************************
@@ -102,17 +936,24 @@ static PyObject *py_code_buffer_find_line_by_addr(PyObject *self, PyObject *args
PyTypeObject *get_python_buffer_cache_type(void)
{
static PyMethodDef py_buffer_cache_methods[] = {
-#if 0
- {
- "find_line_by_addr", py_buffer_cache_find_line_by_addr,
- METH_VARARGS,
- "find_line_by_addr($self, addr, /)\n--\n\nFind a buffer line with a given address."
- },
-#endif
+ BUFFER_CACHE_INSERT_AT_METHOD,
+ BUFFER_CACHE_DELETE_AT_METHOD,
+ BUFFER_CACHE_DELETE_TYPE_AT_METHOD,
+ BUFFER_CACHE_APPEND_METHOD,
+ BUFFER_CACHE_EXTEND_WITH_METHOD,
+ BUFFER_CACHE_TRUNCATE_METHOD,
+ BUFFER_CACHE_GET_LINE_FLAGS_METHOD,
+ BUFFER_CACHE_FIND_LINE_BY_INDEX_METHOD,
+ BUFFER_CACHE_LOOK_FOR_FLAG_METHOD,
{ NULL }
};
static PyGetSetDef py_buffer_cache_getseters[] = {
+ BUFFER_CACHE_CONTENT_ATTRIB,
+ BUFFER_CACHE_LINE_HEIGHT_ATTRIB,
+ BUFFER_CACHE_LEFT_MARGIN_ATTRIB,
+ BUFFER_CACHE_TEXT_POSITION_ATTRIB,
+ BUFFER_CACHE_LINES_COUNT_ATTRIB,
{ NULL }
};
@@ -125,11 +966,14 @@ PyTypeObject *get_python_buffer_cache_type(void)
.tp_flags = Py_TPFLAGS_DEFAULT,
- .tp_doc = "PyChrysalide code buffer",
+ .tp_doc = BUFFER_CACHE_DOC,
.tp_methods = py_buffer_cache_methods,
.tp_getset = py_buffer_cache_getseters,
+ .tp_init = py_buffer_cache_init,
+ .tp_new = py_buffer_cache_new
+
};
return &py_buffer_cache_type;
@@ -171,3 +1015,48 @@ bool ensure_python_buffer_cache_is_registered(void)
return true;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : arg = argument quelconque à tenter de convertir. *
+* dst = destination des valeurs récupérées en cas de succès. *
+* *
+* Description : Tente de convertir en tampon de lignes. *
+* *
+* Retour : Bilan de l'opération, voire indications supplémentaires. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+int convert_to_buffer_cache(PyObject *arg, void *dst)
+{
+ int result; /* Bilan à retourner */
+
+ result = PyObject_IsInstance(arg, (PyObject *)get_python_buffer_cache_type());
+
+ switch (result)
+ {
+ case -1:
+ /* L'exception est déjà fixée par Python */
+ result = 0;
+ break;
+
+ case 0:
+ PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to buffer cache");
+ break;
+
+ case 1:
+ *((GBufferCache **)dst) = G_BUFFER_CACHE(pygobject_get(arg));
+ break;
+
+ default:
+ assert(false);
+ break;
+
+ }
+
+ return result;
+
+}
diff --git a/plugins/pychrysalide/glibext/buffercache.h b/plugins/pychrysalide/glibext/buffercache.h
index 3135e22..1908434 100644
--- a/plugins/pychrysalide/glibext/buffercache.h
+++ b/plugins/pychrysalide/glibext/buffercache.h
@@ -37,6 +37,9 @@ PyTypeObject *get_python_buffer_cache_type(void);
/* Prend en charge l'objet 'pychrysalide.glibext.BufferCache'. */
bool ensure_python_buffer_cache_is_registered(void);
+/* Tente de convertir en tampon de lignes. */
+int convert_to_buffer_cache(PyObject *, void *);
+
#endif /* _PLUGINS_PYCHRYSALIDE_GLIBEXT_BUFFERCACHE_H */
diff --git a/plugins/pychrysalide/glibext/bufferline.c b/plugins/pychrysalide/glibext/bufferline.c
index 47b2bc4..af3cf1d 100644
--- a/plugins/pychrysalide/glibext/bufferline.c
+++ b/plugins/pychrysalide/glibext/bufferline.c
@@ -155,7 +155,7 @@ static PyObject *py_buffer_line_new(PyTypeObject *type, PyObject *args, PyObject
static PyObject *py_buffer_line_append_text(PyObject *self, PyObject *args)
{
PyObject *result; /* Trouvailles à retourner */
- unsigned long column; /* Indice de colonne */
+ size_t column; /* Indice de colonne */
const char *text; /* Texte à ajouter */
RenderingTagType type; /* Type de rendu attendu */
GObject *creator; /* Eventuel créateur à associer*/
@@ -177,7 +177,7 @@ static PyObject *py_buffer_line_append_text(PyObject *self, PyObject *args)
creator = NULL;
- ret = PyArg_ParseTuple(args, "ksO&|O&", &column, &text,
+ ret = PyArg_ParseTuple(args, "nsO&|O&", &column, &text,
convert_to_rendering_tag_type, &type, convert_to_gobject, &creator);
if (!ret) return NULL;
@@ -228,9 +228,17 @@ static PyObject *py_buffer_line_get_text(PyObject *self, PyObject *args)
line = G_BUFFER_LINE(pygobject_get(self));
text = g_buffer_line_get_text(line, first, end, markup);
- result = PyUnicode_FromString(text);
+ if (text != NULL)
+ {
+ result = PyUnicode_FromString(text);
+ free(text);
+ }
- free(text);
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
return result;
@@ -398,11 +406,6 @@ static bool py_buffer_line_define_constants(PyTypeObject *obj_type)
result &= PyDict_AddULongMacro(obj_type, BLC_FIRST);
result &= PyDict_AddULongMacro(obj_type, BLC_DISPLAY);
- result &= PyDict_AddULongMacro(obj_type, BLF_NONE);
- result &= PyDict_AddULongMacro(obj_type, BLF_HAS_CODE);
- result &= PyDict_AddULongMacro(obj_type, BLF_ENTRYPOINT);
- result &= PyDict_AddULongMacro(obj_type, BLF_BOOKMARK);
-
return result;
}
@@ -509,6 +512,9 @@ bool ensure_python_buffer_line_is_registered(void)
if (!define_line_segment_constants(type))
return false;
+ if (!define_buffer_line_constants(type))
+ return false;
+
if (!py_buffer_line_define_constants(type))
return false;
diff --git a/plugins/pychrysalide/glibext/constants.c b/plugins/pychrysalide/glibext/constants.c
index d18e051..823465a 100644
--- a/plugins/pychrysalide/glibext/constants.c
+++ b/plugins/pychrysalide/glibext/constants.c
@@ -26,6 +26,7 @@
#include <glibext/linesegment.h>
+#include <glibext/gbufferline.h>
#include "../helpers.h"
@@ -140,3 +141,102 @@ int convert_to_rendering_tag_type(PyObject *arg, void *dst)
return result;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type dont le dictionnaire est à compléter. *
+* *
+* Description : Définit les constantes relatives aux lignes de tampon. *
+* *
+* Retour : true en cas de succès de l'opération, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool define_buffer_line_constants(PyTypeObject *type)
+{
+ bool result; /* Bilan à retourner */
+ PyObject *values; /* Groupe de valeurs à établir */
+
+ values = PyDict_New();
+
+ result = add_const_to_group(values, "NONE", BLF_NONE);
+ if (result) result = add_const_to_group(values, "HAS_CODE", BLF_HAS_CODE);
+ if (result) result = add_const_to_group(values, "IS_LABEL", BLF_IS_LABEL);
+ if (result) result = add_const_to_group(values, "ENTRYPOINT", BLF_ENTRYPOINT);
+ if (result) result = add_const_to_group(values, "BOOKMARK", BLF_BOOKMARK);
+ if (result) result = add_const_to_group(values, "WIDTH_MANAGER", BLF_WIDTH_MANAGER);
+ if (result) result = add_const_to_group(values, "ALL", BLF_ALL);
+
+ if (!result)
+ {
+ Py_DECREF(values);
+ goto exit;
+ }
+
+ result = attach_constants_group_to_type(type, true, "BufferLineFlags", values,
+ "Optional flags linked to a rendering line.");
+
+ exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : arg = argument quelconque à tenter de convertir. *
+* dst = destination des valeurs récupérées en cas de succès. *
+* *
+* Description : Tente de convertir en constante BufferLineFlags. *
+* *
+* Retour : Bilan de l'opération, voire indications supplémentaires. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+int convert_to_buffer_line_flags(PyObject *arg, void *dst)
+{
+ int result; /* Bilan à retourner */
+ unsigned long value; /* Valeur transcrite */
+
+ result = PyObject_IsInstance(arg, (PyObject *)&PyLong_Type);
+
+ switch (result)
+ {
+ case -1:
+ /* L'exception est déjà fixée par Python */
+ result = 0;
+ break;
+
+ case 0:
+ PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to BufferLineFlags");
+ break;
+
+ case 1:
+ value = PyLong_AsUnsignedLong(arg);
+
+ if ((value & BLF_ALL) != value)
+ {
+ PyErr_SetString(PyExc_TypeError, "invalid value for BufferLineFlags");
+ result = 0;
+ }
+
+ else
+ *((BufferLineFlags *)dst) = value;
+
+ break;
+
+ default:
+ assert(false);
+ break;
+
+ }
+
+ return result;
+
+}
diff --git a/plugins/pychrysalide/glibext/constants.h b/plugins/pychrysalide/glibext/constants.h
index 472507b..a1c56af 100644
--- a/plugins/pychrysalide/glibext/constants.h
+++ b/plugins/pychrysalide/glibext/constants.h
@@ -37,6 +37,12 @@ bool define_line_segment_constants(PyTypeObject *);
/* Tente de convertir en constante RenderingTagType. */
int convert_to_rendering_tag_type(PyObject *, void *);
+/* Définit les constantes relatives aux lignes de tampon. */
+bool define_buffer_line_constants(PyTypeObject *);
+
+/* Tente de convertir en constante BufferLineFlags. */
+int convert_to_buffer_line_flags(PyObject *, void *);
+
#endif /* _PLUGINS_PYCHRYSALIDE_GLIBEXT_CONSTANTS_H */
diff --git a/plugins/pychrysalide/glibext/linegen.c b/plugins/pychrysalide/glibext/linegen.c
index 3ca7fcc..4d6d60d 100644
--- a/plugins/pychrysalide/glibext/linegen.c
+++ b/plugins/pychrysalide/glibext/linegen.c
@@ -28,26 +28,49 @@
#include <pygobject.h>
-#include <common/cpp.h>
-#include <glibext/linegen.h>
+#include <glibext/linegen-int.h>
+#include "bufferline.h"
+#include "constants.h"
+#include "linecursor.h"
#include "../access.h"
#include "../helpers.h"
#include "../analysis/content.h"
-#include "../arch/vmpa.h"
-#include "../glibext/bufferline.h"
+/* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */
+
+
+/* Procède à l'initialisation de l'interface de génération. */
+static void py_line_generator_interface_init(GLineGeneratorIface *, gpointer *);
+
/* Indique le nombre de ligne prêtes à être générées. */
-static PyObject *py_line_generator_count_lines(PyObject *, PyObject *);
+static size_t py_line_generator_count_lines_wrapper(const GLineGenerator *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-//static PyObject *py_line_generator_compute_addr(PyObject *, PyObject *);
+static void py_line_generator_compute_cursor_wrapper(const GLineGenerator *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-//static PyObject *py_line_generator_contains_addr(PyObject *, PyObject *);
+static int py_line_generator_contain_cursor_wrapper(const GLineGenerator *, size_t, size_t, const GLineCursor *);
+
+/* Renseigne sur les propriétés liées à un générateur. */
+static BufferLineFlags py_line_generator_get_flags_wrapper(const GLineGenerator *, size_t, size_t);
+
+/* Imprime dans une ligne de rendu le contenu représenté. */
+static void py_line_generator_print_wrapper(GLineGenerator *, GBufferLine *, size_t, size_t, const GBinContent *);
+
+
+
+/* ------------------------- CONNEXION AVEC L'API DE PYTHON ------------------------- */
+
+
+/* Retrouve l'emplacement correspondant à une position donnée. */
+static PyObject *py_line_generator_compute_cursor(PyObject *, PyObject *);
+
+/* Détermine si le conteneur s'inscrit dans une plage donnée. */
+static PyObject *py_line_generator_contain_cursor(PyObject *, PyObject *);
/* Renseigne sur les propriétés liées à un générateur. */
static PyObject *py_line_generator_get_flags(PyObject *, PyObject *);
@@ -55,12 +78,61 @@ static PyObject *py_line_generator_get_flags(PyObject *, PyObject *);
/* Imprime dans une ligne de rendu le contenu représenté. */
static PyObject *py_line_generator_print(PyObject *, PyObject *);
+/* Indique le nombre de ligne prêtes à être générées. */
+static PyObject *py_line_generator_get_lines_count(PyObject *, void *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* GLUE POUR CREATION DEPUIS PYTHON */
+/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
-* Paramètres : self = classe représentant un générateur à manipuler. *
-* args = arguments fournis à l'appel. *
+* Paramètres : iface = interface GLib à initialiser. *
+* unused = adresse non utilisée ici. *
+* *
+* Description : Procède à l'initialisation de l'interface de génération. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void py_line_generator_interface_init(GLineGeneratorIface *iface, gpointer *unused)
+{
+
+#define LINE_GENERATOR_DOC \
+ "LineGenerator gives an interface to all objects which aim to produce" \
+ " content for rendering lines. Such lines can be exported to graphical" \
+ " interfaces or text files.\n" \
+ "\n" \
+ "A typical class declaration for a new implementation looks like:\n" \
+ "\n" \
+ " class NewImplem(GObject.Object, LineGenerator):\n" \
+ " ...\n" \
+ "\n" \
+ "The following methods have to be defined for new implementations:\n" \
+ "* pychrysalide.glibext.LineGenerator._count_lines();\n" \
+ "* pychrysalide.glibext.LineGenerator._compute_cursor();\n" \
+ "* pychrysalide.glibext.LineGenerator._contain_cursor();\n" \
+ "* pychrysalide.glibext.LineGenerator._get_flags();\n" \
+ "* pychrysalide.glibext.LineGenerator._print();\n" \
+
+ iface->count = py_line_generator_count_lines_wrapper;
+ iface->compute = py_line_generator_compute_cursor_wrapper;
+ iface->contains = py_line_generator_contain_cursor_wrapper;
+ iface->get_flags = py_line_generator_get_flags_wrapper;
+ iface->print = py_line_generator_print_wrapper;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : generator = générateur à consulter. *
* *
* Description : Indique le nombre de ligne prêtes à être générées. *
* *
@@ -70,17 +142,46 @@ static PyObject *py_line_generator_print(PyObject *, PyObject *);
* *
******************************************************************************/
-static PyObject *py_line_generator_count_lines(PyObject *self, PyObject *args)
+static size_t py_line_generator_count_lines_wrapper(const GLineGenerator *generator)
{
- PyObject *result; /* Décompte à retourner */
- GLineGenerator *generator; /* Version native */
- size_t count; /* Nombre de lignes présentes */
+ size_t result; /* Décompte à retourner */
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *pyret; /* Bilan de consultation */
+ int ret; /* Bilan d'une conversion */
- generator = G_LINE_GENERATOR(pygobject_get(self));
+#define LINE_GENERATOR_COUNT_LINES_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _count_lines, "$self, /", \
+ METH_NOARGS, \
+ "Abstract method used to count the number of lines produced" \
+ " by the current generator." \
+)
- count = g_line_generator_count_lines(generator);
+ result = 0;
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(generator));
+
+ if (has_python_method(pyobj, "_count_lines"))
+ {
+ pyret = run_python_method(pyobj, "_count_lines", NULL);
+
+ if (pyret != NULL)
+ {
+ ret = PyLong_Check(pyret);
+
+ if (ret)
+ result = PyLong_AsSize_t(pyret);
+
+ Py_DECREF(pyret);
+
+ }
+
+ }
- result = Py_BuildValue("k", count);
+ PyGILState_Release(gstate);
return result;
@@ -89,40 +190,358 @@ static PyObject *py_line_generator_count_lines(PyObject *self, PyObject *args)
/******************************************************************************
* *
+* Paramètres : generator = générateur à consulter. *
+* x = position géographique sur la ligne concernée. *
+* index = indice de cette même ligne dans le tampon global.*
+* repeat = indice d'utilisations successives du générateur. *
+* *
+* Description : Retrouve l'emplacement correspondant à une position donnée. *
+* *
+* Retour : Emplacement constitué. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void py_line_generator_compute_cursor_wrapper(const GLineGenerator *generator, gint x, size_t index, size_t repeat, GLineCursor **cursor)
+{
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *args; /* Arguments pour l'appel */
+ PyObject *pyret; /* Bilan de consultation */
+ int ret; /* Bilan d'une conversion */
+
+#define LINE_GENERATOR_COMPUTE_CURSOR_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _compute_cursor, "$self, x, index, repeat, /", \
+ METH_VARARGS, \
+ "Abstract method used to create a new cursor for a given" \
+ " location inside displayed lines.\n" \
+ "\n" \
+ "The position on the horizontal axis, the line index and the" \
+ " number of repetitions (only relevant if the generator" \
+ " produces several lines) give indications about the active" \
+ " position.\n" \
+ "\n" \
+ "The result has to be a pychrysalide.glibext.LineCursor" \
+ " instance." \
+)
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(generator));
+
+ if (has_python_method(pyobj, "_compute_cursor"))
+ {
+ args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, PyLong_FromSize_t(x));
+ PyTuple_SetItem(args, 1, PyLong_FromSize_t(index));
+ PyTuple_SetItem(args, 2, PyLong_FromSize_t(repeat));
+
+ pyret = run_python_method(pyobj, "_compute_cursor", args);
+
+ if (pyret != NULL)
+ {
+ ret = convert_to_line_cursor(pyret, cursor);
+
+ if (ret != 1)
+ *cursor = NULL;
+
+ Py_DECREF(pyret);
+
+ }
+
+ Py_DECREF(args);
+
+ }
+
+ PyGILState_Release(gstate);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : generator = générateur à consulter. *
+* index = indice de cette même ligne dans le tampon global.*
+* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
+* *
+* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
+* *
+* Retour : Bilan de la détermination, utilisable en comparaisons. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static int py_line_generator_contain_cursor_wrapper(const GLineGenerator *generator, size_t index, size_t repeat, const GLineCursor *cursor)
+{
+ int result; /* Bilan d'analyse à retourner */
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *args; /* Arguments pour l'appel */
+ PyObject *pyret; /* Bilan de consultation */
+ int ret; /* Bilan d'une conversion */
+
+#define LINE_GENERATOR_CONTAIN_CURSOR_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _contain_cursor, "$self, index, repeat, cursor, /", \
+ METH_VARARGS, \
+ "Abstract method used to check the position of a cursor in" \
+ " relation to rendering lines.\n" \
+ "\n" \
+ "The line index and the number of repetitions (only relevant" \
+ " if the generator produces several lines) give indications" \
+ " about the active position. The cursor is a" \
+ " pychrysalide.glibext.LineCursor instance.\n" \
+ "\n" \
+ "The result has to be an integer less than, equal to, or" \
+ " greater than zero if the cursor is, respectively, before," \
+ " inside or after the area covered by the generator." \
+)
+
+ result = 0;
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(generator));
+
+ if (has_python_method(pyobj, "_contain_cursor"))
+ {
+ args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, PyLong_FromSize_t(index));
+ PyTuple_SetItem(args, 1, PyLong_FromSize_t(repeat));
+ PyTuple_SetItem(args, 2, pygobject_new(G_OBJECT(cursor)));
+
+ pyret = run_python_method(pyobj, "_contain_cursor", args);
+
+ if (pyret != NULL)
+ {
+ ret = PyLong_Check(pyret);
+
+ if (ret)
+ result = PyLong_AsLong(pyret);
+
+ Py_DECREF(pyret);
+
+ }
+
+ Py_DECREF(args);
+
+ }
+
+ PyGILState_Release(gstate);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : generator = générateur à consulter. *
+* index = indice de cette même ligne dans le tampon global.*
+* repeat = indice d'utilisations successives du générateur. *
+* *
+* Description : Renseigne sur les propriétés liées à un générateur. *
+* *
+* Retour : Propriétés particulières associées. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static BufferLineFlags py_line_generator_get_flags_wrapper(const GLineGenerator *generator, size_t index, size_t repeat)
+{
+ BufferLineFlags result; /* Fanions à retourner */
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *args; /* Arguments pour l'appel */
+ PyObject *pyret; /* Bilan de consultation */
+ int ret; /* Bilan d'une conversion */
+
+#define LINE_GENERATOR_GET_FLAGS_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _get_flags, "$self, index, repeat, /", \
+ METH_VARARGS, \
+ "Abstract method used to provide flags for a given rendering" \
+ " line.\n" \
+ "\n" \
+ "The line index and the number of repetitions (only relevant" \
+ " if the generator produces several lines) give indications" \
+ " about the active position.\n" \
+ "\n" \
+ "The result has to be a" \
+ " pychrysalide.glibext.BufferLine.BufferLineFlags value.\n" \
+)
+
+ result = BLF_NONE;
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(generator));
+
+ if (has_python_method(pyobj, "_get_flags"))
+ {
+ args = PyTuple_New(2);
+ PyTuple_SetItem(args, 0, PyLong_FromSize_t(index));
+ PyTuple_SetItem(args, 1, PyLong_FromSize_t(repeat));
+
+ pyret = run_python_method(pyobj, "_get_flags", args);
+
+ if (pyret != NULL)
+ {
+ ret = convert_to_buffer_line_flags(pyret, &result);
+
+ if (ret != 1)
+ result = BLF_NONE;
+
+ Py_DECREF(pyret);
+
+ }
+
+ Py_DECREF(args);
+
+ }
+
+ PyGILState_Release(gstate);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : generator = générateur à utiliser pour l'impression. *
+* line = ligne de rendu à compléter. *
+* index = indice de cette même ligne dans le tampon global.*
+* repeat = indice d'utilisations successives du générateur. *
+* content = éventuel contenu binaire brut à imprimer. *
+* *
+* Description : Imprime dans une ligne de rendu le contenu représenté. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void py_line_generator_print_wrapper(GLineGenerator *generator, GBufferLine *line, size_t index, size_t repeat, const GBinContent *content)
+{
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *args; /* Arguments pour l'appel */
+ PyObject *pyret; /* Bilan de consultation */
+
+#define LINE_GENERATOR_PRINT_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _print, "$self, line, index, repeat, content, /", \
+ METH_VARARGS, \
+ "Abstract method used to generate content into a rendering" \
+ " line, which is a provided pychrysalide.glibext.BufferLine" \
+ " instance.\n" \
+ "\n" \
+ "The line index and the number of repetitions (only relevant" \
+ " if the generator produces several lines) give indications" \
+ " about the current rendering position.\n" \
+ "\n" \
+ "If set, the content is a pychrysalide.analysis.BinContent" \
+ " instance providing access to the processed binary data." \
+)
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(generator));
+
+ if (has_python_method(pyobj, "_print"))
+ {
+ args = PyTuple_New(4);
+ PyTuple_SetItem(args, 0, pygobject_new(G_OBJECT(line)));
+ PyTuple_SetItem(args, 1, PyLong_FromSize_t(index));
+ PyTuple_SetItem(args, 2, PyLong_FromSize_t(repeat));
+ PyTuple_SetItem(args, 3, pygobject_new(G_OBJECT(content)));
+
+ pyret = run_python_method(pyobj, "_print", args);
+
+ Py_DECREF(args);
+
+ Py_XDECREF(pyret);
+
+ }
+
+ PyGILState_Release(gstate);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* CONNEXION AVEC L'API DE PYTHON */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
* Paramètres : self = classe représentant un générateur à manipuler. *
* args = arguments fournis à l'appel. *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
-* Retour : - *
+* Retour : Emplacement constitué. *
* *
* Remarques : - *
* *
******************************************************************************/
-#if 0
-static PyObject *py_line_generator_compute_addr(PyObject *self, PyObject *args)
+
+static PyObject *py_line_generator_compute_cursor(PyObject *self, PyObject *args)
{
- PyObject *result; /* Localisation à retourner */
- GLineGenerator *generator; /* Version native */
- gint x; /* Position géographique */
+ PyObject *result; /* Propriétés à retourner */
+ int x; /* Position horizontale */
size_t index; /* Indice dans le tampon */
size_t repeat; /* Utilisations successives */
int ret; /* Bilan de lecture des args. */
- vmpa2t addr; /* Adresse visée par l'opérat° */
+ GLineGenerator *generator; /* Version native */
+ GLineCursor *cursor; /* Curseur nouveau obtenu */
+
+#define LINE_GENERATOR_COMPUTE_CURSOR_METHOD PYTHON_METHOD_DEF \
+( \
+ compute_cursor, "$self, x, index, repeat, /", \
+ METH_VARARGS, py_line_generator, \
+ "Create a a new cursor for a given location inside displayed" \
+ " lines.\n" \
+ "\n" \
+ "The position on the horizontal axis, the line index and the" \
+ " number of repetitions (only relevant if the generator" \
+ " produces several lines) give indications about the active" \
+ " position.\n" \
+ "\n" \
+ "The result has to be a pychrysalide.glibext.LineCursor" \
+ " instance." \
+)
+
+ ret = PyArg_ParseTuple(args, "inn", &x, &index, &repeat);
+ if (!ret) return NULL;
generator = G_LINE_GENERATOR(pygobject_get(self));
- ret = PyArg_ParseTuple(args, "ikk", &x, &index, &repeat);
- if (!ret) return NULL;
+ cursor = g_line_generator_compute_cursor(generator, x, index, repeat);
- g_line_generator_compute_addr(generator, x, &addr, index, repeat);
-
- result = build_from_internal_vmpa(&addr);
+ if (cursor != NULL)
+ {
+ result = pygobject_new(G_OBJECT(cursor));
+ g_object_unref(G_OBJECT(cursor));
+ }
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
return result;
}
-#endif
/******************************************************************************
@@ -137,30 +556,46 @@ static PyObject *py_line_generator_compute_addr(PyObject *self, PyObject *args)
* Remarques : - *
* *
******************************************************************************/
-#if 0
-static PyObject *py_line_generator_contains_addr(PyObject *self, PyObject *args)
+
+static PyObject *py_line_generator_contain_cursor(PyObject *self, PyObject *args)
{
- GLineGenerator *generator; /* Version native */
- PyObject *py_vmpa; /* Localisation version Python */
+ PyObject *result; /* Propriétés à retourner */
size_t index; /* Indice dans le tampon */
size_t repeat; /* Utilisations successives */
+ GLineCursor *cursor; /* Curseur à venir situer */
int ret; /* Bilan de lecture des args. */
- vmpa2t *addr; /* Adresse visée par l'opérat° */
+ GLineGenerator *generator; /* Version native */
+ int status; /* Bilan d'une analyse */
+
+#define LINE_GENERATOR_CONTAIN_CURSOR_METHOD PYTHON_METHOD_DEF \
+( \
+ contain_cursor, "$self, index, repeat, cursor, /", \
+ METH_VARARGS, py_line_generator, \
+ "Check the position of a cursor in relation to rendering" \
+ " lines.\n" \
+ "\n" \
+ "The line index and the number of repetitions (only relevant" \
+ " if the generator produces several lines) give indications" \
+ " about the active position. The cursor is a" \
+ " pychrysalide.glibext.LineCursor instance.\n" \
+ "\n" \
+ "The result has to be an integer less than, equal to, or" \
+ " greater than zero if the cursor is, respectively, before," \
+ " inside or after the area covered by the generator." \
+)
+
+ ret = PyArg_ParseTuple(args, "nnO&", &index, &repeat, convert_to_line_cursor, &cursor);
+ if (!ret) return NULL;
generator = G_LINE_GENERATOR(pygobject_get(self));
- ret = PyArg_ParseTuple(args, "O!kk", get_python_vmpa_type(), &py_vmpa, &index, &repeat);
- if (!ret) return NULL;
-
- addr = get_internal_vmpa(py_vmpa);
- if (addr == NULL) return NULL;
+ status = g_line_generator_contains_cursor(generator, index, repeat, cursor);
- g_line_generator_contains_addr(generator, addr, index, repeat);
+ result = PyLong_FromLong(status);
- Py_RETURN_NONE;
+ return result;
}
-#endif
/******************************************************************************
@@ -179,20 +614,34 @@ static PyObject *py_line_generator_contains_addr(PyObject *self, PyObject *args)
static PyObject *py_line_generator_get_flags(PyObject *self, PyObject *args)
{
PyObject *result; /* Propriétés à retourner */
- GLineGenerator *generator; /* Version native */
size_t index; /* Indice dans le tampon */
size_t repeat; /* Utilisations successives */
int ret; /* Bilan de lecture des args. */
+ GLineGenerator *generator; /* Version native */
BufferLineFlags flags; /* Propriétés courantes */
- generator = G_LINE_GENERATOR(pygobject_get(self));
-
- ret = PyArg_ParseTuple(args, "kk", &index, &repeat);
+#define LINE_GENERATOR_GET_FLAGS_METHOD PYTHON_METHOD_DEF \
+( \
+ get_flags, "$self, index, repeat, /", \
+ METH_VARARGS, py_line_generator, \
+ "Get the flags of a given position from the generator.\n" \
+ "\n" \
+ "The line index and the number of repetitions (only relevant" \
+ " if the generator produces several lines) give indications" \
+ " about the active position.\n" \
+ "\n" \
+ "The result is a pychrysalide.glibext.BufferLine.BufferLineFlags" \
+ " value." \
+)
+
+ ret = PyArg_ParseTuple(args, "nn", &index, &repeat);
if (!ret) return NULL;
+ generator = G_LINE_GENERATOR(pygobject_get(self));
+
flags = g_line_generator_get_flags(generator, index, repeat);
- result = Py_BuildValue("I", flags);
+ result = cast_with_constants_group_from_type(get_python_buffer_line_type(), "BufferLineFlags", flags);
return result;
@@ -214,19 +663,33 @@ static PyObject *py_line_generator_get_flags(PyObject *self, PyObject *args)
static PyObject *py_line_generator_print(PyObject *self, PyObject *args)
{
- GLineGenerator *generator; /* Version native */
GBufferLine *line; /* Ligne de rendu à compléter */
size_t index; /* Indice dans le tampon */
size_t repeat; /* Utilisations successives */
GBinContent *content; /* Contenu binaire associé */
+ GLineGenerator *generator; /* Version native */
int ret; /* Bilan de lecture des args. */
- generator = G_LINE_GENERATOR(pygobject_get(self));
-
- ret = PyArg_ParseTuple(args, "O&kkO&", convert_to_buffer_line, &line, &index,
+#define LINE_GENERATOR_PRINT_METHOD PYTHON_METHOD_DEF \
+( \
+ print, "$self, line, index, repeat, content, /", \
+ METH_VARARGS, py_line_generator, \
+ "Produce output into a rendering line with optional content.\n" \
+ "\n" \
+ "The line index and the number of repetitions (only relevant" \
+ " if the generator produces several lines) give indications" \
+ " about the current rendering position.\n" \
+ "\n" \
+ "If set, the content is a pychrysalide.analysis.BinContent" \
+ " instance providing access to the processed binary data." \
+)
+
+ ret = PyArg_ParseTuple(args, "O&nnO&", convert_to_buffer_line, &line, &index,
&repeat, convert_to_binary_content, &content);
if (!ret) return NULL;
+ generator = G_LINE_GENERATOR(pygobject_get(self));
+
g_line_generator_print(generator, line, index, repeat, content);
Py_RETURN_NONE;
@@ -234,78 +697,45 @@ static PyObject *py_line_generator_print(PyObject *self, PyObject *args)
}
-
-
-
-
-
-
-
-
-
-
-
-#if 0
-
/******************************************************************************
* *
-* Paramètres : - *
+* Paramètres : self = classe représentant un générateur à manipuler. *
+* closure = non utilisé ici. *
* *
-* Description : Fournit un accès à une définition de type à diffuser. *
+* Description : Indique le nombre de ligne prêtes à être générées. *
* *
-* Retour : - *
+* Retour : Nombre de lignes devant apparaître au final. *
* *
* Remarques : - *
* *
******************************************************************************/
-static void python_line_generator_interface_init(GLineGeneratorIface *iface, PyTypeObject *type)
+static PyObject *py_line_generator_get_lines_count(PyObject *self, void *closure)
{
- GLineGeneratorIface *parent; /* Défintion parente */
- size_t i; /* Boucle de parcours */
- PyObject *method; /* Méthode à associer */
-
- static const char *meth_names[] = {
- "count_lines",
- "compute_addr",
- "contains_addr",
- "get_flags",
- "print"
- };
-
- parent = g_type_interface_peek_parent(iface);
-
- for (i = 0; i < ARRAY_SIZE(meth_names); i++)
- {
- method = NULL;
-
- if (type != NULL)
- method = PyObject_GetAttrString((PyObject *)type, meth_names[i]);
-
- if (method != NULL && PyObject_TypeCheck(method, &PyCFunction_Type) == 0)
- /*iface->iface_method = _wrap_TestInterface__proxy_do_iface_method*/;
+ PyObject *result; /* Décompte à retourner */
+ GLineGenerator *generator; /* Version native */
+ size_t count; /* Nombre de lignes présentes */
- else
- {
- PyErr_Clear();
+#define LINE_GENERATOR_LINES_COUNT_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ lines_count, py_line_generator, \
+ "Quantity of lines produced by the generator.\n" \
+ "\n" \
+ "This number may vary between calls, if a width has changed" \
+ " for instance." \
+)
- if (parent != NULL)
- /*iface->iface_method = parent->iface_method*/;
+ generator = G_LINE_GENERATOR(pygobject_get(self));
- }
+ count = g_line_generator_count_lines(generator);
- Py_XDECREF(method);
+ result = PyLong_FromSize_t(count);
- }
+ return result;
}
-#endif
-
-
-
-
/******************************************************************************
* *
* Paramètres : - *
@@ -321,37 +751,20 @@ static void python_line_generator_interface_init(GLineGeneratorIface *iface, PyT
PyTypeObject *get_python_line_generator_type(void)
{
static PyMethodDef py_line_generator_methods[] = {
- {
- "count_lines", py_line_generator_count_lines,
- METH_NOARGS,
- "count_lines($self, /)\n--\n\nCount the number of lines which can be displayed."
- },
-#if 0
- {
- "compute_addr", py_line_generator_compute_addr,
- METH_VARARGS,
- "compute_addr($self, x, index, repeat, /)\n--\n\nReturn the position at a given location."
- },
- {
- "contains_addr", py_line_generator_contains_addr,
- METH_VARARGS,
- "contains_addr($self, addr, index, repeat, /)\n--\n\nTell if the generator contains an address."
- },
-#endif
- {
- "get_flags", py_line_generator_get_flags,
- METH_VARARGS,
- "get_flags($self, index, repeat, /)\n--\n\nGet the flags of a position from the generator."
- },
- {
- "print", py_line_generator_print,
- METH_VARARGS,
- "print($self, line, index, repeat, content, /)\n--\n\nProduce output into a line from content."
- },
+ LINE_GENERATOR_COUNT_LINES_WRAPPER,
+ LINE_GENERATOR_COMPUTE_CURSOR_WRAPPER,
+ LINE_GENERATOR_CONTAIN_CURSOR_WRAPPER,
+ LINE_GENERATOR_GET_FLAGS_WRAPPER,
+ LINE_GENERATOR_PRINT_WRAPPER,
+ LINE_GENERATOR_COMPUTE_CURSOR_METHOD,
+ LINE_GENERATOR_CONTAIN_CURSOR_METHOD,
+ LINE_GENERATOR_GET_FLAGS_METHOD,
+ LINE_GENERATOR_PRINT_METHOD,
{ NULL }
};
static PyGetSetDef py_line_generator_getseters[] = {
+ LINE_GENERATOR_LINES_COUNT_ATTRIB,
{ NULL }
};
@@ -360,11 +773,11 @@ PyTypeObject *get_python_line_generator_type(void)
PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "pychrysalide.glibext.LineGenerator",
- //.tp_basicsize = sizeof(PyGObject),
+ .tp_basicsize = sizeof(PyObject),
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_doc = "PyChrysalide line content generator",
+ .tp_doc = LINE_GENERATOR_DOC,
.tp_methods = py_line_generator_methods,
.tp_getset = py_line_generator_getseters,
@@ -394,6 +807,14 @@ bool ensure_python_line_generator_is_registered(void)
PyObject *module; /* Module à recompléter */
PyObject *dict; /* Dictionnaire du module */
+ static GInterfaceInfo info = { /* Paramètres d'inscription */
+
+ .interface_init = (GInterfaceInitFunc)py_line_generator_interface_init,
+ .interface_finalize = NULL,
+ .interface_data = NULL,
+
+ };
+
type = get_python_line_generator_type();
if (!PyType_HasFeature(type, Py_TPFLAGS_READY))
@@ -402,7 +823,7 @@ bool ensure_python_line_generator_is_registered(void)
dict = PyModule_GetDict(module);
- if (!register_interface_for_pygobject(dict, G_TYPE_LINE_GENERATOR, type))
+ if (!register_interface_for_pygobject_2(dict, G_TYPE_LINE_GENERATOR, type, &info))
return false;
}
@@ -410,3 +831,48 @@ bool ensure_python_line_generator_is_registered(void)
return true;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : arg = argument quelconque à tenter de convertir. *
+* dst = destination des valeurs récupérées en cas de succès. *
+* *
+* Description : Tente de convertir en générateur de lignes. *
+* *
+* Retour : Bilan de l'opération, voire indications supplémentaires. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+int convert_to_line_generator(PyObject *arg, void *dst)
+{
+ int result; /* Bilan à retourner */
+
+ result = PyObject_IsInstance(arg, (PyObject *)get_python_line_generator_type());
+
+ switch (result)
+ {
+ case -1:
+ /* L'exception est déjà fixée par Python */
+ result = 0;
+ break;
+
+ case 0:
+ PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to line generator");
+ break;
+
+ case 1:
+ *((GLineGenerator **)dst) = G_LINE_GENERATOR(pygobject_get(arg));
+ break;
+
+ default:
+ assert(false);
+ break;
+
+ }
+
+ return result;
+
+}
diff --git a/plugins/pychrysalide/glibext/linegen.h b/plugins/pychrysalide/glibext/linegen.h
index 4502347..bfad885 100644
--- a/plugins/pychrysalide/glibext/linegen.h
+++ b/plugins/pychrysalide/glibext/linegen.h
@@ -37,6 +37,9 @@ PyTypeObject *get_python_line_generator_type(void);
/* Prend en charge l'objet 'pychrysalide.glibext.LineGenerator'. */
bool ensure_python_line_generator_is_registered(void);
+/* Tente de convertir en générateur de lignes. */
+int convert_to_line_generator(PyObject *, void *);
+
#endif /* _PLUGINS_PYCHRYSALIDE_GLIBEXT_LINEGEN_H */
diff --git a/plugins/pychrysalide/helpers.c b/plugins/pychrysalide/helpers.c
index 47285f0..5e911ea 100644
--- a/plugins/pychrysalide/helpers.c
+++ b/plugins/pychrysalide/helpers.c
@@ -916,6 +916,51 @@ bool register_interface_for_pygobject(PyObject *dict, GType gtype, PyTypeObject
* Paramètres : dict = dictionnaire où conserver une référence au type créé.*
* gtype = type dans sa version GLib. *
* type = type dans sa version Python. *
+* *
+* Description : Enregistre correctement une interface GObject pour Python. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool register_interface_for_pygobject_2(PyObject *dict, GType gtype, PyTypeObject *type, const GInterfaceInfo *info)
+{
+ bool result; /* Bilan à retourner */
+ char *name; /* Désignation de la classe */
+
+ assert(gtype != G_TYPE_INVALID);
+
+ name = strrchr(type->tp_name, '.');
+ assert(name != NULL);
+
+ name++;
+
+ pyg_register_interface(dict, name, gtype, type);
+
+ pyg_register_interface_info(gtype, info);
+
+ if (startswith(type->tp_name, "pychrysalide."))
+ {
+ define_auto_documentation(type);
+
+ result = include_python_type_into_features(dict, type);
+
+ }
+ else
+ result = true;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : dict = dictionnaire où conserver une référence au type créé.*
+* gtype = type dans sa version GLib. *
+* type = type dans sa version Python. *
* base = type de base de l'objet. *
* *
* Description : Enregistre un type Python dérivant d'un type GLib dynamique. *
diff --git a/plugins/pychrysalide/helpers.h b/plugins/pychrysalide/helpers.h
index 8ed9d9a..dbc9272 100644
--- a/plugins/pychrysalide/helpers.h
+++ b/plugins/pychrysalide/helpers.h
@@ -162,7 +162,10 @@ bool _register_class_for_pygobject(PyObject *, GType, PyTypeObject *, PyTypeObje
_register_class_for_pygobject(dict, gtype, type, base, NULL)
/* Enregistre correctement une interface GObject pour Python. */
-bool register_interface_for_pygobject(PyObject *, GType, PyTypeObject *);
+bool register_interface_for_pygobject(PyObject *, GType, PyTypeObject *) __attribute__ ((deprecated));
+
+/* Enregistre correctement une interface GObject pour Python. */
+bool register_interface_for_pygobject_2(PyObject *, GType, PyTypeObject *, const GInterfaceInfo *);
/* Enregistre un type Python dérivant d'un type GLib dynamique. */
bool register_class_for_dynamic_pygobject(GType, PyTypeObject *, PyTypeObject *);