From 25811bc506ecca92d6b36fe739734121a872af4d Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Tue, 5 Mar 2019 22:15:36 +0100 Subject: Split the graph code into several files. --- src/gtkext/graph/Makefile.am | 8 +- src/gtkext/graph/cluster-int.h | 102 +++ src/gtkext/graph/cluster.c | 1892 +--------------------------------------- src/gtkext/graph/hspace.c | 125 +++ src/gtkext/graph/hspace.h | 52 ++ src/gtkext/graph/incoming.c | 184 ++++ src/gtkext/graph/incoming.h | 67 ++ src/gtkext/graph/leaving.c | 107 +++ src/gtkext/graph/leaving.h | 66 ++ src/gtkext/graph/rank.c | 914 +++++++++++++++++++ src/gtkext/graph/rank.h | 126 +++ src/gtkext/graph/vspace.c | 374 ++++++++ src/gtkext/graph/vspace.h | 86 ++ 13 files changed, 2242 insertions(+), 1861 deletions(-) create mode 100644 src/gtkext/graph/cluster-int.h create mode 100644 src/gtkext/graph/hspace.c create mode 100644 src/gtkext/graph/hspace.h create mode 100644 src/gtkext/graph/incoming.c create mode 100644 src/gtkext/graph/incoming.h create mode 100644 src/gtkext/graph/leaving.c create mode 100644 src/gtkext/graph/leaving.h create mode 100644 src/gtkext/graph/rank.c create mode 100644 src/gtkext/graph/rank.h create mode 100644 src/gtkext/graph/vspace.c create mode 100644 src/gtkext/graph/vspace.h diff --git a/src/gtkext/graph/Makefile.am b/src/gtkext/graph/Makefile.am index 310c13c..ee5eb19 100644 --- a/src/gtkext/graph/Makefile.am +++ b/src/gtkext/graph/Makefile.am @@ -2,8 +2,14 @@ noinst_LTLIBRARIES = libgtkextgraph.la libgtkextgraph_la_SOURCES = \ + cluster-int.h \ cluster.h cluster.c \ - edge.h edge.c + edge.h edge.c \ + hspace.h hspace.c \ + incoming.h incoming.c \ + leaving.h leaving.c \ + rank.h rank.c \ + vspace.h vspace.c libgtkextgraph_la_LIBADD = diff --git a/src/gtkext/graph/cluster-int.h b/src/gtkext/graph/cluster-int.h new file mode 100644 index 0000000..881a60a --- /dev/null +++ b/src/gtkext/graph/cluster-int.h @@ -0,0 +1,102 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * cluster-int.h - prototypes pour les définitions internes de mise en place de graphiques + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#ifndef _GTKEXT_GRAPH_CLUSTER_INT_H +#define _GTKEXT_GRAPH_CLUSTER_INT_H + + +#include "cluster.h" +#include "leaving.h" + + + +/* Espace minimal horizontal entre les blocs */ +#define HORIZONTAL_MARGIN 20 + +/* Espace minimal vertical entre les blocs */ +#define VERTICAL_MARGIN 15 + + +/* Assigne à un bloc et son ensemble un emplacement initial. */ +void g_graph_cluster_reset_allocation(GGraphCluster *); + +/* Met en place les embryons de liens nécessaires. */ +void g_graph_cluster_define_links(GGraphCluster *, GHashTable *); + +/* Repère les liens marquants à destination d'autres blocs. */ +void g_graph_cluster_setup_links(GGraphCluster *); + +/* Organise la disposition d'un ensemble de blocs basiques. */ +void g_graph_cluster_dispatch_x(GGraphCluster *); + +/* Réorganise au besoin les liens entrants d'un bloc. */ +void g_graph_cluster_sort_incoming_links(GGraphCluster *); + +/* Retrouve l'indice d'un lien entrant donné pour un bloc. */ +size_t g_graph_cluster_find_incoming_link(const GGraphCluster *, const leaving_link_t *); + +/* Détermine si un cluster possède un lien sortant. */ +bool g_graph_cluster_has_exit_link(GGraphCluster *, bool *); + +/* Compare deux clusters avec lien sortant. */ +int g_graph_cluster_compare_by_exit(const GGraphCluster **, const GGraphCluster **, const bool *); + +/* Réordonne les blocs sortant du cluster au mieux. */ +void g_graph_cluster_reorder_exit_blocks(GGraphCluster *); + +/* Réordonne les blocs de départ de boucle au mieux. */ +void g_graph_cluster_reorder_loop_blocks(GGraphCluster *); + +/* Réordonne le départ des liens en entrée de bloc. */ +void g_graph_cluster_reorder_link_origins(GGraphCluster *, bool); + +/* Décale vers la droite un ensemble de blocs basiques. */ +void g_graph_cluster_offset_x(GGraphCluster *, gint); + +/* Décale vers le bas un ensemble de blocs basiques. */ +void g_graph_cluster_set_y(GGraphCluster *, gint); + +/* Calcule l'abscisse d'un lien pour un bloc. */ +gint _g_graph_cluster_compute_link_position(const GGraphCluster *, size_t, size_t, bool); + +/* Calcule l'abscisse d'un lien à son départ d'un bloc. */ +gint g_graph_cluster_compute_leaving_link_position(const GGraphCluster *, size_t); + +/* Calcule l'abscisse d'un lien à son arrivée à un bloc. */ +gint g_graph_cluster_compute_incoming_link_position(const GGraphCluster *, size_t); + +/* Détermine les abscisses des liens de boucle en place. */ +void g_graph_cluster_compute_loop_link_x_positions(GGraphCluster *); + +/* Détermine les ordonnées de tous les liens en place. */ +void g_graph_cluster_compute_link_y_positions(GGraphCluster *); + +/* Collecte tous les chefs de file de blocs de code. */ +GGraphCluster **g_graph_cluster_collect(GGraphCluster *, GGraphCluster **, size_t *); + +/* Collecte tous les liens de chefs de file de blocs de code. */ +GGraphEdge **g_graph_cluster_collect_edges(GGraphCluster *, GGraphEdge **, size_t *); + + + +#endif diff --git a/src/gtkext/graph/cluster.c b/src/gtkext/graph/cluster.c index 6284029..41392a2 100644 --- a/src/gtkext/graph/cluster.c +++ b/src/gtkext/graph/cluster.c @@ -31,6 +31,12 @@ #include +#include "cluster-int.h" +#include "hspace.h" +#include "incoming.h" +#include "leaving.h" +#include "rank.h" +#include "vspace.h" #include "../gtkblockdisplay.h" #include "../gtkbufferdisplay.h" #include "../gtkdisplaypanel.h" @@ -39,248 +45,6 @@ -/* Définition du tracé d'un lien */ -typedef struct _incoming_link_t incoming_link_t; - - -/* ------------------------- LIEN SORTANT D'UN BLOC DE CODE ------------------------- */ - - -/* Détails sur le départ d'un lien */ -typedef struct _leaving_link_t -{ - GGraphCluster *owner; /* Propriétaire du lien */ - - GdkPoint start[2]; /* Point de départ d'un lien */ - size_t index; /* Indice sur ligne de départ */ - - bool straight; /* Présence d'une ligne droite */ - bool forced_straight; /* Forçage de verticalité */ - size_t straight_level; /* Rang atteint en ligne droite*/ - bool cluster_exit; /* Sortie du cluster d'origine */ - - incoming_link_t *other; /* Autre extrémité du lien */ - -} leaving_link_t; - - -#define SHOULD_BE_VERTICAL(l) ((l)->straight || (l)->forced_straight || (l)->cluster_exit) - - -/* Crée un point d'attache pour un lien sortant. */ -static leaving_link_t *create_leaving_link(GGraphCluster *, size_t); - -/* Détruit un point d'attache pour un lien sortant. */ -static void delete_leaving_link(leaving_link_t *); - -/* Calcule l'abscisse d'un lien à son départ d'un bloc. */ -static gint compute_leaving_link_position(const leaving_link_t *); - - - -/* ------------------------- LIEN ENTRANT D'UN BLOC DE CODE ------------------------- */ - - -/* Définition du tracé d'un lien */ -struct _incoming_link_t -{ - GGraphCluster *owner; /* Propriétaire du lien */ - - InstructionLinkType type; /* Complexité du tracé */ - - const size_t *hslot; /* Couche horizontale réservée */ - GdkPoint end[2]; /* Point d'arrivée final */ - - GGraphEdge *edge; /* Lien complet en préparation */ - - leaving_link_t *other; /* Autre extrémité du lien */ - -}; - - -/* Crée un point d'attache pour un lien entrant simple. */ -static incoming_link_t *create_incoming_link(GGraphCluster *, InstructionLinkType, leaving_link_t *); - -/* Crée un point d'attache pour un lien entrant de boucle. */ -static incoming_link_t *create_incoming_loop_link(GGraphCluster *, const GdkPoint *, leaving_link_t *); - -/* Détruit un point d'attache pour un lien entrant. */ -static void delete_incoming_link(incoming_link_t *); - -/* Compare deux liens entrants. */ -static int cmp_incoming_links(const incoming_link_t **, const incoming_link_t **); - - - -/* ------------------------ ENCADREMENTS D'ESPACES VERTICAUX ------------------------ */ - - -/* Réservations d'espaces latéraux */ -typedef struct _vspace_booking_t -{ - leaving_link_t *from; /* Bloc de départ du lien */ - incoming_link_t *to; /* Bloc d'arrivée du lien */ - - GdkPoint *pts; /* Coordonnées des points */ - - bool external; /* Lien vers un cluster parent */ - -} vspace_booking_t; - -/* Réservations d'espaces latéraux */ -typedef struct _vspace_manager_t -{ - vspace_booking_t *pending; /* Besoins exprimés */ - size_t pending_count; /* Nombre de ces besoins */ - - vspace_booking_t **left; /* Lignes disposées à gauche */ - size_t left_count; /* Quantité de ces lignes */ - - vspace_booking_t **right; /* Lignes disposées à droite */ - size_t right_count; /* Quantité de ces lignes */ - -} vspace_manager_t; - - -/* Initialise les réservations liens verticaux. */ -static void init_vspace_manager(vspace_manager_t *); - -/* Termine les réservations liens verticaux. */ -static void exit_vspace_manager(vspace_manager_t *); - -/* Inscrit une nouvelle réservation d'espace latéral. */ -static void extend_vspace_manager(vspace_manager_t *, leaving_link_t *, incoming_link_t *, GdkPoint *, bool); - -/* Détermine l'emplacement requis pour les espaces latéraux. */ -static void compute_vspace_manager_needed_alloc(const vspace_manager_t *, bool, GtkAllocation *); - -/* Réorganise au besoin les liens de boucle entre blocs. */ -static void sort_incoming_links_for_vspace_manager(vspace_manager_t *); - -/* Décale vers la droite un ensemble de points. */ -static void offset_x_vspace_manager(vspace_manager_t *, gint); - -/* Détermine les abscisses de tous les liens en place. */ -static gint compute_loop_link_x_with_vspace_manager(const vspace_manager_t *, const GtkAllocation *, bool); - -/* Détermine les ordonnées de tous les liens en place. */ -static void compute_loop_link_y_with_vspace_manager(const vspace_manager_t *, const GtkAllocation *); - - - -/* ---------------------- DESCENDANTS DIRECTS CLASSES PAR RANG ---------------------- */ - - -/* Réservation pour les lignes horizontales */ -typedef struct _hspace_booking -{ - gint start; /* Abscisse de départ de ligne */ - size_t index; /* Indice de rangée verticale */ - -} hspace_booking; - - -/* Prépare une réservation d'espace pour ligne horizontale. */ -static hspace_booking *create_hspace_booking(gint); - -/* Compare deux réservations d'espace. */ -static int cmp_hspace_booking_r2l(const hspace_booking **, const hspace_booking **); - -/* Compare deux réservations d'espace. */ -static int cmp_hspace_booking_l2r(const hspace_booking **, const hspace_booking **); - - -/* Découpage vertical */ -typedef struct _graph_rank_t -{ - hspace_booking **right2left; /* Réservations de D -> G */ - size_t r2l_count; /* Quantité de ces réservations*/ - - hspace_booking **left2right; /* Réservations de G -> D */ - size_t l2r_count; /* Quantité de ces réservations*/ - - GGraphCluster **clusters; /* Ensembles de blocs */ - size_t count; /* Nombre de ces ensembles */ - - vspace_manager_t vspaces; /* Gestion des liens latéraux */ - -} graph_rank_t; - - -/* Initialise la gestion d'un ensemble de blocs de même rang. */ -static void init_graph_rank(graph_rank_t *, GGraphCluster *); - -/* Termine la gestion d'un ensemble de blocs de même rang. */ -static void exit_graph_rank(graph_rank_t *); - -/* Assigne à un ensemble de blocs un emplacement initial. */ -static void reset_graph_rank_allocation(const graph_rank_t *); - -/* Fournit le rang d'un ensemble de blocs. */ -static size_t get_graph_rank(const graph_rank_t *); - -/* Compare deux rangées de blocs de code. */ -static int cmp_graph_rank(const graph_rank_t *, const graph_rank_t *); - -/* Etend un ensemble de blocs de même rang. */ -static void extend_graph_rank(graph_rank_t *, GGraphCluster *); - -/* Détermine si un groupe de blocs contient un bloc particulier. */ -static bool has_graph_rank_cluster(const graph_rank_t *, GGraphCluster *); - -/* Inscrit à l'endroit idéal une réservation d'espace latéral. */ -static bool extend_graph_rank_vspace_manager(graph_rank_t *, leaving_link_t *, incoming_link_t *, GdkPoint *, bool); - -/* Met en place les embryons de liens nécessaires. */ -static void define_graph_rank_links(const graph_rank_t *, GHashTable *); - -/* Repère les liens marquants à destination d'autres blocs. */ -static void setup_graph_rank_links(const graph_rank_t *); - -/* Détermine l'emplacement requis d'un ensemble de blocs. */ -static void compute_graph_rank_needed_alloc(const graph_rank_t *, bool, GtkAllocation *); - -/* Affine l'abscisse d'un ensemble de blocs de même rang. */ -static void _place_graph_rank_clusters(GGraphCluster **, size_t, gint, int); - -/* Organise la disposition d'un ensemble de blocs basiques. */ -static void dispatch_x_graph_rank(const graph_rank_t *); - -/* Réorganise au besoin les liens entrants un ensemble de blocs. */ -static void sort_graph_rank_incoming_links(graph_rank_t *); - -/* Réordonne les blocs sortant d'un ensemble. */ -static void reorder_graph_rank_exit_blocks(graph_rank_t *); - -/* Réordonne les blocs de départ de boucle d'un ensemble. */ -static void reorder_graph_rank_loop_blocks(graph_rank_t *); - -/* Décale vers la droite un ensemble de blocs basiques. */ -static void offset_x_graph_rank(graph_rank_t *, gint); - -/* Détermine les abscisses des liens de boucle en place. */ -static gint compute_loop_link_x_positions_with_graph_rank(const graph_rank_t *, const GtkAllocation *); - -/* Décale vers le bas un ensemble de blocs basiques. */ -static void set_y_for_graph_rank(const graph_rank_t *, gint *); - -/* Détermine les ordonnées de tous les liens en place. */ -static void compute_loop_link_with_graph_rank(const graph_rank_t *, const GtkAllocation *); - -/* Recherche le groupe de blocs avec un bloc donné comme chef. */ -static GGraphCluster *find_cluster_by_block_in_graph_rank(const graph_rank_t *, GCodeBlock *); - -/* Recherche le groupe de blocs avec un composant comme chef. */ -static GGraphCluster *find_cluster_by_widget_in_graph_rank(const graph_rank_t *, GtkWidget *); - -/* Collecte tous les chefs de file de blocs de code. */ -static GGraphCluster **collect_graph_ranks_clusters(const graph_rank_t *, GGraphCluster **, size_t *); - -/* Collecte tous les liens de chefs de file de blocs de code. */ -static GGraphEdge **collect_graph_ranks_cluster_edges(const graph_rank_t *, GGraphEdge **, size_t *); - - - /* -------------------------- DEFINITION D'UN CHEF DE FILE -------------------------- */ @@ -330,12 +94,6 @@ struct _GGraphClusterClass }; -/* Espace minimal horizontal entre les blocs */ -#define HORIZONTAL_MARGIN 20 - -/* Espace minimal vertical entre les blocs */ -#define VERTICAL_MARGIN 15 - /* Initialise la classe des mises en disposition graphique. */ static void g_graph_cluster_class_init(GGraphClusterClass *); @@ -349,9 +107,6 @@ static void g_graph_cluster_dispose(GGraphCluster *); /* Procède à la libération totale de la mémoire. */ static void g_graph_cluster_finalize(GGraphCluster *); -/* Assigne à un bloc et son ensemble un emplacement initial. */ -static void g_graph_cluster_reset_allocation(GGraphCluster *); - /* Complète un graphique avec un sous-ensemble de blocs. */ static void g_graph_cluster_add_sub(GGraphCluster *, GGraphCluster *); @@ -361,75 +116,18 @@ static void g_graph_cluster_setup_link_for_target(GGraphCluster *, GGraphCluster /* Inscrit à l'endroit idéal une réservation d'espace latéral. */ static void g_graph_cluster_extend_vspace_manager(GGraphCluster *, leaving_link_t *, incoming_link_t *, GdkPoint *); -/* Met en place les embryons de liens nécessaires. */ -static void g_graph_cluster_define_links(GGraphCluster *, GHashTable *); - -/* Repère les liens marquants à destination d'autres blocs. */ -static void g_graph_cluster_setup_links(GGraphCluster *); - -/* Organise la disposition d'un ensemble de blocs basiques. */ -static void g_graph_cluster_dispatch_x(GGraphCluster *); - -/* Réorganise au besoin les liens entrants d'un bloc. */ -static void g_graph_cluster_sort_incoming_links(GGraphCluster *); - -/* Retrouve l'indice d'un lien entrant donné pour un bloc. */ -static size_t g_graph_cluster_find_incoming_link(const GGraphCluster *, const leaving_link_t *); - -/* Détermine si un cluster possède un lien sortant. */ -static bool g_graph_cluster_has_exit_link(GGraphCluster *, bool *); - -/* Compare deux clusters avec lien sortant. */ -static int g_graph_cluster_compare_by_exit(const GGraphCluster **, const GGraphCluster **, const bool *); - -/* Réordonne les blocs sortant du cluster au mieux. */ -static void g_graph_cluster_reorder_exit_blocks(GGraphCluster *); - -/* Réordonne les blocs de départ de boucle au mieux. */ -static void g_graph_cluster_reorder_loop_blocks(GGraphCluster *); - -/* Réordonne le départ des liens en entrée de bloc. */ -static void g_graph_cluster_reorder_link_origins(GGraphCluster *, bool); - -/* Décale vers la droite un ensemble de blocs basiques. */ -static void g_graph_cluster_offset_x(GGraphCluster *, gint); - -/* Décale vers le bas un ensemble de blocs basiques. */ -static void g_graph_cluster_set_y(GGraphCluster *, gint); - -/* Calcule l'abscisse d'un lien pour un bloc. */ -static gint _g_graph_cluster_compute_link_position(const GGraphCluster *, size_t, size_t, bool); - -/* Calcule l'abscisse d'un lien à son départ d'un bloc. */ -static gint g_graph_cluster_compute_leaving_link_position(const GGraphCluster *, size_t); - -/* Calcule l'abscisse d'un lien à son arrivée à un bloc. */ -static gint g_graph_cluster_compute_incoming_link_position(const GGraphCluster *, size_t); - /* Ajoute une marge à gauche pour les liens remontants. */ static void g_graph_cluster_insert_left_margin(GGraphCluster *, gint); -/* Détermine les abscisses des liens de boucle en place. */ -static void g_graph_cluster_compute_loop_link_x_positions(GGraphCluster *); - /* Détermine les abscisses de tous les liens en place. */ static void g_graph_cluster_compute_link_x_positions(GGraphCluster *); /* Réserve de l'espace vertical pour les lignes horizontales. */ static void g_graph_cluster_book_hspace_for_links(GGraphCluster *); -/* Détermine les ordonnées de tous les liens en place. */ -static void g_graph_cluster_compute_link_y_positions(GGraphCluster *); - /* Applique les positions calculées pour chaque lien graphique. */ static void g_graph_cluster_resolve_links(const GGraphCluster *); -/* Collecte tous les chefs de file de blocs de code. */ -static GGraphCluster **g_graph_cluster_collect(GGraphCluster *, GGraphCluster **, size_t *); - -/* Collecte tous les liens de chefs de file de blocs de code. */ -static GGraphEdge **g_graph_cluster_collect_edges(GGraphCluster *, GGraphEdge **, size_t *); - /* ------------------------- CALCUL DE REPARTITION DE BLOCS ------------------------- */ @@ -454,80 +152,6 @@ static GGraphCluster *setup_graph_clusters(GLoadedBinary *, const GBlockList *, /* ---------------------------------------------------------------------------------- */ -/****************************************************************************** -* * -* Paramètres : owner = propriétaire du bloc de rattachement. * -* index = indice dans les liens de sortie. * -* * -* Description : Crée un point d'attache pour un lien sortant. * -* * -* Retour : Structure mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static leaving_link_t *create_leaving_link(GGraphCluster *owner, size_t index) -{ - leaving_link_t *result; /* Structure à retourner */ - - result = malloc(sizeof(leaving_link_t)); - - result->owner = owner; - - result->index = index; - - result->straight = false; - result->forced_straight = false; - result->straight_level = SIZE_MAX; - result->cluster_exit = false; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : link = structure à libérer de la mémoire. * -* * -* Description : Détruit un point d'attache pour un lien sortant. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void delete_leaving_link(leaving_link_t *link) -{ - free(link); - -} - - -/****************************************************************************** -* * -* Paramètres : link = information sur un lien à consulter. * -* * -* Description : Calcule l'abscisse d'un lien à son départ d'un bloc. * -* * -* Retour : Abscisse à attribuer à un départ de lien. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static gint compute_leaving_link_position(const leaving_link_t *link) -{ - gint result; /* Position à retourner */ - - result = g_graph_cluster_compute_leaving_link_position(link->owner, link->index); - - return result; - -} - /* ---------------------------------------------------------------------------------- */ @@ -535,1473 +159,21 @@ static gint compute_leaving_link_position(const leaving_link_t *link) /* ---------------------------------------------------------------------------------- */ -/****************************************************************************** -* * -* Paramètres : owner = propriétaire du bloc de rattachement. * -* type = type de lien simple attendu. * -* other = point de départ du lien formé. * -* * -* Description : Crée un point d'attache pour un lien entrant simple. * -* * -* Retour : Structure mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static incoming_link_t *create_incoming_link(GGraphCluster *owner, InstructionLinkType type, leaving_link_t *other) -{ - incoming_link_t *result; /* Structure à retourner */ - GCodeBlock *src; /* Bloc d'origine du lien */ - GCodeBlock *dst; /* Bloc de destination du lien */ - - result = malloc(sizeof(incoming_link_t)); - - result->owner = owner; - - result->type = type; - - src = other->owner->block; - dst = owner->block; - - if (type == ILT_JUMP_IF_TRUE) - result->edge = g_graph_edge_new_true(src, dst, - &other->start[0], &other->start[1], - &result->end[0], &result->end[1]); - - else if (type == ILT_JUMP_IF_FALSE) - result->edge = g_graph_edge_new_false(src, dst, - &other->start[0], &other->start[1], - &result->end[0], &result->end[1]); - - else - result->edge = g_graph_edge_new(src, dst, - &other->start[0], &other->start[1], - &result->end[0], &result->end[1]); - - result->other = other; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : owner = propriétaire du bloc de rattachement. * -* other = point de départ du lien formé. * -* * -* Description : Crée un point d'attache pour un lien entrant de boucle. * -* * -* Retour : Structure mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static incoming_link_t *create_incoming_loop_link(GGraphCluster *owner, const GdkPoint *midpts, leaving_link_t *other) -{ - incoming_link_t *result; /* Structure à retourner */ - GCodeBlock *src; /* Bloc d'origine du lien */ - GCodeBlock *dst; /* Bloc de destination du lien */ - - result = malloc(sizeof(incoming_link_t)); - - result->owner = owner; - - result->type = ILT_LOOP; - - src = other->owner->block; - dst = owner->block; - - result->edge = g_graph_edge_new_loop(src, dst, - &other->start[0], &other->start[1], - &midpts[0], &midpts[1], - &result->end[0], &result->end[1]); - - result->other = other; - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : link = structure à libérer de la mémoire. * -* * -* Description : Détruit un point d'attache pour un lien entrant. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ -static void delete_incoming_link(incoming_link_t *link) -{ - free(link); +/* ---------------------------------------------------------------------------------- */ +/* ENCADREMENTS D'ESPACES VERTICAUX */ +/* ---------------------------------------------------------------------------------- */ -} -/****************************************************************************** -* * -* Paramètres : a = premier lien entrant à comparer. * -* b = second lien entrant à comparer. * -* * -* Description : Compare deux liens entrants. * -* * -* Retour : Bilan de comparaison. * -* * -* Remarques : - * -* * -******************************************************************************/ -static int cmp_incoming_links(const incoming_link_t **a, const incoming_link_t **b) -{ - int result; /* Bilan à retourner */ - gint pos_a; /* Point de départ pour A */ - gint pos_b; /* Point de départ pour B */ - pos_a = compute_leaving_link_position((*a)->other); +/* ---------------------------------------------------------------------------------- */ +/* DESCENDANTS DIRECTS CLASSES PAR RANG */ +/* ---------------------------------------------------------------------------------- */ - pos_b = compute_leaving_link_position((*b)->other); - if (pos_a < pos_b) - result = -1; - - else if (pos_a > pos_b) - result = 1; - - else - result = 0; - - return result; - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* ENCADREMENTS D'ESPACES VERTICAUX */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : manager = structure à initialiser. * -* * -* Description : Initialise les réservations liens verticaux. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void init_vspace_manager(vspace_manager_t *manager) -{ - manager->pending = NULL; - manager->pending_count = 0; - - manager->left = NULL; - manager->left_count = 0; - - manager->right = NULL; - manager->right_count = 0; - -} - - -/****************************************************************************** -* * -* Paramètres : manager = structure à vider. * -* * -* Description : Termine les réservations liens verticaux. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void exit_vspace_manager(vspace_manager_t *manager) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < manager->pending_count; i++) - free(manager->pending[i].pts); - - if (manager->pending != NULL) - free(manager->pending); - - if (manager->left != NULL) - free(manager->left); - - if (manager->right != NULL) - free(manager->right); - -} - - -/****************************************************************************** -* * -* Paramètres : manager = structure à compléter. * -* from = point de départ du lien concerné. * -* to = point d'arrivée du lien concerné. * -* pts = points intermédiaires du tracé complet final. * -* external = précise une sortie du cadre du cluster premier. * -* * -* Description : Inscrit une nouvelle réservation d'espace latéral. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void extend_vspace_manager(vspace_manager_t *manager, leaving_link_t *from, incoming_link_t *to, GdkPoint *pts, bool external) -{ - vspace_booking_t *new; /* Réservation à constituer */ - - manager->pending = realloc(manager->pending, ++manager->pending_count * sizeof(vspace_booking_t)); - - new = &manager->pending[manager->pending_count - 1]; - - new->from = from; - new->to = to; - - new->pts = pts; - - new->external = external; - -} - - -/****************************************************************************** -* * -* Paramètres : manager = gestion des espaces latéraux à consulter. * -* external = précise une sortie du cadre du cluster premier. * -* alloc = emplacement idéal pour l'affichage. [OUT] * -* * -* Description : Détermine l'emplacement requis pour les espaces latéraux. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void compute_vspace_manager_needed_alloc(const vspace_manager_t *manager, bool external, GtkAllocation *alloc) -{ - gint width; /* Largeur supplémentaire */ - size_t count; /* Nombre de liens retenus */ - size_t i; /* Boucle de parcours */ - - width = 0; - - /* Extension de la largeur, à gauche */ - - count = 0; - - for (i = 0; i < manager->left_count; i++) - if (manager->left[i]->external == external) - count++; - - width += count * LINK_MARGIN; - - alloc->x -= width; - - /* Extension de la largeur, à droite */ - - count = 0; - - for (i = 0; i < manager->right_count; i++) - if (manager->right[i]->external == external) - count++; - - width += count * LINK_MARGIN; - - alloc->width += width; - - /* Extension de la hauteur */ - - if (!external) - alloc->height += manager->pending_count * VERTICAL_MARGIN; - -} - - -/****************************************************************************** -* * -* Paramètres : manager = gestion d'espaces latéraux à manipuler. * -* * -* Description : Réorganise au besoin les liens de boucle entre blocs. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void sort_incoming_links_for_vspace_manager(vspace_manager_t *manager) -{ - size_t i; /* Boucle de parcours */ - vspace_booking_t *pending; /* Elément traité */ - gint x1; /* Abscisse de départ de lien */ - size_t idx; /* Indice du lien entrant */ - gint x2; /* Abscisse d'arrivée de lien */ - bool for_left; /* Répartition par la gauche ? */ - - for (i = 0; i < manager->pending_count; i++) - { - pending = &manager->pending[i]; - - x1 = g_graph_cluster_compute_leaving_link_position(pending->from->owner, pending->from->index); - - idx = g_graph_cluster_find_incoming_link(pending->to->owner, pending->from); - - x2 = g_graph_cluster_compute_incoming_link_position(pending->to->owner, idx); - - /** - * Prise en compte d'une boucle while (1); - */ - if (pending->from->owner == pending->to->owner) - for_left = (x2 < x1); - else - for_left = (x1 < x2); - - if (for_left) - { - manager->left = realloc(manager->left, ++manager->left_count * sizeof(vspace_booking_t *)); - manager->left[manager->left_count - 1] = pending; - } - else - { - manager->right = realloc(manager->right, ++manager->right_count * sizeof(vspace_booking_t *)); - manager->right[manager->right_count - 1] = pending; - } - - } - -} - - -/****************************************************************************** -* * -* Paramètres : manager = structure à actualiser. * -* offset = décalage à appliquer. * -* * -* Description : Décale vers la droite un ensemble de points. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void offset_x_vspace_manager(vspace_manager_t *manager, gint offset) -{ - size_t i; /* Boucle de parcours */ - vspace_booking_t *booking; /* Réservation à traiter */ - - for (i = 0; i < manager->left_count; i++) - { - booking = manager->left[i]; - - booking->pts[0].x += offset; - booking->pts[1].x += offset; - - } - - for (i = 0; i < manager->right_count; i++) - { - booking = manager->right[i]; - - booking->pts[0].x += offset; - booking->pts[1].x += offset; - - } - -} - - -/****************************************************************************** -* * -* Paramètres : manager = structure à consulter. * -* needed = espace nécessaire et alloué pour les blocs. * -* external = précise une sortie du cadre du cluster premier. * -* * -* Description : Détermine les abscisses de tous les liens en place. * -* * -* Retour : Eventuelle marge à gauche devenue nécessaire. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static gint compute_loop_link_x_with_vspace_manager(const vspace_manager_t *manager, const GtkAllocation *needed, bool external) -{ - gint result; /* Eventuelle marge à renvoyer */ - size_t count; /* Quantité de liens traités */ - size_t i; /* Boucle de parcours */ - vspace_booking_t *booking; /* Réservation à traiter */ - gint x; /* Position à appliquer */ - - count = 0; - - for (i = 0; i < manager->left_count; i++) - { - booking = manager->left[i]; - - if (booking->external != external) - continue; - - x = ++count * LINK_MARGIN; - - booking->pts[0].x = needed->x - x; - booking->pts[1].x = needed->x - x; - - } - - result = count * LINK_MARGIN; - - count = 0; - - for (i = 0; i < manager->right_count; i++) - { - booking = manager->right[i]; - - if (booking->external != external) - continue; - - x = ++count * LINK_MARGIN; - - booking->pts[0].x = needed->x + needed->width + x; - booking->pts[1].x = needed->x + needed->width + x; - - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : manager = structure à consulter. * -* needed = espace nécessaire et alloué pour les blocs. * -* * -* Description : Détermine les ordonnées de tous les liens en place. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void compute_loop_link_y_with_vspace_manager(const vspace_manager_t *manager, const GtkAllocation *needed) -{ - gint real_bottom; /* Point de départ réel */ - size_t i; /* Boucle de parcours */ - vspace_booking_t *booking; /* Réservation à traiter */ - - real_bottom = needed->y + needed->height - manager->pending_count * VERTICAL_MARGIN; - - for (i = 0; i < manager->pending_count; i++) - { - booking = &manager->pending[i]; - - /** - * On corrige le raccourci pris sans distinction de type de lien dans - * la fonction g_graph_cluster_compute_link_y_positions(). - */ - - booking->from->start[1].y = real_bottom + (i + 1) * VERTICAL_MARGIN; - - /* Définition de l'ordonnée des points du lien */ - - booking->pts[0].y = booking->from->start[1].y; - - booking->pts[1].y = booking->to->end[0].y; - - } - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* DESCENDANTS DIRECTS CLASSES PAR RANG */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : start = abscisse de départ de ligne. * -* * -* Description : Prépare une réservation d'espace pour ligne horizontale. * -* * -* Retour : Structure mise en place pour la conservation d'informations. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static hspace_booking *create_hspace_booking(gint start) -{ - hspace_booking *result; /* Structure à retourner */ - - result = malloc(sizeof(hspace_booking)); - - result->start = start; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : a = première réservation d'espace à comparer. * -* b = seconde réservation d'espace à comparer. * -* * -* Description : Compare deux réservations d'espace. * -* * -* Retour : Bilan de comparaison. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static int cmp_hspace_booking_r2l(const hspace_booking **a, const hspace_booking **b) -{ - int result; /* Bilan à retourner */ - - if ((*a)->start > (*b)->start) - result = -1; - - else if ((*a)->start < (*b)->start) - result = 1; - - else - { - assert(false); - result = 0; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : a = première réservation d'espace à comparer. * -* b = seconde réservation d'espace à comparer. * -* * -* Description : Compare deux réservations d'espace. * -* * -* Retour : Bilan de comparaison. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static int cmp_hspace_booking_l2r(const hspace_booking **a, const hspace_booking **b) -{ - int result; /* Bilan à retourner */ - - if ((*a)->start < (*b)->start) - result = -1; - - else if ((*a)->start > (*b)->start) - result = 1; - - else - { - assert(false); - result = 0; - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = structure à initialiser. [OUT] * -* cluster = chef de file d'un ensemble de blocs. * -* * -* Description : Initialise la gestion d'un ensemble de blocs de même rang. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void init_graph_rank(graph_rank_t *grank, GGraphCluster *cluster) -{ - grank->right2left = NULL; - grank->r2l_count = 0; - - grank->left2right = NULL; - grank->l2r_count = 0; - - grank->clusters = malloc(sizeof(GGraphCluster *)); - grank->count = 1; - - grank->clusters[0] = cluster; - - init_vspace_manager(&grank->vspaces); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = structure à vider. * -* * -* Description : Termine la gestion d'un ensemble de blocs de même rang. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void exit_graph_rank(graph_rank_t *grank) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->r2l_count; i++) - free(grank->right2left[i]); - - if (grank->right2left != NULL) - free(grank->right2left); - - for (i = 0; i < grank->l2r_count; i++) - free(grank->left2right[i]); - - if (grank->left2right != NULL) - free(grank->left2right); - - assert(grank->clusters != NULL); - - free(grank->clusters); - - exit_vspace_manager(&grank->vspaces); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de même rang à consulter. * -* * -* Description : Assigne à un ensemble de blocs un emplacement initial. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void reset_graph_rank_allocation(const graph_rank_t *grank) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_reset_allocation(grank->clusters[i]); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de même rang à consulter. * -* * -* Description : Fournit le rang d'un ensemble de blocs. * -* * -* Retour : Rang d'un ensemble de blocs de même rang. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static size_t get_graph_rank(const graph_rank_t *grank) -{ - size_t result; /* Rang à retourner */ - - result = g_code_block_get_rank(grank->clusters[0]->block); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : a = premier ensemble de même rang à comparer. * -* b = second ensemble de même rang à comparer. * -* * -* Description : Compare deux rangées de blocs de code. * -* * -* Retour : Bilan de comparaison. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static int cmp_graph_rank(const graph_rank_t *a, const graph_rank_t *b) -{ - int result; /* Bilan à retourner */ - size_t level_a; /* Niveau de l'ensemble A */ - size_t level_b; /* Niveau de l'ensemble B */ - - level_a = get_graph_rank(a); - level_b = get_graph_rank(b); - - if (level_a < level_b) - result = -1; - - else if (level_a > level_b) - result = 1; - - else - result = 0; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = structure à compléter. * -* cluster = chef de file d'un ensemble de blocs. * -* * -* Description : Etend un ensemble de blocs de même rang. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void extend_graph_rank(graph_rank_t *grank, GGraphCluster *cluster) -{ - grank->count++; - grank->clusters = realloc(grank->clusters, sizeof(GGraphCluster *) * grank->count); - - grank->clusters[grank->count - 1] = cluster; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = structure à compléter. * -* cluster = chef de file d'un ensemble de blocs. * -* * -* Description : Détermine si un groupe de blocs contient un bloc particulier.* -* * -* Retour : true si le chef est bien contenu, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool has_graph_rank_cluster(const graph_rank_t *grank, GGraphCluster *cluster) -{ - bool result; /* Bilan à renvoyer */ - size_t i; /* Boucle de parcours */ - - result = false; - - for (i = 0; i < grank->count && !result; i++) - result = (grank->clusters[i] == cluster); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de descendants d'un même rang. * -* from = point de départ du lien concerné. * -* to = point d'arrivée du lien concerné. * -* pts = points intermédiaires du tracé complet final. * -* external = précise une sortie du cadre du cluster premier. * -* * -* Description : Inscrit à l'endroit idéal une réservation d'espace latéral. * -* * -* Retour : true si la demande a bien été traitée. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool extend_graph_rank_vspace_manager(graph_rank_t *grank, leaving_link_t *from, incoming_link_t *to, GdkPoint *pts, bool external) -{ - bool result; /* Bilan à renvoyer */ - - result = has_graph_rank_cluster(grank, from->owner); - - if (result) - extend_vspace_manager(&grank->vspaces, from, to, pts, external); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de descendants d'un même rang. * -* all = table regroupant tous les groupes créés. * -* * -* Description : Met en place les embryons de liens nécessaires. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void define_graph_rank_links(const graph_rank_t *grank, GHashTable *all) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_define_links(grank->clusters[i], all); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de descendants d'un même rang. * -* * -* Description : Repère les liens marquants à destination d'autres blocs. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void setup_graph_rank_links(const graph_rank_t *grank) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_setup_links(grank->clusters[i]); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de descendants d'un même rang. * -* last = indique s'il s'agit du dernier étage de l'ensemble. * -* alloc = emplacement idéal pour l'affichage. [OUT] * -* * -* Description : Détermine l'emplacement requis d'un ensemble de blocs. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void compute_graph_rank_needed_alloc(const graph_rank_t *grank, bool last, GtkAllocation *alloc) -{ - GtkAllocation needed; /* Taille requise */ - - switch (grank->count) - { - case 1: - - g_graph_cluster_compute_needed_alloc(grank->clusters[0], &needed); - - if (needed.x < alloc->x) - { - alloc->width += (alloc->x - needed.x); - alloc->x = needed.x; - } - - if ((needed.x + needed.width) > (alloc->x + alloc->width)) - alloc->width += needed.x + needed.width - alloc->x - alloc->width; - - /* La hauteur maximale n'est présente qu'avec le dernier morceau */ - if (last) - { - if ((needed.y + needed.height) > (alloc->y + alloc->height)) - alloc->height += needed.y + needed.height - alloc->y - alloc->height; - } - - break; - - default: - - assert(grank->count >= 2); - - g_graph_cluster_compute_needed_alloc(grank->clusters[0], &needed); - - if (needed.x < alloc->x) - { - alloc->width += (alloc->x - needed.x); - alloc->x = needed.x; - } - - /* La hauteur maximale n'est présente qu'avec le dernier morceau */ - if (last) - { - if ((needed.y + needed.height) > (alloc->y + alloc->height)) - alloc->height += needed.y + needed.height - alloc->y - alloc->height; - } - - g_graph_cluster_compute_needed_alloc(grank->clusters[grank->count - 1], &needed); - - if ((needed.x + needed.width) > (alloc->x + alloc->width)) - alloc->width += needed.x + needed.width - alloc->x - alloc->width; - - /* La hauteur maximale n'est présente qu'avec le dernier morceau */ - if (last) - { - if ((needed.y + needed.height) > (alloc->y + alloc->height)) - alloc->height += needed.y + needed.height - alloc->y - alloc->height; - } - - break; - - } - - compute_vspace_manager_needed_alloc(&grank->vspaces, false, alloc); - -} - - -/****************************************************************************** -* * -* Paramètres : iter = début de la boucle de parcours. * -* loop = nombre d'itérations à mener. * -* base = position de base sur l'axe des abscisses. * -* dir = direction du parcours. * -* * -* Description : Affine l'abscisse d'un ensemble de blocs de même rang. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void _place_graph_rank_clusters(GGraphCluster **iter, size_t loop, gint base, int dir) -{ - size_t i; /* Boucle de parcours */ - GtkAllocation needed; /* Taille requise */ - - assert(dir == -1 || dir == 1); - - for (i = 0; i < loop; i++, iter += dir) - { - g_graph_cluster_dispatch_x(*iter); - - g_graph_cluster_compute_needed_alloc(*iter, &needed); - - if (dir > 0) - g_graph_cluster_offset_x(*iter, base - needed.x); - else - g_graph_cluster_offset_x(*iter, base - needed.x - needed.width); - - base += dir * (needed.width + HORIZONTAL_MARGIN); - - } - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à manipuler. * -* * -* Description : Organise la disposition d'un ensemble de blocs basiques. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void dispatch_x_graph_rank(const graph_rank_t *grank) -{ - size_t mid; /* Position centrale de départ */ - gint start; /* Position initiale de départ */ - - if (grank->count % 2 == 1) - { - if (grank->count > 1) - { - mid = grank->count / 2; - - start = grank->clusters[mid]->alloc.x - HORIZONTAL_MARGIN; - - _place_graph_rank_clusters(grank->clusters + mid - 1, mid, start, -1); - - start *= -1; - - _place_graph_rank_clusters(grank->clusters + mid + 1, mid, start, 1); - - } - - else - g_graph_cluster_dispatch_x(grank->clusters[0]); - - } - - else - { - mid = grank->count / 2 - 1; - - start = - HORIZONTAL_MARGIN / 2; - - _place_graph_rank_clusters(grank->clusters + mid, mid + 1, start, -1); - - start *= -1; - - _place_graph_rank_clusters(grank->clusters + mid + 1, mid + 1, start, 1); - - } - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à actualiser. * -* * -* Description : Réorganise au besoin les liens entrants un ensemble de blocs.* -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void sort_graph_rank_incoming_links(graph_rank_t *grank) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_sort_incoming_links(grank->clusters[i]); - - sort_incoming_links_for_vspace_manager(&grank->vspaces); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à actualiser. * -* * -* Description : Réordonne les blocs sortant d'un ensemble. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void reorder_graph_rank_exit_blocks(graph_rank_t *grank) -{ - GGraphCluster **exit_2_left; /* Liste avec sortie à gauche */ - GGraphCluster **exit_2_right; /* Liste avec sortie à droite */ - GGraphCluster **no_exit; /* Liste sans sortie */ - size_t count_2_left; /* Quantité de présents */ - size_t count_2_right; /* Quantité de présents */ - size_t count_no; /* Quantité de présents */ - size_t i; /* Boucle de parcours */ - bool l2r; /* Détermination de catégorie */ - - if (grank->count > 1) - { - exit_2_left = malloc(grank->count * sizeof(GGraphCluster *)); - exit_2_right = malloc(grank->count * sizeof(GGraphCluster *)); - no_exit = malloc(grank->count * sizeof(GGraphCluster *)); - - count_2_left = 0; - count_2_right = 0; - count_no = 0; - - for (i = 0; i < grank->count; i++) - { - if (g_graph_cluster_has_exit_link(grank->clusters[i], &l2r)) - { - if (l2r) - exit_2_right[count_2_right++] = grank->clusters[i]; - else - exit_2_left[count_2_left++] = grank->clusters[i]; - } - else - no_exit[count_no++] = grank->clusters[i]; - - } - - assert((count_2_left + count_2_right + count_no) == grank->count); - - qsort_r(exit_2_left, count_2_left, sizeof(GGraphCluster *), - (__compar_d_fn_t)g_graph_cluster_compare_by_exit, (bool []){ false }); - - qsort_r(exit_2_right, count_2_right, sizeof(GGraphCluster *), - (__compar_d_fn_t)g_graph_cluster_compare_by_exit, (bool []){ true }); - - grank->count = 0; - - for (i = 0; i < count_2_left; i++) - grank->clusters[grank->count++] = exit_2_left[i]; - - for (i = 0; i < count_no; i++) - grank->clusters[grank->count++] = no_exit[i]; - - for (i = 0; i < count_2_right; i++) - grank->clusters[grank->count++] = exit_2_right[i]; - - } - - for (i = 0; i < grank->count; i++) - g_graph_cluster_reorder_exit_blocks(grank->clusters[i]); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à actualiser. * -* * -* Description : Réordonne les blocs de départ de boucle d'un ensemble. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void reorder_graph_rank_loop_blocks(graph_rank_t *grank) -{ - size_t i; /* Boucle de parcours #1 */ - size_t k; /* Boucle de parcours #2 */ - GGraphCluster *tmp; /* Stockage temporaire */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_reorder_loop_blocks(grank->clusters[i]); - - if (grank->count > 1) - { - /* Placement des départs de boucle à gauche ! */ - - for (i = 0; i < grank->vspaces.left_count; i++) - { - tmp = grank->vspaces.left[i]->from->owner; - - for (k = 0; k < grank->count; k++) - if (grank->clusters[k] == tmp) - break; - - assert(k < grank->count); - - memmove(&grank->clusters[1], &grank->clusters[0], - k * sizeof(GGraphCluster *)); - - grank->clusters[0] = tmp; - - g_graph_cluster_reorder_link_origins(tmp, true); - - } - - /* Placement des départs de boucle à droite ! */ - - for (i = 0; i < grank->vspaces.right_count; i++) - { - tmp = grank->vspaces.right[i]->from->owner; - - for (k = 0; k < grank->count; k++) - if (grank->clusters[k] == tmp) - break; - - assert(k < grank->count); - - memmove(&grank->clusters[k], &grank->clusters[k + 1], - (grank->count - k - 1) * sizeof(GGraphCluster *)); - - grank->clusters[grank->count - 1] = tmp; - - g_graph_cluster_reorder_link_origins(tmp, false); - - } - - } - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à actualiser. * -* offset = décalage à appliquer. * -* * -* Description : Décale vers la droite un ensemble de blocs basiques. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void offset_x_graph_rank(graph_rank_t *grank, gint offset) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_offset_x(grank->clusters[i], offset); - - offset_x_vspace_manager(&grank->vspaces, offset); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à actualiser. * -* needed = espace nécessaire et alloué pour les blocs. * -* * -* Description : Détermine les abscisses des liens de boucle en place. * -* * -* Retour : Eventuelle marge à gauche devenue nécessaire. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static gint compute_loop_link_x_positions_with_graph_rank(const graph_rank_t *grank, const GtkAllocation *needed) -{ - gint result; /* Eventuelle marge à renvoyer */ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_compute_loop_link_x_positions(grank->clusters[i]); - - result = compute_loop_link_x_with_vspace_manager(&grank->vspaces, needed, false); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à actualiser. * -* base = position ordonnée à appliquer. * -* * -* Description : Décale vers le bas un ensemble de blocs basiques. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void set_y_for_graph_rank(const graph_rank_t *grank, gint *base) -{ - gint max; /* Hauteur maximale rencontrée */ - size_t i; /* Boucle de parcours */ - GGraphCluster *sub; /* Sous-ensemble traité */ - GtkAllocation alloc; /* Allocation courante */ - - /* On ajoute l'espace vertical pour les lignes horizontales */ - - if (grank->r2l_count > grank->l2r_count) - max = grank->r2l_count; - else - max = grank->l2r_count; - - *base += VERTICAL_MARGIN; - - /** - * Comme les liens purement verticaux n'entrainent pas de réservation, - * il n'y a potentiellement pas toujours d'espace à ajouter. - */ - - if (max > 0) - { - *base += ((max - 1) * LINK_MARGIN); - *base += VERTICAL_MARGIN; - } - - /* On ajoute l'espace requis pour l'affichage des blocs */ - - max = 0; - - for (i = 0; i < grank->count; i++) - { - sub = grank->clusters[i]; - - g_graph_cluster_set_y(sub, *base); - - g_graph_cluster_compute_needed_alloc(sub, &alloc); - - if ((alloc.y + alloc.height) > max) - max = alloc.y + alloc.height; - - } - - *base = max; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à actualiser. * -* needed = espace nécessaire et alloué pour les blocs. * -* * -* Description : Détermine les ordonnées de tous les liens en place. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void compute_loop_link_with_graph_rank(const graph_rank_t *grank, const GtkAllocation *needed) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < grank->count; i++) - g_graph_cluster_compute_link_y_positions(grank->clusters[i]); - - compute_loop_link_y_with_vspace_manager(&grank->vspaces, needed); - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à analyser. * -* block = bloc de code à retrouver. * -* * -* Description : Recherche le groupe de blocs avec un bloc donné comme chef. * -* * -* Retour : Groupe trouvé ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GGraphCluster *find_cluster_by_block_in_graph_rank(const graph_rank_t *grank, GCodeBlock *block) -{ - GGraphCluster *result; /* Trouvaille à retourner */ - size_t i; /* Boucle de parcours */ - - result = NULL; - - for (i = 0; i < grank->count && result == NULL; i++) - result = g_graph_cluster_find_by_block(grank->clusters[i], block); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à analyser. * -* widget = composant graphique à retrouver. * -* * -* Description : Recherche le groupe de blocs avec un composant comme chef. * -* * -* Retour : Groupe trouvé ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GGraphCluster *find_cluster_by_widget_in_graph_rank(const graph_rank_t *grank, GtkWidget *widget) -{ - GGraphCluster *result; /* Trouvaille à retourner */ - size_t i; /* Boucle de parcours */ - - result = NULL; - - for (i = 0; i < grank->count && result == NULL; i++) - result = g_graph_cluster_find_by_widget(grank->clusters[i], widget); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à analyser. * -* list = liste en cours de constitution. [OUT] * -* count = taille de cette liste. [OUT] * -* * -* Description : Collecte tous les chefs de file de blocs de code. * -* * -* Retour : Liste de graphiques de blocs rassemblés. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GGraphCluster **collect_graph_ranks_clusters(const graph_rank_t *grank, GGraphCluster **list, size_t *count) -{ - GGraphCluster **result; /* Liste complétée à renvoyer */ - size_t i; /* Boucle de parcours */ - - result = list; - - for (i = 0; i < grank->count; i++) - result = g_graph_cluster_collect(grank->clusters[i], result, count); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : grank = ensemble de blocs de même rang à analyser. * -* list = liste en cours de constitution. [OUT] * -* count = taille de cette liste. [OUT] * -* * -* Description : Collecte tous les liens de chefs de file de blocs de code. * -* * -* Retour : Liste de liens graphiques de blocs rassemblés. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GGraphEdge **collect_graph_ranks_cluster_edges(const graph_rank_t *grank, GGraphEdge **list, size_t *count) -{ - GGraphEdge **result; /* Liste complétée à renvoyer */ - size_t i; /* Boucle de parcours */ - - result = list; - - for (i = 0; i < grank->count; i++) - result = g_graph_cluster_collect_edges(grank->clusters[i], result, count); - - return result; - -} @@ -2178,7 +350,7 @@ GGraphCluster *g_graph_cluster_new(GCodeBlock *block, segcnt_list *highlighted, * * ******************************************************************************/ -static void g_graph_cluster_reset_allocation(GGraphCluster *cluster) +void g_graph_cluster_reset_allocation(GGraphCluster *cluster) { GtkRequisition requisition; /* Taille à l'écran actuelle */ size_t i; /* Boucle de parcours */ @@ -2344,7 +516,7 @@ static void g_graph_cluster_extend_vspace_manager(GGraphCluster *target, leaving * * ******************************************************************************/ -static void g_graph_cluster_define_links(GGraphCluster *cluster, GHashTable *all) +void g_graph_cluster_define_links(GGraphCluster *cluster, GHashTable *all) { size_t dcount; /* Nombre de liens de dest. */ block_link_t *links; /* Liens associés au bloc */ @@ -2539,7 +711,7 @@ static void g_graph_cluster_define_links(GGraphCluster *cluster, GHashTable *all * * ******************************************************************************/ -static void g_graph_cluster_setup_links(GGraphCluster *cluster) +void g_graph_cluster_setup_links(GGraphCluster *cluster) { size_t i; /* Boucle de parcours #1 */ leaving_link_t *leaving; /* Départ de lien */ @@ -2633,7 +805,7 @@ static void g_graph_cluster_setup_links(GGraphCluster *cluster) * * ******************************************************************************/ -static void g_graph_cluster_dispatch_x(GGraphCluster *cluster) +void g_graph_cluster_dispatch_x(GGraphCluster *cluster) { size_t i; /* Boucle de parcours #1 */ leaving_link_t *straight_leaving; /* Lien à présenter vertical */ @@ -2786,7 +958,7 @@ static void g_graph_cluster_dispatch_x(GGraphCluster *cluster) * * ******************************************************************************/ -static void g_graph_cluster_sort_incoming_links(GGraphCluster *cluster) +void g_graph_cluster_sort_incoming_links(GGraphCluster *cluster) { size_t i; /* Boucle de parcours */ @@ -2813,7 +985,7 @@ static void g_graph_cluster_sort_incoming_links(GGraphCluster *cluster) * * ******************************************************************************/ -static size_t g_graph_cluster_find_incoming_link(const GGraphCluster *cluster, const leaving_link_t *leaving) +size_t g_graph_cluster_find_incoming_link(const GGraphCluster *cluster, const leaving_link_t *leaving) { size_t result; /* Indice à retourner */ @@ -2841,7 +1013,7 @@ static size_t g_graph_cluster_find_incoming_link(const GGraphCluster *cluster, c * * ******************************************************************************/ -static bool g_graph_cluster_has_exit_link(GGraphCluster *cluster, bool *l2r) +bool g_graph_cluster_has_exit_link(GGraphCluster *cluster, bool *l2r) { bool result; /* Bilan à retourner */ size_t i; /* Boucle de parcours */ @@ -2891,7 +1063,7 @@ static bool g_graph_cluster_has_exit_link(GGraphCluster *cluster, bool *l2r) * * ******************************************************************************/ -static int g_graph_cluster_compare_by_exit(const GGraphCluster **cluster, const GGraphCluster **other, const bool *l2r) +int g_graph_cluster_compare_by_exit(const GGraphCluster **cluster, const GGraphCluster **other, const bool *l2r) { int result; /* Bilan à renvoyer */ size_t i; /* Boucle de parcours */ @@ -2959,7 +1131,7 @@ static int g_graph_cluster_compare_by_exit(const GGraphCluster **cluster, const * * ******************************************************************************/ -static void g_graph_cluster_reorder_exit_blocks(GGraphCluster *cluster) +void g_graph_cluster_reorder_exit_blocks(GGraphCluster *cluster) { size_t i; /* Boucle de parcours */ @@ -2981,7 +1153,7 @@ static void g_graph_cluster_reorder_exit_blocks(GGraphCluster *cluster) * * ******************************************************************************/ -static void g_graph_cluster_reorder_loop_blocks(GGraphCluster *cluster) +void g_graph_cluster_reorder_loop_blocks(GGraphCluster *cluster) { size_t i; /* Boucle de parcours */ @@ -3005,7 +1177,7 @@ static void g_graph_cluster_reorder_loop_blocks(GGraphCluster *cluster) * * ******************************************************************************/ -static void g_graph_cluster_reorder_link_origins(GGraphCluster *cluster, bool left) +void g_graph_cluster_reorder_link_origins(GGraphCluster *cluster, bool left) { size_t i; /* Boucle de parcours #1 */ leaving_link_t *origin; /* Autre extrémité du lien */ @@ -3058,7 +1230,7 @@ static void g_graph_cluster_reorder_link_origins(GGraphCluster *cluster, bool le * * ******************************************************************************/ -static void g_graph_cluster_offset_x(GGraphCluster *cluster, gint offset) +void g_graph_cluster_offset_x(GGraphCluster *cluster, gint offset) { size_t i; /* Boucle de parcours */ @@ -3085,7 +1257,7 @@ static void g_graph_cluster_offset_x(GGraphCluster *cluster, gint offset) * * ******************************************************************************/ -static void g_graph_cluster_set_y(GGraphCluster *cluster, gint base) +void g_graph_cluster_set_y(GGraphCluster *cluster, gint base) { size_t i; /* Boucle de parcours */ @@ -3265,7 +1437,7 @@ void g_graph_cluster_place(GGraphCluster *cluster, GtkGraphDisplay *display) * * ******************************************************************************/ -static gint _g_graph_cluster_compute_link_position(const GGraphCluster *cluster, size_t index, size_t half, bool odd) +gint _g_graph_cluster_compute_link_position(const GGraphCluster *cluster, size_t index, size_t half, bool odd) { gint result; /* Position à retourner */ gint mid_x; /* Abscisse centrale */ @@ -3313,7 +1485,7 @@ static gint _g_graph_cluster_compute_link_position(const GGraphCluster *cluster, * * ******************************************************************************/ -static gint g_graph_cluster_compute_leaving_link_position(const GGraphCluster *cluster, size_t index) +gint g_graph_cluster_compute_leaving_link_position(const GGraphCluster *cluster, size_t index) { gint result; /* Position à retourner */ size_t half; /* Indice de répartition égale */ @@ -3345,7 +1517,7 @@ static gint g_graph_cluster_compute_leaving_link_position(const GGraphCluster *c * * ******************************************************************************/ -static gint g_graph_cluster_compute_incoming_link_position(const GGraphCluster *cluster, size_t index) +gint g_graph_cluster_compute_incoming_link_position(const GGraphCluster *cluster, size_t index) { gint result; /* Position à retourner */ size_t half; /* Indice de répartition égale */ @@ -3441,7 +1613,7 @@ static void g_graph_cluster_insert_left_margin(GGraphCluster *cluster, gint marg * * ******************************************************************************/ -static void g_graph_cluster_compute_loop_link_x_positions(GGraphCluster *cluster) +void g_graph_cluster_compute_loop_link_x_positions(GGraphCluster *cluster) { GtkAllocation alloc; /* Emplacement à faire évoluer */ gint margin; /* Marge à gauche éventuelle */ @@ -3680,7 +1852,7 @@ static void g_graph_cluster_book_hspace_for_links(GGraphCluster *cluster) * * ******************************************************************************/ -static void g_graph_cluster_compute_link_y_positions(GGraphCluster *cluster) +void g_graph_cluster_compute_link_y_positions(GGraphCluster *cluster) { gint y; /* Ordonnée d'application */ size_t i; /* Boucle de parcours */ @@ -3855,7 +2027,7 @@ GGraphCluster *g_graph_cluster_find_by_widget(GGraphCluster *cluster, GtkWidget * * ******************************************************************************/ -static GGraphCluster **g_graph_cluster_collect(GGraphCluster *cluster, GGraphCluster **list, size_t *count) +GGraphCluster **g_graph_cluster_collect(GGraphCluster *cluster, GGraphCluster **list, size_t *count) { GGraphCluster **result; /* Liste complétée à renvoyer */ size_t i; /* Boucle de parcours */ @@ -3887,7 +2059,7 @@ static GGraphCluster **g_graph_cluster_collect(GGraphCluster *cluster, GGraphClu * * ******************************************************************************/ -static GGraphEdge **g_graph_cluster_collect_edges(GGraphCluster *cluster, GGraphEdge **list, size_t *count) +GGraphEdge **g_graph_cluster_collect_edges(GGraphCluster *cluster, GGraphEdge **list, size_t *count) { GGraphEdge **result; /* Liste complétée à renvoyer */ size_t i; /* Boucle de parcours */ diff --git a/src/gtkext/graph/hspace.c b/src/gtkext/graph/hspace.c new file mode 100644 index 0000000..4294050 --- /dev/null +++ b/src/gtkext/graph/hspace.c @@ -0,0 +1,125 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hspace.c - encadrement des espaces horizontaux réservés + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#include "hspace.h" + + +#include +#include +#ifndef NDEBUG +# include +#endif + + + +/****************************************************************************** +* * +* Paramètres : start = abscisse de départ de ligne. * +* * +* Description : Prépare une réservation d'espace pour ligne horizontale. * +* * +* Retour : Structure mise en place pour la conservation d'informations. * +* * +* Remarques : - * +* * +******************************************************************************/ + +hspace_booking *create_hspace_booking(gint start) +{ + hspace_booking *result; /* Structure à retourner */ + + result = malloc(sizeof(hspace_booking)); + + result->start = start; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : a = première réservation d'espace à comparer. * +* b = seconde réservation d'espace à comparer. * +* * +* Description : Compare deux réservations d'espace. * +* * +* Retour : Bilan de comparaison. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int cmp_hspace_booking_r2l(const hspace_booking **a, const hspace_booking **b) +{ + int result; /* Bilan à retourner */ + + if ((*a)->start > (*b)->start) + result = -1; + + else if ((*a)->start < (*b)->start) + result = 1; + + else + { + assert(false); + result = 0; + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : a = première réservation d'espace à comparer. * +* b = seconde réservation d'espace à comparer. * +* * +* Description : Compare deux réservations d'espace. * +* * +* Retour : Bilan de comparaison. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int cmp_hspace_booking_l2r(const hspace_booking **a, const hspace_booking **b) +{ + int result; /* Bilan à retourner */ + + if ((*a)->start < (*b)->start) + result = -1; + + else if ((*a)->start > (*b)->start) + result = 1; + + else + { + assert(false); + result = 0; + } + + return result; + +} diff --git a/src/gtkext/graph/hspace.h b/src/gtkext/graph/hspace.h new file mode 100644 index 0000000..ee0b778 --- /dev/null +++ b/src/gtkext/graph/hspace.h @@ -0,0 +1,52 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hspace.h - prototypes pour l'encadrement des espaces horizontaux réservés + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#ifndef _GTKEXT_GRAPH_HSPACE_H +#define _GTKEXT_GRAPH_HSPACE_H + + +#include + + + +/* Réservation pour les lignes horizontales */ +typedef struct _hspace_booking +{ + gint start; /* Abscisse de départ de ligne */ + size_t index; /* Indice de rangée verticale */ + +} hspace_booking; + + +/* Prépare une réservation d'espace pour ligne horizontale. */ +hspace_booking *create_hspace_booking(gint); + +/* Compare deux réservations d'espace. */ +int cmp_hspace_booking_r2l(const hspace_booking **, const hspace_booking **); + +/* Compare deux réservations d'espace. */ +int cmp_hspace_booking_l2r(const hspace_booking **, const hspace_booking **); + + + +#endif /* _GTKEXT_GRAPH_HSPACE_H */ diff --git a/src/gtkext/graph/incoming.c b/src/gtkext/graph/incoming.c new file mode 100644 index 0000000..8e25b8d --- /dev/null +++ b/src/gtkext/graph/incoming.c @@ -0,0 +1,184 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * incoming.c - liens entrants d'un bloc de code dans une représentation graphique + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#include "incoming.h" + + +#include + + +#include "leaving.h" + + + +/****************************************************************************** +* * +* Paramètres : owner = propriétaire du bloc de rattachement. * +* type = type de lien simple attendu. * +* other = point de départ du lien formé. * +* * +* Description : Crée un point d'attache pour un lien entrant simple. * +* * +* Retour : Structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +incoming_link_t *create_incoming_link(GGraphCluster *owner, InstructionLinkType type, leaving_link_t *other) +{ + incoming_link_t *result; /* Structure à retourner */ + GCodeBlock *src; /* Bloc d'origine du lien */ + GCodeBlock *dst; /* Bloc de destination du lien */ + + result = malloc(sizeof(incoming_link_t)); + + result->owner = owner; + + result->type = type; + + src = g_graph_cluster_get_block(other->owner); + dst = g_graph_cluster_get_block(owner); + + if (type == ILT_JUMP_IF_TRUE) + result->edge = g_graph_edge_new_true(src, dst, + &other->start[0], &other->start[1], + &result->end[0], &result->end[1]); + + else if (type == ILT_JUMP_IF_FALSE) + result->edge = g_graph_edge_new_false(src, dst, + &other->start[0], &other->start[1], + &result->end[0], &result->end[1]); + + else + result->edge = g_graph_edge_new(src, dst, + &other->start[0], &other->start[1], + &result->end[0], &result->end[1]); + + g_object_unref(G_OBJECT(src)); + g_object_unref(G_OBJECT(dst)); + + result->other = other; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : owner = propriétaire du bloc de rattachement. * +* other = point de départ du lien formé. * +* * +* Description : Crée un point d'attache pour un lien entrant de boucle. * +* * +* Retour : Structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +incoming_link_t *create_incoming_loop_link(GGraphCluster *owner, const GdkPoint *midpts, leaving_link_t *other) +{ + incoming_link_t *result; /* Structure à retourner */ + GCodeBlock *src; /* Bloc d'origine du lien */ + GCodeBlock *dst; /* Bloc de destination du lien */ + + result = malloc(sizeof(incoming_link_t)); + + result->owner = owner; + + result->type = ILT_LOOP; + + src = g_graph_cluster_get_block(other->owner); + dst = g_graph_cluster_get_block(owner); + + result->edge = g_graph_edge_new_loop(src, dst, + &other->start[0], &other->start[1], + &midpts[0], &midpts[1], + &result->end[0], &result->end[1]); + + g_object_unref(G_OBJECT(src)); + g_object_unref(G_OBJECT(dst)); + + result->other = other; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : link = structure à libérer de la mémoire. * +* * +* Description : Détruit un point d'attache pour un lien entrant. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_incoming_link(incoming_link_t *link) +{ + free(link); + +} + + +/****************************************************************************** +* * +* Paramètres : a = premier lien entrant à comparer. * +* b = second lien entrant à comparer. * +* * +* Description : Compare deux liens entrants. * +* * +* Retour : Bilan de comparaison. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int cmp_incoming_links(const incoming_link_t **a, const incoming_link_t **b) +{ + int result; /* Bilan à retourner */ + gint pos_a; /* Point de départ pour A */ + gint pos_b; /* Point de départ pour B */ + + pos_a = compute_leaving_link_position((*a)->other); + + pos_b = compute_leaving_link_position((*b)->other); + + if (pos_a < pos_b) + result = -1; + + else if (pos_a > pos_b) + result = 1; + + else + result = 0; + + return result; + +} diff --git a/src/gtkext/graph/incoming.h b/src/gtkext/graph/incoming.h new file mode 100644 index 0000000..d08eb46 --- /dev/null +++ b/src/gtkext/graph/incoming.h @@ -0,0 +1,67 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * incoming.h - prototypes pour les liens entrants d'un bloc de code dans une représentation graphique + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#ifndef _GTKEXT_GRAPH_INCOMING_H +#define _GTKEXT_GRAPH_INCOMING_H + + +#include "cluster.h" +#include "edge.h" + + + +/* Depuis leaving.h : détails sur le départ d'un lien */ +typedef struct _leaving_link_t leaving_link_t; + +/* Définition du tracé d'un lien */ +typedef struct _incoming_link_t +{ + GGraphCluster *owner; /* Propriétaire du lien */ + + InstructionLinkType type; /* Complexité du tracé */ + + const size_t *hslot; /* Couche horizontale réservée */ + GdkPoint end[2]; /* Point d'arrivée final */ + + GGraphEdge *edge; /* Lien complet en préparation */ + + leaving_link_t *other; /* Autre extrémité du lien */ + +} incoming_link_t; + + +/* Crée un point d'attache pour un lien entrant simple. */ +incoming_link_t *create_incoming_link(GGraphCluster *, InstructionLinkType, leaving_link_t *); + +/* Crée un point d'attache pour un lien entrant de boucle. */ +incoming_link_t *create_incoming_loop_link(GGraphCluster *, const GdkPoint *, leaving_link_t *); + +/* Détruit un point d'attache pour un lien entrant. */ +void delete_incoming_link(incoming_link_t *); + +/* Compare deux liens entrants. */ +int cmp_incoming_links(const incoming_link_t **, const incoming_link_t **); + + + +#endif /* _GTKEXT_GRAPH_INCOMING_H */ diff --git a/src/gtkext/graph/leaving.c b/src/gtkext/graph/leaving.c new file mode 100644 index 0000000..ad07f04 --- /dev/null +++ b/src/gtkext/graph/leaving.c @@ -0,0 +1,107 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * leaving.c - liens sortants d'un bloc de code dans une représentation graphique + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#include "leaving.h" + + +#include + + +#include "cluster-int.h" +#include "incoming.h" + + + +/****************************************************************************** +* * +* Paramètres : owner = propriétaire du bloc de rattachement. * +* index = indice dans les liens de sortie. * +* * +* Description : Crée un point d'attache pour un lien sortant. * +* * +* Retour : Structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +leaving_link_t *create_leaving_link(GGraphCluster *owner, size_t index) +{ + leaving_link_t *result; /* Structure à retourner */ + + result = malloc(sizeof(leaving_link_t)); + + result->owner = owner; + + result->index = index; + + result->straight = false; + result->forced_straight = false; + result->straight_level = SIZE_MAX; + result->cluster_exit = false; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : link = structure à libérer de la mémoire. * +* * +* Description : Détruit un point d'attache pour un lien sortant. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_leaving_link(leaving_link_t *link) +{ + free(link); + +} + + +/****************************************************************************** +* * +* Paramètres : link = information sur un lien à consulter. * +* * +* Description : Calcule l'abscisse d'un lien à son départ d'un bloc. * +* * +* Retour : Abscisse à attribuer à un départ de lien. * +* * +* Remarques : - * +* * +******************************************************************************/ + +gint compute_leaving_link_position(const leaving_link_t *link) +{ + gint result; /* Position à retourner */ + + result = g_graph_cluster_compute_leaving_link_position(link->owner, link->index); + + return result; + +} diff --git a/src/gtkext/graph/leaving.h b/src/gtkext/graph/leaving.h new file mode 100644 index 0000000..c91f232 --- /dev/null +++ b/src/gtkext/graph/leaving.h @@ -0,0 +1,66 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * leaving.h - prototypes pour les liens sortants d'un bloc de code dans une représentation graphique + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#ifndef _GTKEXT_GRAPH_LEAVING_H +#define _GTKEXT_GRAPH_LEAVING_H + + +#include "cluster.h" + + +/* Depuis incoming.h : définition du tracé d'un lien */ +typedef struct _incoming_link_t incoming_link_t; + +/* Détails sur le départ d'un lien */ +typedef struct _leaving_link_t +{ + GGraphCluster *owner; /* Propriétaire du lien */ + + GdkPoint start[2]; /* Point de départ d'un lien */ + size_t index; /* Indice sur ligne de départ */ + + bool straight; /* Présence d'une ligne droite */ + bool forced_straight; /* Forçage de verticalité */ + size_t straight_level; /* Rang atteint en ligne droite*/ + bool cluster_exit; /* Sortie du cluster d'origine */ + + incoming_link_t *other; /* Autre extrémité du lien */ + +} leaving_link_t; + + +#define SHOULD_BE_VERTICAL(l) ((l)->straight || (l)->forced_straight || (l)->cluster_exit) + + +/* Crée un point d'attache pour un lien sortant. */ +leaving_link_t *create_leaving_link(GGraphCluster *, size_t); + +/* Détruit un point d'attache pour un lien sortant. */ +void delete_leaving_link(leaving_link_t *); + +/* Calcule l'abscisse d'un lien à son départ d'un bloc. */ +gint compute_leaving_link_position(const leaving_link_t *); + + + +#endif /* _GTKEXT_GRAPH_LEAVING_H */ diff --git a/src/gtkext/graph/rank.c b/src/gtkext/graph/rank.c new file mode 100644 index 0000000..0fadb27 --- /dev/null +++ b/src/gtkext/graph/rank.c @@ -0,0 +1,914 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * rank.c - classement par rang des descendants directs + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#include "rank.h" + + +#include +#include + + +#include "cluster-int.h" + + + +/****************************************************************************** +* * +* Paramètres : grank = structure à initialiser. [OUT] * +* cluster = chef de file d'un ensemble de blocs. * +* * +* Description : Initialise la gestion d'un ensemble de blocs de même rang. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void init_graph_rank(graph_rank_t *grank, GGraphCluster *cluster) +{ + grank->right2left = NULL; + grank->r2l_count = 0; + + grank->left2right = NULL; + grank->l2r_count = 0; + + grank->clusters = malloc(sizeof(GGraphCluster *)); + grank->count = 1; + + grank->clusters[0] = cluster; + + init_vspace_manager(&grank->vspaces); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = structure à vider. * +* * +* Description : Termine la gestion d'un ensemble de blocs de même rang. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void exit_graph_rank(graph_rank_t *grank) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->r2l_count; i++) + free(grank->right2left[i]); + + if (grank->right2left != NULL) + free(grank->right2left); + + for (i = 0; i < grank->l2r_count; i++) + free(grank->left2right[i]); + + if (grank->left2right != NULL) + free(grank->left2right); + + assert(grank->clusters != NULL); + + free(grank->clusters); + + exit_vspace_manager(&grank->vspaces); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de même rang à consulter. * +* * +* Description : Assigne à un ensemble de blocs un emplacement initial. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void reset_graph_rank_allocation(const graph_rank_t *grank) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_reset_allocation(grank->clusters[i]); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de même rang à consulter. * +* * +* Description : Fournit le rang d'un ensemble de blocs. * +* * +* Retour : Rang d'un ensemble de blocs de même rang. * +* * +* Remarques : - * +* * +******************************************************************************/ + +size_t get_graph_rank(const graph_rank_t *grank) +{ + size_t result; /* Rang à retourner */ + GCodeBlock *block; /* Bloc de code de référence */ + + block = g_graph_cluster_get_block(grank->clusters[0]); + + result = g_code_block_get_rank(block); + + g_object_unref(G_OBJECT(block)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : a = premier ensemble de même rang à comparer. * +* b = second ensemble de même rang à comparer. * +* * +* Description : Compare deux rangées de blocs de code. * +* * +* Retour : Bilan de comparaison. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int cmp_graph_rank(const graph_rank_t *a, const graph_rank_t *b) +{ + int result; /* Bilan à retourner */ + size_t level_a; /* Niveau de l'ensemble A */ + size_t level_b; /* Niveau de l'ensemble B */ + + level_a = get_graph_rank(a); + level_b = get_graph_rank(b); + + if (level_a < level_b) + result = -1; + + else if (level_a > level_b) + result = 1; + + else + result = 0; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = structure à compléter. * +* cluster = chef de file d'un ensemble de blocs. * +* * +* Description : Etend un ensemble de blocs de même rang. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void extend_graph_rank(graph_rank_t *grank, GGraphCluster *cluster) +{ + grank->count++; + grank->clusters = realloc(grank->clusters, sizeof(GGraphCluster *) * grank->count); + + grank->clusters[grank->count - 1] = cluster; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = structure à compléter. * +* cluster = chef de file d'un ensemble de blocs. * +* * +* Description : Détermine si un groupe de blocs contient un bloc particulier.* +* * +* Retour : true si le chef est bien contenu, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool has_graph_rank_cluster(const graph_rank_t *grank, GGraphCluster *cluster) +{ + bool result; /* Bilan à renvoyer */ + size_t i; /* Boucle de parcours */ + + result = false; + + for (i = 0; i < grank->count && !result; i++) + result = (grank->clusters[i] == cluster); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de descendants d'un même rang. * +* from = point de départ du lien concerné. * +* to = point d'arrivée du lien concerné. * +* pts = points intermédiaires du tracé complet final. * +* external = précise une sortie du cadre du cluster premier. * +* * +* Description : Inscrit à l'endroit idéal une réservation d'espace latéral. * +* * +* Retour : true si la demande a bien été traitée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool extend_graph_rank_vspace_manager(graph_rank_t *grank, leaving_link_t *from, incoming_link_t *to, GdkPoint *pts, bool external) +{ + bool result; /* Bilan à renvoyer */ + + result = has_graph_rank_cluster(grank, from->owner); + + if (result) + extend_vspace_manager(&grank->vspaces, from, to, pts, external); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de descendants d'un même rang. * +* all = table regroupant tous les groupes créés. * +* * +* Description : Met en place les embryons de liens nécessaires. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void define_graph_rank_links(const graph_rank_t *grank, GHashTable *all) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_define_links(grank->clusters[i], all); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de descendants d'un même rang. * +* * +* Description : Repère les liens marquants à destination d'autres blocs. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void setup_graph_rank_links(const graph_rank_t *grank) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_setup_links(grank->clusters[i]); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de descendants d'un même rang. * +* last = indique s'il s'agit du dernier étage de l'ensemble. * +* alloc = emplacement idéal pour l'affichage. [OUT] * +* * +* Description : Détermine l'emplacement requis d'un ensemble de blocs. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void compute_graph_rank_needed_alloc(const graph_rank_t *grank, bool last, GtkAllocation *alloc) +{ + GtkAllocation needed; /* Taille requise */ + + switch (grank->count) + { + case 1: + + g_graph_cluster_compute_needed_alloc(grank->clusters[0], &needed); + + if (needed.x < alloc->x) + { + alloc->width += (alloc->x - needed.x); + alloc->x = needed.x; + } + + if ((needed.x + needed.width) > (alloc->x + alloc->width)) + alloc->width += needed.x + needed.width - alloc->x - alloc->width; + + /* La hauteur maximale n'est présente qu'avec le dernier morceau */ + if (last) + { + if ((needed.y + needed.height) > (alloc->y + alloc->height)) + alloc->height += needed.y + needed.height - alloc->y - alloc->height; + } + + break; + + default: + + assert(grank->count >= 2); + + g_graph_cluster_compute_needed_alloc(grank->clusters[0], &needed); + + if (needed.x < alloc->x) + { + alloc->width += (alloc->x - needed.x); + alloc->x = needed.x; + } + + /* La hauteur maximale n'est présente qu'avec le dernier morceau */ + if (last) + { + if ((needed.y + needed.height) > (alloc->y + alloc->height)) + alloc->height += needed.y + needed.height - alloc->y - alloc->height; + } + + g_graph_cluster_compute_needed_alloc(grank->clusters[grank->count - 1], &needed); + + if ((needed.x + needed.width) > (alloc->x + alloc->width)) + alloc->width += needed.x + needed.width - alloc->x - alloc->width; + + /* La hauteur maximale n'est présente qu'avec le dernier morceau */ + if (last) + { + if ((needed.y + needed.height) > (alloc->y + alloc->height)) + alloc->height += needed.y + needed.height - alloc->y - alloc->height; + } + + break; + + } + + compute_vspace_manager_needed_alloc(&grank->vspaces, false, alloc); + +} + + +/****************************************************************************** +* * +* Paramètres : iter = début de la boucle de parcours. * +* loop = nombre d'itérations à mener. * +* base = position de base sur l'axe des abscisses. * +* dir = direction du parcours. * +* * +* Description : Affine l'abscisse d'un ensemble de blocs de même rang. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void _place_graph_rank_clusters(GGraphCluster **iter, size_t loop, gint base, int dir) +{ + size_t i; /* Boucle de parcours */ + GtkAllocation needed; /* Taille requise */ + + assert(dir == -1 || dir == 1); + + for (i = 0; i < loop; i++, iter += dir) + { + g_graph_cluster_dispatch_x(*iter); + + g_graph_cluster_compute_needed_alloc(*iter, &needed); + + if (dir > 0) + g_graph_cluster_offset_x(*iter, base - needed.x); + else + g_graph_cluster_offset_x(*iter, base - needed.x - needed.width); + + base += dir * (needed.width + HORIZONTAL_MARGIN); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à manipuler. * +* * +* Description : Organise la disposition d'un ensemble de blocs basiques. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void dispatch_x_graph_rank(const graph_rank_t *grank) +{ + size_t mid; /* Position centrale de départ */ + GtkAllocation alloc; /* Emplacement de cluster */ + gint start; /* Position initiale de départ */ + + if (grank->count % 2 == 1) + { + if (grank->count > 1) + { + mid = grank->count / 2; + + g_graph_cluster_get_allocation(grank->clusters[mid], &alloc); + + start = alloc.x - HORIZONTAL_MARGIN; + + _place_graph_rank_clusters(grank->clusters + mid - 1, mid, start, -1); + + start *= -1; + + _place_graph_rank_clusters(grank->clusters + mid + 1, mid, start, 1); + + } + + else + g_graph_cluster_dispatch_x(grank->clusters[0]); + + } + + else + { + mid = grank->count / 2 - 1; + + start = - HORIZONTAL_MARGIN / 2; + + _place_graph_rank_clusters(grank->clusters + mid, mid + 1, start, -1); + + start *= -1; + + _place_graph_rank_clusters(grank->clusters + mid + 1, mid + 1, start, 1); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à actualiser. * +* * +* Description : Réorganise au besoin les liens entrants un ensemble de blocs.* +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void sort_graph_rank_incoming_links(graph_rank_t *grank) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_sort_incoming_links(grank->clusters[i]); + + sort_incoming_links_for_vspace_manager(&grank->vspaces); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à actualiser. * +* * +* Description : Réordonne les blocs sortant d'un ensemble. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void reorder_graph_rank_exit_blocks(graph_rank_t *grank) +{ + GGraphCluster **exit_2_left; /* Liste avec sortie à gauche */ + GGraphCluster **exit_2_right; /* Liste avec sortie à droite */ + GGraphCluster **no_exit; /* Liste sans sortie */ + size_t count_2_left; /* Quantité de présents */ + size_t count_2_right; /* Quantité de présents */ + size_t count_no; /* Quantité de présents */ + size_t i; /* Boucle de parcours */ + bool l2r; /* Détermination de catégorie */ + + if (grank->count > 1) + { + exit_2_left = malloc(grank->count * sizeof(GGraphCluster *)); + exit_2_right = malloc(grank->count * sizeof(GGraphCluster *)); + no_exit = malloc(grank->count * sizeof(GGraphCluster *)); + + count_2_left = 0; + count_2_right = 0; + count_no = 0; + + for (i = 0; i < grank->count; i++) + { + if (g_graph_cluster_has_exit_link(grank->clusters[i], &l2r)) + { + if (l2r) + exit_2_right[count_2_right++] = grank->clusters[i]; + else + exit_2_left[count_2_left++] = grank->clusters[i]; + } + else + no_exit[count_no++] = grank->clusters[i]; + + } + + assert((count_2_left + count_2_right + count_no) == grank->count); + + qsort_r(exit_2_left, count_2_left, sizeof(GGraphCluster *), + (__compar_d_fn_t)g_graph_cluster_compare_by_exit, (bool []){ false }); + + qsort_r(exit_2_right, count_2_right, sizeof(GGraphCluster *), + (__compar_d_fn_t)g_graph_cluster_compare_by_exit, (bool []){ true }); + + grank->count = 0; + + for (i = 0; i < count_2_left; i++) + grank->clusters[grank->count++] = exit_2_left[i]; + + for (i = 0; i < count_no; i++) + grank->clusters[grank->count++] = no_exit[i]; + + for (i = 0; i < count_2_right; i++) + grank->clusters[grank->count++] = exit_2_right[i]; + + } + + for (i = 0; i < grank->count; i++) + g_graph_cluster_reorder_exit_blocks(grank->clusters[i]); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à actualiser. * +* * +* Description : Réordonne les blocs de départ de boucle d'un ensemble. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void reorder_graph_rank_loop_blocks(graph_rank_t *grank) +{ + size_t i; /* Boucle de parcours #1 */ + size_t k; /* Boucle de parcours #2 */ + GGraphCluster *tmp; /* Stockage temporaire */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_reorder_loop_blocks(grank->clusters[i]); + + if (grank->count > 1) + { + /* Placement des départs de boucle à gauche ! */ + + for (i = 0; i < grank->vspaces.left_count; i++) + { + tmp = grank->vspaces.left[i]->from->owner; + + for (k = 0; k < grank->count; k++) + if (grank->clusters[k] == tmp) + break; + + assert(k < grank->count); + + memmove(&grank->clusters[1], &grank->clusters[0], + k * sizeof(GGraphCluster *)); + + grank->clusters[0] = tmp; + + g_graph_cluster_reorder_link_origins(tmp, true); + + } + + /* Placement des départs de boucle à droite ! */ + + for (i = 0; i < grank->vspaces.right_count; i++) + { + tmp = grank->vspaces.right[i]->from->owner; + + for (k = 0; k < grank->count; k++) + if (grank->clusters[k] == tmp) + break; + + assert(k < grank->count); + + memmove(&grank->clusters[k], &grank->clusters[k + 1], + (grank->count - k - 1) * sizeof(GGraphCluster *)); + + grank->clusters[grank->count - 1] = tmp; + + g_graph_cluster_reorder_link_origins(tmp, false); + + } + + } + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à actualiser. * +* offset = décalage à appliquer. * +* * +* Description : Décale vers la droite un ensemble de blocs basiques. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void offset_x_graph_rank(graph_rank_t *grank, gint offset) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_offset_x(grank->clusters[i], offset); + + offset_x_vspace_manager(&grank->vspaces, offset); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à actualiser. * +* needed = espace nécessaire et alloué pour les blocs. * +* * +* Description : Détermine les abscisses des liens de boucle en place. * +* * +* Retour : Eventuelle marge à gauche devenue nécessaire. * +* * +* Remarques : - * +* * +******************************************************************************/ + +gint compute_loop_link_x_positions_with_graph_rank(const graph_rank_t *grank, const GtkAllocation *needed) +{ + gint result; /* Eventuelle marge à renvoyer */ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_compute_loop_link_x_positions(grank->clusters[i]); + + result = compute_loop_link_x_with_vspace_manager(&grank->vspaces, needed, false); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à actualiser. * +* base = position ordonnée à appliquer. * +* * +* Description : Décale vers le bas un ensemble de blocs basiques. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void set_y_for_graph_rank(const graph_rank_t *grank, gint *base) +{ + gint max; /* Hauteur maximale rencontrée */ + size_t i; /* Boucle de parcours */ + GGraphCluster *sub; /* Sous-ensemble traité */ + GtkAllocation alloc; /* Allocation courante */ + + /* On ajoute l'espace vertical pour les lignes horizontales */ + + if (grank->r2l_count > grank->l2r_count) + max = grank->r2l_count; + else + max = grank->l2r_count; + + *base += VERTICAL_MARGIN; + + /** + * Comme les liens purement verticaux n'entrainent pas de réservation, + * il n'y a potentiellement pas toujours d'espace à ajouter. + */ + + if (max > 0) + { + *base += ((max - 1) * LINK_MARGIN); + *base += VERTICAL_MARGIN; + } + + /* On ajoute l'espace requis pour l'affichage des blocs */ + + max = 0; + + for (i = 0; i < grank->count; i++) + { + sub = grank->clusters[i]; + + g_graph_cluster_set_y(sub, *base); + + g_graph_cluster_compute_needed_alloc(sub, &alloc); + + if ((alloc.y + alloc.height) > max) + max = alloc.y + alloc.height; + + } + + *base = max; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à actualiser. * +* needed = espace nécessaire et alloué pour les blocs. * +* * +* Description : Détermine les ordonnées de tous les liens en place. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void compute_loop_link_with_graph_rank(const graph_rank_t *grank, const GtkAllocation *needed) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < grank->count; i++) + g_graph_cluster_compute_link_y_positions(grank->clusters[i]); + + compute_loop_link_y_with_vspace_manager(&grank->vspaces, needed); + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à analyser. * +* block = bloc de code à retrouver. * +* * +* Description : Recherche le groupe de blocs avec un bloc donné comme chef. * +* * +* Retour : Groupe trouvé ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GGraphCluster *find_cluster_by_block_in_graph_rank(const graph_rank_t *grank, GCodeBlock *block) +{ + GGraphCluster *result; /* Trouvaille à retourner */ + size_t i; /* Boucle de parcours */ + + result = NULL; + + for (i = 0; i < grank->count && result == NULL; i++) + result = g_graph_cluster_find_by_block(grank->clusters[i], block); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à analyser. * +* widget = composant graphique à retrouver. * +* * +* Description : Recherche le groupe de blocs avec un composant comme chef. * +* * +* Retour : Groupe trouvé ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GGraphCluster *find_cluster_by_widget_in_graph_rank(const graph_rank_t *grank, GtkWidget *widget) +{ + GGraphCluster *result; /* Trouvaille à retourner */ + size_t i; /* Boucle de parcours */ + + result = NULL; + + for (i = 0; i < grank->count && result == NULL; i++) + result = g_graph_cluster_find_by_widget(grank->clusters[i], widget); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à analyser. * +* list = liste en cours de constitution. [OUT] * +* count = taille de cette liste. [OUT] * +* * +* Description : Collecte tous les chefs de file de blocs de code. * +* * +* Retour : Liste de graphiques de blocs rassemblés. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GGraphCluster **collect_graph_ranks_clusters(const graph_rank_t *grank, GGraphCluster **list, size_t *count) +{ + GGraphCluster **result; /* Liste complétée à renvoyer */ + size_t i; /* Boucle de parcours */ + + result = list; + + for (i = 0; i < grank->count; i++) + result = g_graph_cluster_collect(grank->clusters[i], result, count); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : grank = ensemble de blocs de même rang à analyser. * +* list = liste en cours de constitution. [OUT] * +* count = taille de cette liste. [OUT] * +* * +* Description : Collecte tous les liens de chefs de file de blocs de code. * +* * +* Retour : Liste de liens graphiques de blocs rassemblés. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GGraphEdge **collect_graph_ranks_cluster_edges(const graph_rank_t *grank, GGraphEdge **list, size_t *count) +{ + GGraphEdge **result; /* Liste complétée à renvoyer */ + size_t i; /* Boucle de parcours */ + + result = list; + + for (i = 0; i < grank->count; i++) + result = g_graph_cluster_collect_edges(grank->clusters[i], result, count); + + return result; + +} diff --git a/src/gtkext/graph/rank.h b/src/gtkext/graph/rank.h new file mode 100644 index 0000000..1a149fc --- /dev/null +++ b/src/gtkext/graph/rank.h @@ -0,0 +1,126 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * rank.h - prototypes pour le classement par rang des descendants directs + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#ifndef _GTKEXT_GRAPH_RANK_H +#define _GTKEXT_GRAPH_RANK_H + + +#include "cluster.h" +#include "edge.h" +#include "hspace.h" +#include "vspace.h" + + + +/* Découpage vertical */ +typedef struct _graph_rank_t +{ + hspace_booking **right2left; /* Réservations de D -> G */ + size_t r2l_count; /* Quantité de ces réservations*/ + + hspace_booking **left2right; /* Réservations de G -> D */ + size_t l2r_count; /* Quantité de ces réservations*/ + + GGraphCluster **clusters; /* Ensembles de blocs */ + size_t count; /* Nombre de ces ensembles */ + + vspace_manager_t vspaces; /* Gestion des liens latéraux */ + +} graph_rank_t; + + +/* Initialise la gestion d'un ensemble de blocs de même rang. */ +void init_graph_rank(graph_rank_t *, GGraphCluster *); + +/* Termine la gestion d'un ensemble de blocs de même rang. */ +void exit_graph_rank(graph_rank_t *); + +/* Assigne à un ensemble de blocs un emplacement initial. */ +void reset_graph_rank_allocation(const graph_rank_t *); + +/* Fournit le rang d'un ensemble de blocs. */ +size_t get_graph_rank(const graph_rank_t *); + +/* Compare deux rangées de blocs de code. */ +int cmp_graph_rank(const graph_rank_t *, const graph_rank_t *); + +/* Etend un ensemble de blocs de même rang. */ +void extend_graph_rank(graph_rank_t *, GGraphCluster *); + +/* Détermine si un groupe de blocs contient un bloc particulier. */ +bool has_graph_rank_cluster(const graph_rank_t *, GGraphCluster *); + +/* Inscrit à l'endroit idéal une réservation d'espace latéral. */ +bool extend_graph_rank_vspace_manager(graph_rank_t *, leaving_link_t *, incoming_link_t *, GdkPoint *, bool); + +/* Met en place les embryons de liens nécessaires. */ +void define_graph_rank_links(const graph_rank_t *, GHashTable *); + +/* Repère les liens marquants à destination d'autres blocs. */ +void setup_graph_rank_links(const graph_rank_t *); + +/* Détermine l'emplacement requis d'un ensemble de blocs. */ +void compute_graph_rank_needed_alloc(const graph_rank_t *, bool, GtkAllocation *); + +/* Affine l'abscisse d'un ensemble de blocs de même rang. */ +void _place_graph_rank_clusters(GGraphCluster **, size_t, gint, int); + +/* Organise la disposition d'un ensemble de blocs basiques. */ +void dispatch_x_graph_rank(const graph_rank_t *); + +/* Réorganise au besoin les liens entrants un ensemble de blocs. */ +void sort_graph_rank_incoming_links(graph_rank_t *); + +/* Réordonne les blocs sortant d'un ensemble. */ +void reorder_graph_rank_exit_blocks(graph_rank_t *); + +/* Réordonne les blocs de départ de boucle d'un ensemble. */ +void reorder_graph_rank_loop_blocks(graph_rank_t *); + +/* Décale vers la droite un ensemble de blocs basiques. */ +void offset_x_graph_rank(graph_rank_t *, gint); + +/* Détermine les abscisses des liens de boucle en place. */ +gint compute_loop_link_x_positions_with_graph_rank(const graph_rank_t *, const GtkAllocation *); + +/* Décale vers le bas un ensemble de blocs basiques. */ +void set_y_for_graph_rank(const graph_rank_t *, gint *); + +/* Détermine les ordonnées de tous les liens en place. */ +void compute_loop_link_with_graph_rank(const graph_rank_t *, const GtkAllocation *); + +/* Recherche le groupe de blocs avec un bloc donné comme chef. */ +GGraphCluster *find_cluster_by_block_in_graph_rank(const graph_rank_t *, GCodeBlock *); + +/* Recherche le groupe de blocs avec un composant comme chef. */ +GGraphCluster *find_cluster_by_widget_in_graph_rank(const graph_rank_t *, GtkWidget *); + +/* Collecte tous les chefs de file de blocs de code. */ +GGraphCluster **collect_graph_ranks_clusters(const graph_rank_t *, GGraphCluster **, size_t *); + +/* Collecte tous les liens de chefs de file de blocs de code. */ +GGraphEdge **collect_graph_ranks_cluster_edges(const graph_rank_t *, GGraphEdge **, size_t *); + + + +#endif /* _GTKEXT_GRAPH_RANK_H */ diff --git a/src/gtkext/graph/vspace.c b/src/gtkext/graph/vspace.c new file mode 100644 index 0000000..8327759 --- /dev/null +++ b/src/gtkext/graph/vspace.c @@ -0,0 +1,374 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * vspace.c - encadrement des espaces verticaux réservés + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#include "vspace.h" + + +#include + + +#include "cluster-int.h" + + + +/****************************************************************************** +* * +* Paramètres : manager = structure à initialiser. * +* * +* Description : Initialise les réservations liens verticaux. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void init_vspace_manager(vspace_manager_t *manager) +{ + manager->pending = NULL; + manager->pending_count = 0; + + manager->left = NULL; + manager->left_count = 0; + + manager->right = NULL; + manager->right_count = 0; + +} + + +/****************************************************************************** +* * +* Paramètres : manager = structure à vider. * +* * +* Description : Termine les réservations liens verticaux. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void exit_vspace_manager(vspace_manager_t *manager) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < manager->pending_count; i++) + free(manager->pending[i].pts); + + if (manager->pending != NULL) + free(manager->pending); + + if (manager->left != NULL) + free(manager->left); + + if (manager->right != NULL) + free(manager->right); + +} + + +/****************************************************************************** +* * +* Paramètres : manager = structure à compléter. * +* from = point de départ du lien concerné. * +* to = point d'arrivée du lien concerné. * +* pts = points intermédiaires du tracé complet final. * +* external = précise une sortie du cadre du cluster premier. * +* * +* Description : Inscrit une nouvelle réservation d'espace latéral. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void extend_vspace_manager(vspace_manager_t *manager, leaving_link_t *from, incoming_link_t *to, GdkPoint *pts, bool external) +{ + vspace_booking_t *new; /* Réservation à constituer */ + + manager->pending = realloc(manager->pending, ++manager->pending_count * sizeof(vspace_booking_t)); + + new = &manager->pending[manager->pending_count - 1]; + + new->from = from; + new->to = to; + + new->pts = pts; + + new->external = external; + +} + + +/****************************************************************************** +* * +* Paramètres : manager = gestion des espaces latéraux à consulter. * +* external = précise une sortie du cadre du cluster premier. * +* alloc = emplacement idéal pour l'affichage. [OUT] * +* * +* Description : Détermine l'emplacement requis pour les espaces latéraux. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void compute_vspace_manager_needed_alloc(const vspace_manager_t *manager, bool external, GtkAllocation *alloc) +{ + gint width; /* Largeur supplémentaire */ + size_t count; /* Nombre de liens retenus */ + size_t i; /* Boucle de parcours */ + + width = 0; + + /* Extension de la largeur, à gauche */ + + count = 0; + + for (i = 0; i < manager->left_count; i++) + if (manager->left[i]->external == external) + count++; + + width += count * LINK_MARGIN; + + alloc->x -= width; + + /* Extension de la largeur, à droite */ + + count = 0; + + for (i = 0; i < manager->right_count; i++) + if (manager->right[i]->external == external) + count++; + + width += count * LINK_MARGIN; + + alloc->width += width; + + /* Extension de la hauteur */ + + if (!external) + alloc->height += manager->pending_count * VERTICAL_MARGIN; + +} + + +/****************************************************************************** +* * +* Paramètres : manager = gestion d'espaces latéraux à manipuler. * +* * +* Description : Réorganise au besoin les liens de boucle entre blocs. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void sort_incoming_links_for_vspace_manager(vspace_manager_t *manager) +{ + size_t i; /* Boucle de parcours */ + vspace_booking_t *pending; /* Elément traité */ + gint x1; /* Abscisse de départ de lien */ + size_t idx; /* Indice du lien entrant */ + gint x2; /* Abscisse d'arrivée de lien */ + bool for_left; /* Répartition par la gauche ? */ + + for (i = 0; i < manager->pending_count; i++) + { + pending = &manager->pending[i]; + + x1 = g_graph_cluster_compute_leaving_link_position(pending->from->owner, pending->from->index); + + idx = g_graph_cluster_find_incoming_link(pending->to->owner, pending->from); + + x2 = g_graph_cluster_compute_incoming_link_position(pending->to->owner, idx); + + /** + * Prise en compte d'une boucle while (1); + */ + if (pending->from->owner == pending->to->owner) + for_left = (x2 < x1); + else + for_left = (x1 < x2); + + if (for_left) + { + manager->left = realloc(manager->left, ++manager->left_count * sizeof(vspace_booking_t *)); + manager->left[manager->left_count - 1] = pending; + } + else + { + manager->right = realloc(manager->right, ++manager->right_count * sizeof(vspace_booking_t *)); + manager->right[manager->right_count - 1] = pending; + } + + } + +} + + +/****************************************************************************** +* * +* Paramètres : manager = structure à actualiser. * +* offset = décalage à appliquer. * +* * +* Description : Décale vers la droite un ensemble de points. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void offset_x_vspace_manager(vspace_manager_t *manager, gint offset) +{ + size_t i; /* Boucle de parcours */ + vspace_booking_t *booking; /* Réservation à traiter */ + + for (i = 0; i < manager->left_count; i++) + { + booking = manager->left[i]; + + booking->pts[0].x += offset; + booking->pts[1].x += offset; + + } + + for (i = 0; i < manager->right_count; i++) + { + booking = manager->right[i]; + + booking->pts[0].x += offset; + booking->pts[1].x += offset; + + } + +} + + +/****************************************************************************** +* * +* Paramètres : manager = structure à consulter. * +* needed = espace nécessaire et alloué pour les blocs. * +* external = précise une sortie du cadre du cluster premier. * +* * +* Description : Détermine les abscisses de tous les liens en place. * +* * +* Retour : Eventuelle marge à gauche devenue nécessaire. * +* * +* Remarques : - * +* * +******************************************************************************/ + +gint compute_loop_link_x_with_vspace_manager(const vspace_manager_t *manager, const GtkAllocation *needed, bool external) +{ + gint result; /* Eventuelle marge à renvoyer */ + size_t count; /* Quantité de liens traités */ + size_t i; /* Boucle de parcours */ + vspace_booking_t *booking; /* Réservation à traiter */ + gint x; /* Position à appliquer */ + + count = 0; + + for (i = 0; i < manager->left_count; i++) + { + booking = manager->left[i]; + + if (booking->external != external) + continue; + + x = ++count * LINK_MARGIN; + + booking->pts[0].x = needed->x - x; + booking->pts[1].x = needed->x - x; + + } + + result = count * LINK_MARGIN; + + count = 0; + + for (i = 0; i < manager->right_count; i++) + { + booking = manager->right[i]; + + if (booking->external != external) + continue; + + x = ++count * LINK_MARGIN; + + booking->pts[0].x = needed->x + needed->width + x; + booking->pts[1].x = needed->x + needed->width + x; + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : manager = structure à consulter. * +* needed = espace nécessaire et alloué pour les blocs. * +* * +* Description : Détermine les ordonnées de tous les liens en place. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void compute_loop_link_y_with_vspace_manager(const vspace_manager_t *manager, const GtkAllocation *needed) +{ + gint real_bottom; /* Point de départ réel */ + size_t i; /* Boucle de parcours */ + vspace_booking_t *booking; /* Réservation à traiter */ + + real_bottom = needed->y + needed->height - manager->pending_count * VERTICAL_MARGIN; + + for (i = 0; i < manager->pending_count; i++) + { + booking = &manager->pending[i]; + + /** + * On corrige le raccourci pris sans distinction de type de lien dans + * la fonction g_graph_cluster_compute_link_y_positions(). + */ + + booking->from->start[1].y = real_bottom + (i + 1) * VERTICAL_MARGIN; + + /* Définition de l'ordonnée des points du lien */ + + booking->pts[0].y = booking->from->start[1].y; + + booking->pts[1].y = booking->to->end[0].y; + + } + +} diff --git a/src/gtkext/graph/vspace.h b/src/gtkext/graph/vspace.h new file mode 100644 index 0000000..de83141 --- /dev/null +++ b/src/gtkext/graph/vspace.h @@ -0,0 +1,86 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * vspace.h - prototypes pour l'encadrement des espaces verticaux réservés + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide 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 + * (at your option) any later version. + * + * Chrysalide 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 Chrysalide. If not, see . + */ + + +#ifndef _GTKEXT_GRAPH_VSPACE_H +#define _GTKEXT_GRAPH_VSPACE_H + + +#include "incoming.h" +#include "leaving.h" + + + +/* Réservations d'espaces latéraux */ +typedef struct _vspace_booking_t +{ + leaving_link_t *from; /* Bloc de départ du lien */ + incoming_link_t *to; /* Bloc d'arrivée du lien */ + + GdkPoint *pts; /* Coordonnées des points */ + + bool external; /* Lien vers un cluster parent */ + +} vspace_booking_t; + +/* Réservations d'espaces latéraux */ +typedef struct _vspace_manager_t +{ + vspace_booking_t *pending; /* Besoins exprimés */ + size_t pending_count; /* Nombre de ces besoins */ + + vspace_booking_t **left; /* Lignes disposées à gauche */ + size_t left_count; /* Quantité de ces lignes */ + + vspace_booking_t **right; /* Lignes disposées à droite */ + size_t right_count; /* Quantité de ces lignes */ + +} vspace_manager_t; + + +/* Initialise les réservations liens verticaux. */ +void init_vspace_manager(vspace_manager_t *); + +/* Termine les réservations liens verticaux. */ +void exit_vspace_manager(vspace_manager_t *); + +/* Inscrit une nouvelle réservation d'espace latéral. */ +void extend_vspace_manager(vspace_manager_t *, leaving_link_t *, incoming_link_t *, GdkPoint *, bool); + +/* Détermine l'emplacement requis pour les espaces latéraux. */ +void compute_vspace_manager_needed_alloc(const vspace_manager_t *, bool, GtkAllocation *); + +/* Réorganise au besoin les liens de boucle entre blocs. */ +void sort_incoming_links_for_vspace_manager(vspace_manager_t *); + +/* Décale vers la droite un ensemble de points. */ +void offset_x_vspace_manager(vspace_manager_t *, gint); + +/* Détermine les abscisses de tous les liens en place. */ +gint compute_loop_link_x_with_vspace_manager(const vspace_manager_t *, const GtkAllocation *, bool); + +/* Détermine les ordonnées de tous les liens en place. */ +void compute_loop_link_y_with_vspace_manager(const vspace_manager_t *, const GtkAllocation *); + + + +#endif /* _GTKEXT_GRAPH_VSPACE_H */ -- cgit v0.11.2-87-g4458