diff --git a/To discuss (after audit).txt b/To discuss (after audit).txt new file mode 100644 index 0000000..d485d78 --- /dev/null +++ b/To discuss (after audit).txt @@ -0,0 +1,9 @@ +les fonctions commençant par get devraient renvoyer des valeurs et non pas des widgets +> "get_..." remplacé par "rec_..." pour les widgets +> "set_..." remplacé par "fix_..." pour les widgets + +ne pas utiliser la taille de fenêtre comme comme référence +> corrigé + + + diff --git a/include/base.h b/include/base.h index d855cd6..92b83df 100644 --- a/include/base.h +++ b/include/base.h @@ -45,8 +45,7 @@ #include #include -// #define G_APPLICATION_DEFAULT_FLAGS 0 < work TODO here ? - +// #define G_APPLICATION_DEFAULT_FLAGS 0 TODO What was this declaration for ? /******************************************************************************/ diff --git a/include/fsm.h b/include/fsm.h index 7cd48ad..9a70568 100644 --- a/include/fsm.h +++ b/include/fsm.h @@ -28,6 +28,7 @@ * * * * * * * * * * * * * * * * * * * * * * * * * * */ +#pragma once #include diff --git a/include/graphics.h b/include/graphics.h index 6ed7ce6..0b52f2a 100644 --- a/include/graphics.h +++ b/include/graphics.h @@ -48,7 +48,7 @@ * Structure describing a gl_area and its parameters, used to create a table * of Gem-graph client current gl_areas */ -struct graph_stack_t { +struct graphics_stack_t { int id; int mode; @@ -85,15 +85,15 @@ struct graph_stack_t { /* * Dynamic array of ptrs to dynamically allocated gl_area_entry */ -extern struct graph_stack_t *graph_stack; +extern struct graphics_stack_t *graphics_stack; /* * Structure describing a gl_area and its parameters, used to create a table * of Gem-graph client current gl_areas */ -bool graph_render_stack(GtkWidget *container_widget); +bool graphics_render_stack(GtkWidget *container_widget); -bool graph_setup_glarea(int target_mode, GtkWidget *target_widget); +bool graphics_setup_glarea(int target_mode, GtkWidget *target_widget); /* * Initializes a gl_area @@ -102,7 +102,7 @@ bool graph_setup_glarea(int target_mode, GtkWidget *target_widget); * * @return true if initialized */ -int graph_init(void *error_buffer); +int graphics_init(void *error_buffer); /* * Draws the current buffer to a gl_area @@ -111,7 +111,7 @@ int graph_init(void *error_buffer); * * @return void */ -void graph_draw(const int graph_stack_id); +void graphics_draw(const int graphics_stack_id); /* * Shutdowns a gl_area @@ -120,7 +120,7 @@ void graph_draw(const int graph_stack_id); * * @return true if success */ -bool graph_shutdown(const int graph_stack_id, void *error_buffer); +bool graphics_shutdown(const int graphics_stack_id, void *error_buffer); /* * Initializes the shaders of a gl_area and link them to a program @@ -129,18 +129,18 @@ bool graph_shutdown(const int graph_stack_id, void *error_buffer); * * @return true if initialized */ -bool graph_init_shaders(const int graph_stack_id); +bool graphics_init_shaders(const int graphics_stack_id); -bool graph_init_graph_stack(void *container_widget, GError *error_buffer); -bool graph_shutdown_graph_stack(void *container_widget, GError *error_buffer); -bool graph_update_axis_stack(GtkWidget *container_widget, int axis, int value); +bool graphics_init_graphics_stack(void *container_widget, GError *error_buffer); +bool graphics_shutdown_graphics_stack(void *container_widget, GError *error_buffer); +bool graphics_update_axis_stack(GtkWidget *container_widget, int axis, int value); /* Initializes the buffer of a gl_area * Calls according to the user preferences * @param gl_area, ptr to the gl_area widget * @return void */ -void graph_init_buffers(const int graph_stack_id); +void graphics_init_buffers(const int graphics_stack_id); /* * Draws a vertex (x, y, z) @@ -150,7 +150,7 @@ void graph_init_buffers(const int graph_stack_id); * * @return void */ -void graph_draw_vertex (const int graph_stack_id, +void graphics_draw_vertex (const int graphics_stack_id, GLfloat x, GLfloat y, GLfloat z); @@ -163,7 +163,7 @@ void graph_draw_vertex (const int graph_stack_id, * * @return void */ -void graph_draw_color (const int graph_stack_id, GLfloat r, GLfloat g, GLfloat b); +void graphics_draw_color (const int graphics_stack_id, GLfloat r, GLfloat g, GLfloat b); /* * Writes values to describe a line from a to b into the line buffer @@ -172,7 +172,7 @@ void graph_draw_color (const int graph_stack_id, GLfloat r, GLfloat g, GLfloat b * * @return void */ -void graph_draw_line (const int graph_stack_id, GLuint a, GLuint b); +void graphics_draw_line (const int graphics_stack_id, GLuint a, GLuint b); /* * Writes values to describe an (a,b,c) plan (triangle) into the plan buffer @@ -181,7 +181,7 @@ void graph_draw_line (const int graph_stack_id, GLuint a, GLuint b); * * @return void */ -void graph_draw_plan (const int graph_stack_id, GLuint a, GLuint b, GLuint c); +void graphics_draw_plan (const int graphics_stack_id, GLuint a, GLuint b, GLuint c); /* * Created and compile a shader @@ -191,7 +191,7 @@ void graph_draw_plan (const int graph_stack_id, GLuint a, GLuint b, GLuint c); * * @return shader id */ -static inline GLuint graph_create_shader(const int graph_stack_id, int type, const char *src) +static inline GLuint graphics_create_shader(const int graphics_stack_id, int type, const char *src) { GLuint shader; int status; @@ -225,47 +225,48 @@ static inline GLuint graph_create_shader(const int graph_stack_id, int type, con return shader; } -static inline void graph_print_stack(int graph_stack_id) +static inline void graphics_print_stack(int graphics_stack_id) { static int n = 0; printf("\n[n=%d]***************", n); printf("id = %d\tmode = %d\n", - graph_stack[graph_stack_id].id, - graph_stack[graph_stack_id].mode); + graphics_stack[graphics_stack_id].id, + graphics_stack[graphics_stack_id].mode); printf("rotation_angles = "); for (int i = 0; i < N_AXIS; i++) { - printf("%f\t", graph_stack[graph_stack_id].rotation_angles[i]); // Rotation angles on each axis + printf("%f\t", graphics_stack[graphics_stack_id].rotation_angles[i]); + // Rotation angles on each axis } printf("\n"); - printf("vao = %d\n", graph_stack[graph_stack_id].vao); - printf("position_buffer = %d\n", graph_stack[graph_stack_id].position_buffer); - printf("color_buffer = %d\n", graph_stack[graph_stack_id].color_buffer); - printf("program = %d\n", graph_stack[graph_stack_id].program); - printf("m = %d\n", graph_stack[graph_stack_id].m); - printf("v = %d\n", graph_stack[graph_stack_id].v); - printf("p = %d\n", graph_stack[graph_stack_id].p); + printf("vao = %d\n", graphics_stack[graphics_stack_id].vao); + printf("position_buffer = %d\n", graphics_stack[graphics_stack_id].position_buffer); + printf("color_buffer = %d\n", graphics_stack[graphics_stack_id].color_buffer); + printf("program = %d\n", graphics_stack[graphics_stack_id].program); + printf("m = %d\n", graphics_stack[graphics_stack_id].m); + printf("v = %d\n", graphics_stack[graphics_stack_id].v); + printf("p = %d\n", graphics_stack[graphics_stack_id].p); - printf("arrows_ptr = %p\n", graph_stack[graph_stack_id].arrows_ptr); - printf("arrows_nb = %ld\n", graph_stack[graph_stack_id].arrows_nb); + printf("arrows_ptr = %p\n", graphics_stack[graphics_stack_id].arrows_ptr); + printf("arrows_nb = %ld\n", graphics_stack[graphics_stack_id].arrows_nb); - printf("buffer_vertex_origin = %p\n", graph_stack[graph_stack_id].buffer_vertex_origin); - printf("buffer_colors_origin = %p\n", graph_stack[graph_stack_id].buffer_colors_origin); - printf("buffer_lines_origin = %p\n", graph_stack[graph_stack_id].buffer_lines_origin); - printf("buffer_plans_origin = %p\n", graph_stack[graph_stack_id].buffer_plans_origin); + printf("buffer_vertex_origin = %p\n", graphics_stack[graphics_stack_id].buffer_vertex_origin); + printf("buffer_colors_origin = %p\n", graphics_stack[graphics_stack_id].buffer_colors_origin); + printf("buffer_lines_origin = %p\n", graphics_stack[graphics_stack_id].buffer_lines_origin); + printf("buffer_plans_origin = %p\n", graphics_stack[graphics_stack_id].buffer_plans_origin); - printf("buffer_vertex_size = %ld\n", graph_stack[graph_stack_id].buffer_vertex_size); - printf("buffer_colors_size = %ld\n", graph_stack[graph_stack_id].buffer_colors_size); - printf("buffer_lines_size = %ld\n", graph_stack[graph_stack_id].buffer_lines_size); - printf("buffer_plans_size = %ld\n", graph_stack[graph_stack_id].buffer_plans_size); + printf("buffer_vertex_size = %ld\n", graphics_stack[graphics_stack_id].buffer_vertex_size); + printf("buffer_colors_size = %ld\n", graphics_stack[graphics_stack_id].buffer_colors_size); + printf("buffer_lines_size = %ld\n", graphics_stack[graphics_stack_id].buffer_lines_size); + printf("buffer_plans_size = %ld\n", graphics_stack[graphics_stack_id].buffer_plans_size); - printf("buffer_vertex_0_arrow = %ld\n", graph_stack[graph_stack_id].buffer_vertex_0_arrow); - printf("buffer_colors_0_arrow = %ld\n", graph_stack[graph_stack_id].buffer_colors_0_arrow); - printf("buffer_lines_0_arrow = %ld\n", graph_stack[graph_stack_id].buffer_lines_0_arrow); - printf("buffer_plans_0_arrow = %ld\n", graph_stack[graph_stack_id].buffer_plans_0_arrow); + printf("buffer_vertex_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_vertex_0_arrow); + printf("buffer_colors_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_colors_0_arrow); + printf("buffer_lines_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_lines_0_arrow); + printf("buffer_plans_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_plans_0_arrow); printf("********************\n"); n++; @@ -279,7 +280,7 @@ static inline void graph_print_stack(int graph_stack_id) * * @return true if initialized */ -int graph_init(void *error_buffer); +int graphics_init(void *error_buffer); /* * Draws the current buffer to a gl_area @@ -288,7 +289,7 @@ int graph_init(void *error_buffer); * * @return void */ -//void graph_draw(const int graph_stack_id); +//void graphics_draw(const int graphics_stack_id); /* * Shutdowns a gl_area @@ -297,7 +298,7 @@ int graph_init(void *error_buffer); * * @return true if success */ -bool graph_shutdown(const int graph_stack_id, void *error_buffer); +bool graphics_shutdown(const int graphics_stack_id, void *error_buffer); /* * Initializes the shaders of a gl_area and link them to a program @@ -306,14 +307,14 @@ bool graph_shutdown(const int graph_stack_id, void *error_buffer); * * @return true if initialized */ -bool graph_init_shaders(const int graph_stack_id); +bool graphics_init_shaders(const int graphics_stack_id); /* Initializes the buffer of a gl_area * Calls according to the user preferences * @param gl_area, ptr to the gl_area widget * @return void */ -void graph_init_buffers(const int graph_stack_id); +void graphics_init_buffers(const int graphics_stack_id); /* * Draws a vertex (x, y, z) @@ -323,7 +324,7 @@ void graph_init_buffers(const int graph_stack_id); * * @return void */ -void graph_draw_vertex (const int graph_stack_id, +void graphics_draw_vertex (const int graphics_stack_id, GLfloat x, GLfloat y, GLfloat z); @@ -336,7 +337,7 @@ void graph_draw_vertex (const int graph_stack_id, * * @return void */ -void graph_draw_color (const int graph_stack_id, GLfloat r, GLfloat g, GLfloat b); +void graphics_draw_color (const int graphics_stack_id, GLfloat r, GLfloat g, GLfloat b); /* * Writes values to describe a line from a to b into the line buffer @@ -345,7 +346,7 @@ void graph_draw_color (const int graph_stack_id, GLfloat r, GLfloat g, GLfloat b * * @return void */ -void graph_draw_line (const int graph_stack_id, GLuint a, GLuint b); +void graphics_draw_line (const int graphics_stack_id, GLuint a, GLuint b); /* * Writes values to describe an (a,b,c) plan (triangle) into the plan buffer @@ -354,11 +355,11 @@ void graph_draw_line (const int graph_stack_id, GLuint a, GLuint b); * * @return void */ -void graph_draw_plan (const int graph_stack_id, GLuint a, GLuint b, GLuint c); +void graphics_draw_plan (const int graphics_stack_id, GLuint a, GLuint b, GLuint c); -void graph_model_setup (const int graph_stack_id); +void graphics_model_setup (const int graphics_stack_id); -int graph_draw_one_arrow_vertex (const int graph_stack_id, +int graphics_draw_one_arrow_vertex (const int graphics_stack_id, int space_X, int space_Y, int space_Z, @@ -368,7 +369,7 @@ int graph_draw_one_arrow_vertex (const int graph_stack_id, int y, int z); -int graph_draw_one_arrow_line(const int graph_stack_id, +int graphics_draw_one_arrow_line(const int graphics_stack_id, int offset_vertex); /* @@ -378,13 +379,13 @@ int graph_draw_one_arrow_line(const int graph_stack_id, * * @return void */ -int graph_draw_space_ridges_vertex (const int graph_stack_id, +int graphics_draw_space_ridges_vertex (const int graphics_stack_id, long offset_vertex, long x, long y, long z); -int graph_draw_space_ridges_lines (const int graph_stack_id); +int graphics_draw_space_ridges_lines (const int graphics_stack_id); /* * Writes grid lines on space faces @@ -393,18 +394,18 @@ int graph_draw_space_ridges_lines (const int graph_stack_id); * * @return void */ -long graph_draw_grids_on_space_faces_vertex (const int graph_stack_id, +long graphics_draw_grids_on_space_faces_vertex (const int graphics_stack_id, long x, long y, long z); -long graph_draw_grids_on_space_faces_lines (const int graph_stack_id, +long graphics_draw_grids_on_space_faces_lines (const int graphics_stack_id, long offset_vertex, long x, long y, long z); -int graph_set_arrow (int graph_stack_id, +int graphics_set_arrow (int graphics_stack_id, int arrows_nb, int space_X, int space_Y, diff --git a/include/parse.h b/include/parse.h index d12d8a4..0408b79 100644 --- a/include/parse.h +++ b/include/parse.h @@ -28,19 +28,21 @@ * * * * * * * * * * * * * * * * * * * * * * * * * * */ +#pragma once -bool model_init(const char *content, size_t length, const char *basename); -bool model_shutdown(void); -char model_get_dim(void); -long model_get_dim_value(const char *axis); -char model_get_multiplicity(void); -bool model_get_next_state(char *new_state_id); -bool model_get_next_arrow(struct arrow_t *new_arrow, +bool parse_model_init(const char *content, size_t length, const char *basename); +bool parse_model_shutdown(void); + +char parse_model_get_dim(void); +long parse_model_get_dim_value(const char *axis); +char parse_model_get_multiplicity(void); +bool parse_model_get_next_state(char *new_state_id); +bool parse_model_get_next_arrow(struct arrow_t *new_arrow, const char *state_id, char dimension); -long model_get_state_arrows_count(const char *state_id); +long parse_model_get_state_arrows_count(const char *state_id); diff --git a/include/signal.h b/include/signal.h index ee6c0c2..4c7a389 100644 --- a/include/signal.h +++ b/include/signal.h @@ -28,7 +28,7 @@ * * * * * * * * * * * * * * * * * * * * * * * * * * */ - +#pragma once #include // void on_auto_notification (const char *message); @@ -90,18 +90,6 @@ void on_clicked_menu_experiment (GtkWidget *btt_menu, gpointer list_box); - - - - - - - - - - - - diff --git a/include/widget.h b/include/widget.h index 26b1953..6d39219 100644 --- a/include/widget.h +++ b/include/widget.h @@ -28,16 +28,16 @@ * * * * * * * * * * * * * * * * * * * * * * * * * * */ - +#pragma once #include /******************************************************************************/ /* W I N D O W S */ /******************************************************************************/ -void widget_head_set_MAIN_WINDOW (GtkApplication *app); -void widget_head_set_DIALOG_WINDOW (GtkApplication *app); -void widget_head_set_TEXT_WINDOW (GtkApplication *app); +void widget_head_fix_MAIN_WINDOW (GtkApplication *app); +void widget_head_fix_DIALOG_WINDOW (GtkApplication *app); +void widget_head_fix_TEXT_WINDOW (GtkApplication *app); void widget_head_MAIN_WINDOW_design (GtkWindow *main_window); void widget_head_DIALOG_WINDOW_design (GtkWindow *main_window, @@ -45,20 +45,20 @@ void widget_head_DIALOG_WINDOW_design (GtkWindow *main_window, void widget_head_TEXT_WINDOW_design (GtkWindow *main_window, GtkWindow *text_window); -GtkWindow *widget_head_get_MAIN_WINDOW(); -GtkWindow *widget_head_get_DIALOG_WINDOW(); -GtkWindow *widget_head_get_TEXT_WINDOW(); +GtkWindow *widget_head_rec_MAIN_WINDOW(); +GtkWindow *widget_head_rec_DIALOG_WINDOW(); +GtkWindow *widget_head_rec_TEXT_WINDOW(); /******************************************************************************/ /* W I D G E T S */ /******************************************************************************/ -GtkWidget *get_STATE_page(); -GtkWidget *get_RULES_page(); -GtkWidget *get_STOCK_page(); +GtkWidget *widget_rec_STATE_page(); +GtkWidget *widget_rec_RULES_page(); +GtkWidget *widget_rec_STOCK_page(); -GtkWidget *get_STOCK_text (gchar *text_name); +GtkWidget *widget_rec_STOCK_text (gchar *text_name); /******************************************************************************/ @@ -66,9 +66,9 @@ GtkWidget *get_STOCK_text (gchar *text_name); /******************************************************************************/ struct MenuNode_t {gchar *text; struct MenuNode_t *child, *next;}; -struct MenuNode_t *create_user_menu_node (const gchar* text); +struct MenuNode_t *widget_create_user_menu_node (const gchar* text); -GtkWidget *get_menu_anchor(); +GtkWidget *widget_rec_menu_anchor(); /******************************************************************************/ @@ -76,12 +76,12 @@ GtkWidget *get_menu_anchor(); /******************************************************************************/ struct TreeNode_t {gchar *text; struct TreeNode_t *child, *next;}; -struct TreeNode_t *create_user_tree_node (const gchar* text); +struct TreeNode_t *widget_create_user_tree_node (const gchar* text); -void add_child_node (struct TreeNode_t *parent, struct TreeNode_t *child); +void widget_add_child_node (struct TreeNode_t *parent, struct TreeNode_t *child); void labo_let_us_create_a_complex_useless_and_expensive_tree (struct TreeNode_t *tree_root); -GtkScrolledWindow *get_user_rules_tree (); +GtkScrolledWindow *widget_rec_user_rules_tree (); /******************************************************************************/ @@ -89,11 +89,11 @@ GtkScrolledWindow *get_user_rules_tree (); /******************************************************************************/ // images are in : data / image / -GtkWidget *get_image_E_coli(); -GtkWidget *get_image_GLUTAMATE(); -GtkWidget *get_image_GLUTAMINE(); -GtkWidget *get_image_ATP(); -GtkWidget *get_image_AMP(); +GtkWidget *widget_rec_image_E_coli(); +GtkWidget *widget_rec_image_GLUTAMATE(); +GtkWidget *widget_rec_image_GLUTAMINE(); +GtkWidget *widget_rec_image_ATP(); +GtkWidget *widget_rec_image_AMP(); /******************************************************************************/ @@ -101,9 +101,9 @@ GtkWidget *get_image_AMP(); /******************************************************************************/ // texts are in : data / text / -gchar *get_text_address_THEORY (); -gchar *get_text_address_ABOUT_COMMANDS (); -gchar *get_text_address_ANY (); +gchar *widget_rec_text_address_THEORY (); +gchar *widget_rec_text_address_ABOUT_COMMANDS (); +gchar *widget_rec_text_address_ANY (); /******************************************************************************/ diff --git a/src/automat.c b/src/fsm.c similarity index 100% rename from src/automat.c rename to src/fsm.c diff --git a/src/graphics/draw.c b/src/graphics/draw.c index 2b2893e..2c13fc3 100644 --- a/src/graphics/draw.c +++ b/src/graphics/draw.c @@ -38,7 +38,7 @@ * * @return void */ -void graph_draw_vertex (const int stack_id, +void graphics_draw_vertex (const int stack_id, GLfloat x, GLfloat y, GLfloat z) @@ -47,22 +47,22 @@ void graph_draw_vertex (const int stack_id, //g_printerr("stack_id is %d\n", stack_id); //g_printerr("graphic_stack is at %p\n", graphic_stack); //g_printerr("graphic_stack[stack_id] is at %p\n", graphic_stack + stack_id); - volatile struct graph_stack_t *graph_stack = NULL; // *graph_stack = &graph_stack[stack_id]; TODO + volatile struct graphics_stack_t *graphics_stack = NULL; // *graphics_stack = &graphics_stack[stack_id]; TODO //g_printerr("Currently stack->buffer_vertex_origin @ %p\n", stack->buffer_vertex_origin); //assert (stack->buffer_vertex_origin); - graph_stack->buffer_vertex_origin = - g_realloc (graph_stack->buffer_vertex_origin, - (graph_stack->buffer_vertex_size + 3) * sizeof(GLfloat)); + graphics_stack->buffer_vertex_origin = + g_realloc (graphics_stack->buffer_vertex_origin, + (graphics_stack->buffer_vertex_size + 3) * sizeof(GLfloat)); //print_stack(stack_id); - graph_stack->buffer_vertex_origin[graph_stack->buffer_vertex_size + 0] = x; - graph_stack->buffer_vertex_origin[graph_stack->buffer_vertex_size + 1] = y; - graph_stack->buffer_vertex_origin[graph_stack->buffer_vertex_size + 2] = z; + graphics_stack->buffer_vertex_origin[graphics_stack->buffer_vertex_size + 0] = x; + graphics_stack->buffer_vertex_origin[graphics_stack->buffer_vertex_size + 1] = y; + graphics_stack->buffer_vertex_origin[graphics_stack->buffer_vertex_size + 2] = z; - graph_stack->buffer_vertex_size += 3; + graphics_stack->buffer_vertex_size += 3; } /* @@ -72,23 +72,23 @@ void graph_draw_vertex (const int stack_id, * * @return void */ -void graph_draw_color (const int stack_id, +void graphics_draw_color (const int stack_id, GLfloat r, GLfloat g, GLfloat b) { - struct graph_stack_t *graph_stack = NULL; // *graph_stack = &graph_stack[stack_id]; TODO + struct graphics_stack_t *graphics_stack = NULL; // *graphics_stack = &graphics_stack[stack_id]; TODO - graph_stack->buffer_colors_origin = g_realloc (graph_stack->buffer_colors_origin, - (graph_stack->buffer_colors_size + 3) * sizeof(GLfloat)); + graphics_stack->buffer_colors_origin = g_realloc (graphics_stack->buffer_colors_origin, + (graphics_stack->buffer_colors_size + 3) * sizeof(GLfloat)); - assert (graph_stack->buffer_colors_origin); + assert (graphics_stack->buffer_colors_origin); - graph_stack->buffer_colors_origin[graph_stack->buffer_colors_size + 0] = r; - graph_stack->buffer_colors_origin[graph_stack->buffer_colors_size + 1] = g; - graph_stack->buffer_colors_origin[graph_stack->buffer_colors_size + 2] = b; + graphics_stack->buffer_colors_origin[graphics_stack->buffer_colors_size + 0] = r; + graphics_stack->buffer_colors_origin[graphics_stack->buffer_colors_size + 1] = g; + graphics_stack->buffer_colors_origin[graphics_stack->buffer_colors_size + 2] = b; - graph_stack->buffer_colors_size += 3; + graphics_stack->buffer_colors_size += 3; } /* @@ -98,21 +98,21 @@ void graph_draw_color (const int stack_id, * * @return void */ -void graph_draw_line (const int stack_id, +void graphics_draw_line (const int stack_id, GLuint a, GLuint b) { - struct graph_stack_t *graph_stack = NULL; // *graph_stack = &graph_stack[stack_id]; TODO + struct graphics_stack_t *graphics_stack = NULL; // *graphics_stack = &graphics_stack[stack_id]; TODO - graph_stack->buffer_lines_origin = g_realloc (graph_stack->buffer_lines_origin, - (graph_stack->buffer_lines_size + 2) * sizeof(GLuint)); + graphics_stack->buffer_lines_origin = g_realloc (graphics_stack->buffer_lines_origin, + (graphics_stack->buffer_lines_size + 2) * sizeof(GLuint)); - assert (graph_stack->buffer_lines_origin); + assert (graphics_stack->buffer_lines_origin); - graph_stack->buffer_lines_origin[graph_stack->buffer_lines_size + 0] = a; - graph_stack->buffer_lines_origin[graph_stack->buffer_lines_size + 1] = b; + graphics_stack->buffer_lines_origin[graphics_stack->buffer_lines_size + 0] = a; + graphics_stack->buffer_lines_origin[graphics_stack->buffer_lines_size + 1] = b; - graph_stack->buffer_lines_size += 2; + graphics_stack->buffer_lines_size += 2; } /* @@ -122,23 +122,23 @@ void graph_draw_line (const int stack_id, * * @return void */ -void graph_draw_plan (const int stack_id, +void graphics_draw_plan (const int stack_id, GLuint a, GLuint b, GLuint c) { - struct graph_stack_t *stack = &graph_stack[stack_id]; + struct graphics_stack_t *stack = &graphics_stack[stack_id]; - graph_stack->buffer_plans_origin = g_realloc (graph_stack->buffer_plans_origin, - (graph_stack->buffer_plans_size + 3) * sizeof(GLuint)); + graphics_stack->buffer_plans_origin = g_realloc (graphics_stack->buffer_plans_origin, + (graphics_stack->buffer_plans_size + 3) * sizeof(GLuint)); assert (stack->buffer_plans_origin); - graph_stack->buffer_plans_origin[graph_stack->buffer_plans_size + 0] = a; - graph_stack->buffer_plans_origin[graph_stack->buffer_plans_size + 1] = b; - graph_stack->buffer_plans_origin[graph_stack->buffer_plans_size + 2] = c; + graphics_stack->buffer_plans_origin[graphics_stack->buffer_plans_size + 0] = a; + graphics_stack->buffer_plans_origin[graphics_stack->buffer_plans_size + 1] = b; + graphics_stack->buffer_plans_origin[graphics_stack->buffer_plans_size + 2] = c; - graph_stack->buffer_plans_size += 3; + graphics_stack->buffer_plans_size += 3; } /* @@ -148,13 +148,13 @@ void graph_draw_plan (const int stack_id, * * @return void */ -void graph_draw(const int stack_id) +void graphics_draw(const int stack_id) { - struct graph_stack_t *stack = &graph_stack[stack_id]; + struct graphics_stack_t *stack = &graphics_stack[stack_id]; - g_printerr("[debug] graph_draw() started\n"); + g_printerr("[debug] graphics_draw() started\n"); - graph_print_stack(stack_id); + graphics_print_stack(stack_id); GLint cur_viewport[4]; glGetIntegerv(GL_VIEWPORT, cur_viewport); @@ -204,5 +204,5 @@ void graph_draw(const int stack_id) glUseProgram(0); glFlush(); - g_printerr("[debug] graph_draw() ended\n"); + g_printerr("[debug] graphics_draw() ended\n"); } diff --git a/src/graphics/grid.c b/src/graphics/grid.c index 3e20bba..1ce7281 100644 --- a/src/graphics/grid.c +++ b/src/graphics/grid.c @@ -28,7 +28,7 @@ #include "../../include/graphics.h" -int graph_draw_space_ridges_vertex (const int stack_id, +int graphics_draw_space_ridges_vertex (const int stack_id, long offset_vertex, long x, long y, @@ -36,44 +36,44 @@ int graph_draw_space_ridges_vertex (const int stack_id, { GLfloat max = fmax(x, y); max = fmax(max, z); - graph_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex - y / max, - z / max); + graphics_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex - y / max, - z / max); - graph_draw_vertex (stack_id, offset_vertex + x / max, offset_vertex - y / max, - z / max); - graph_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex + y / max, - z / max); - graph_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex - y / max, + z / max); + graphics_draw_vertex (stack_id, offset_vertex + x / max, offset_vertex - y / max, - z / max); + graphics_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex + y / max, - z / max); + graphics_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex - y / max, + z / max); - graph_draw_vertex (stack_id, offset_vertex + x / max, offset_vertex + y / max, - z / max); - graph_draw_vertex (stack_id, offset_vertex + x / max, offset_vertex - y / max, + z / max); - graph_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex + y / max, + z / max); + graphics_draw_vertex (stack_id, offset_vertex + x / max, offset_vertex + y / max, - z / max); + graphics_draw_vertex (stack_id, offset_vertex + x / max, offset_vertex - y / max, + z / max); + graphics_draw_vertex (stack_id, offset_vertex - x / max, offset_vertex + y / max, + z / max); - graph_draw_vertex (stack_id, offset_vertex + x / max, + y / max, + z / max); + graphics_draw_vertex (stack_id, offset_vertex + x / max, + y / max, + z / max); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); - graph_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); + graphics_draw_color (stack_id, 0.8f, 0.6f, 0.5f); return 8; } -int graph_draw_space_ridges_lines (const int stack_id) +int graphics_draw_space_ridges_lines (const int stack_id) { - graph_draw_line (stack_id, 0, 1); graph_draw_line (stack_id, 7, 4); - graph_draw_line (stack_id, 0, 2); graph_draw_line (stack_id, 7, 5); - graph_draw_line (stack_id, 0, 3); graph_draw_line (stack_id, 7, 6); + graphics_draw_line (stack_id, 0, 1); graphics_draw_line (stack_id, 7, 4); + graphics_draw_line (stack_id, 0, 2); graphics_draw_line (stack_id, 7, 5); + graphics_draw_line (stack_id, 0, 3); graphics_draw_line (stack_id, 7, 6); - graph_draw_line (stack_id, 1, 4); graph_draw_line (stack_id, 2, 4); - graph_draw_line (stack_id, 1, 5); graph_draw_line (stack_id, 3, 5); - graph_draw_line (stack_id, 2, 6); graph_draw_line (stack_id, 3, 6); + graphics_draw_line (stack_id, 1, 4); graphics_draw_line (stack_id, 2, 4); + graphics_draw_line (stack_id, 1, 5); graphics_draw_line (stack_id, 3, 5); + graphics_draw_line (stack_id, 2, 6); graphics_draw_line (stack_id, 3, 6); return 12; } -long graph_draw_grids_on_space_faces_vertex (const int stack_id, +long graphics_draw_grids_on_space_faces_vertex (const int stack_id, long x, long y, long z) @@ -82,52 +82,52 @@ long graph_draw_grids_on_space_faces_vertex (const int stack_id, for (i = 1; i < x; i++) { - graph_draw_vertex (stack_id, (2 * i / x - 1) * x / max, - y / max, - z / max); - graph_draw_vertex (stack_id, (2 * i / x - 1) * x / max, - y / max, z / max); - graph_draw_vertex (stack_id, (2 * i / x - 1) * x / max, y / max, z / max); - graph_draw_vertex (stack_id, (2 * i / x - 1) * x / max, y / max, - z / max); + graphics_draw_vertex (stack_id, (2 * i / x - 1) * x / max, - y / max, - z / max); + graphics_draw_vertex (stack_id, (2 * i / x - 1) * x / max, - y / max, z / max); + graphics_draw_vertex (stack_id, (2 * i / x - 1) * x / max, y / max, z / max); + graphics_draw_vertex (stack_id, (2 * i / x - 1) * x / max, y / max, - z / max); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); } /* offset_vertex += (x - 1) * 4; */ /* offset_colors += (x - 1) * 4; */ for (i = 1; i < y; i++) { - graph_draw_vertex (stack_id, - x / max, (2 * i / y - 1) * y / max, - z / max); - graph_draw_vertex (stack_id, - x / max, (2 * i / y - 1) * y / max, z / max); - graph_draw_vertex (stack_id, x / max, (2 * i / y - 1) * y / max, z / max); - graph_draw_vertex (stack_id, x / max, (2 * i / y - 1) * y / max, - z / max); + graphics_draw_vertex (stack_id, - x / max, (2 * i / y - 1) * y / max, - z / max); + graphics_draw_vertex (stack_id, - x / max, (2 * i / y - 1) * y / max, z / max); + graphics_draw_vertex (stack_id, x / max, (2 * i / y - 1) * y / max, z / max); + graphics_draw_vertex (stack_id, x / max, (2 * i / y - 1) * y / max, - z / max); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); } /* offset_vertex += (y - 1) * 4; */ /* offset_colors += (y - 1) * 4; */ for (i = 1; i < z; i++) { - graph_draw_vertex (stack_id, - x / max, - y / max, (2 * i / z - 1) * z / max); - graph_draw_vertex (stack_id, - x / max, y / max, (2 * i / z - 1) * z / max); - graph_draw_vertex (stack_id, x / max, y / max, (2 * i / z - 1) * z / max); - graph_draw_vertex (stack_id, x / max, - y / max, (2 * i / z - 1) * z / max); + graphics_draw_vertex (stack_id, - x / max, - y / max, (2 * i / z - 1) * z / max); + graphics_draw_vertex (stack_id, - x / max, y / max, (2 * i / z - 1) * z / max); + graphics_draw_vertex (stack_id, x / max, y / max, (2 * i / z - 1) * z / max); + graphics_draw_vertex (stack_id, x / max, - y / max, (2 * i / z - 1) * z / max); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); - graph_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); + graphics_draw_color (stack_id, 0.55f, 0.55f, 0.55f); } return (x + y + z - 3) * 3; } -long graph_draw_grids_on_space_faces_lines (const int stack_id, +long graphics_draw_grids_on_space_faces_lines (const int stack_id, long offset_vertex, long x, long y, @@ -137,24 +137,24 @@ long graph_draw_grids_on_space_faces_lines (const int stack_id, for (int i = 0; i < x - 1; i ++) { - graph_draw_line (stack_id, offset_vertex + i * 4 + 1, offset_vertex + i * 4 + 2); - graph_draw_line (stack_id, offset_vertex + i * 4 + 2, offset_vertex + i * 4 + 3); + graphics_draw_line (stack_id, offset_vertex + i * 4 + 1, offset_vertex + i * 4 + 2); + graphics_draw_line (stack_id, offset_vertex + i * 4 + 2, offset_vertex + i * 4 + 3); } offset_vertex += (x - 1) * 4; for (int i = 0; i < y - 1; i ++) { - graph_draw_line (stack_id, offset_vertex + i * 4 + 2, offset_vertex + i * 4 + 3); - graph_draw_line (stack_id, offset_vertex + i * 4 + 3, offset_vertex + i * 4 + 0); + graphics_draw_line (stack_id, offset_vertex + i * 4 + 2, offset_vertex + i * 4 + 3); + graphics_draw_line (stack_id, offset_vertex + i * 4 + 3, offset_vertex + i * 4 + 0); } offset_vertex += (y - 1) * 4; for (int i = 0; i < z - 1; i ++) { - graph_draw_line (stack_id, offset_vertex + i * 4 + 0, offset_vertex + i * 4 + 1); - graph_draw_line (stack_id, offset_vertex + i * 4 + 3, offset_vertex + i * 4 + 0); + graphics_draw_line (stack_id, offset_vertex + i * 4 + 0, offset_vertex + i * 4 + 1); + graphics_draw_line (stack_id, offset_vertex + i * 4 + 3, offset_vertex + i * 4 + 0); } return (x + y + z - 3) * 4; diff --git a/src/graphics/init.c b/src/graphics/init.c index 27ce7bc..dca3d5a 100644 --- a/src/graphics/init.c +++ b/src/graphics/init.c @@ -31,8 +31,8 @@ #define TEST 0 -struct graph_stack_t *graph_stack = NULL; -size_t graph_stack_size = 0; +struct graphics_stack_t *graphics_stack = NULL; +size_t graphics_stack_size = 0; int *free_stack_slot = NULL; size_t free_stack_slot_size = 0; @@ -50,7 +50,7 @@ size_t free_stack_slot_size = 0; * @return void */ -static void graph_debug_callback(GLenum source, GLenum type, GLuint id, +static void graphics_debug_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *msg, const void *data) { @@ -105,17 +105,17 @@ static void graph_debug_callback(GLenum source, GLenum type, GLuint id, * * @return id if initialized */ -int graph_init(void *error_buffer) +int graphics_init(void *error_buffer) { int cur_id = 0; - struct graph_stack_t *graph_stack = NULL; + struct graphics_stack_t *graphics_stack = NULL; - g_printerr("[debug] graph_init()\n"); + g_printerr("[debug] graphics_init()\n"); - if (graph_stack == NULL) { - graph_stack = g_malloc0 (sizeof(struct graph_stack_t)); - graph_stack_size = 1; - g_printerr("[debug] graph_init(): init graph_stack @ %p\n", graph_stack); + if (graphics_stack == NULL) { + graphics_stack = g_malloc0 (sizeof(struct graphics_stack_t)); + graphics_stack_size = 1; + g_printerr("[debug] graphics_init(): init graphics_stack @ %p\n", graphics_stack); } else { // Check if there are free slots if (free_stack_slot_size) { @@ -126,33 +126,33 @@ int graph_init(void *error_buffer) free_stack_slot_size-- * sizeof(int)); } else { - cur_id = graph_stack_size; - graph_stack = g_realloc (graph_stack, - ++graph_stack_size * - sizeof(struct graph_stack_t)); + cur_id = graphics_stack_size; + graphics_stack = g_realloc (graphics_stack, + ++graphics_stack_size * + sizeof(struct graphics_stack_t)); } } - memset(&graph_stack[cur_id], 0, sizeof(struct graph_stack_t)); + memset(&graphics_stack[cur_id], 0, sizeof(struct graphics_stack_t)); - g_printerr("[debug] graph_init() : graph_stack (@0x%p) has %ld elements\n", - graph_stack, - graph_stack_size); + g_printerr("[debug] graphics_init() : graphics_stack (@0x%p) has %ld elements\n", + graphics_stack, + graphics_stack_size); - graph_stack = &graph_stack[cur_id]; - graph_stack->id = cur_id; + graphics_stack = &graphics_stack[cur_id]; + graphics_stack->id = cur_id; glEnable(GL_DEBUG_OUTPUT); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); glEnable(GL_MULTISAMPLE); - if (!graph_init_shaders(cur_id)) return -1; + if (!graphics_init_shaders(cur_id)) return -1; - graph_print_stack(cur_id); + graphics_print_stack(cur_id); - graph_init_buffers(cur_id); + graphics_init_buffers(cur_id); - glDebugMessageCallback(graph_debug_callback, NULL); + glDebugMessageCallback(graphics_debug_callback, NULL); //print_stack(cur_id); @@ -166,37 +166,37 @@ int graph_init(void *error_buffer) * * @return true if success */ -bool graph_shutdown(const int id, void *error_buffer) +bool graphics_shutdown(const int id, void *error_buffer) { - struct graph_stack_t *graph_stack = NULL; // *graph_stack = &graph_stack[stack_id]; TODO + struct graphics_stack_t *graphics_stack = NULL; // *graphics_stack = &graphics_stack[stack_id]; TODO - if (id >= graph_stack_size || - graph_stack_size == 0 || - graph_stack == NULL) + if (id >= graphics_stack_size || + graphics_stack_size == 0 || + graphics_stack == NULL) return false; - graph_stack = &graph_stack[id]; + graphics_stack = &graphics_stack[id]; //XXX - free(graph_stack->arrows_ptr); - graph_stack->arrows_ptr = NULL; - graph_stack->arrows_nb = 0; + free(graphics_stack->arrows_ptr); + graphics_stack->arrows_ptr = NULL; + graphics_stack->arrows_nb = 0; - glDeleteBuffers(1, &graph_stack->position_buffer); - glDeleteBuffers(1, &graph_stack->color_buffer); - glDeleteProgram(graph_stack->program); + glDeleteBuffers(1, &graphics_stack->position_buffer); + glDeleteBuffers(1, &graphics_stack->color_buffer); + glDeleteProgram(graphics_stack->program); - g_free(graph_stack->buffer_vertex_origin); - g_free(graph_stack->buffer_colors_origin); - g_free(graph_stack->buffer_lines_origin); - g_free(graph_stack->buffer_plans_origin); + g_free(graphics_stack->buffer_vertex_origin); + g_free(graphics_stack->buffer_colors_origin); + g_free(graphics_stack->buffer_lines_origin); + g_free(graphics_stack->buffer_plans_origin); - if (graph_stack_size == 1) { - free(graph_stack); - graph_stack = NULL; - graph_stack_size = 0; + if (graphics_stack_size == 1) { + free(graphics_stack); + graphics_stack = NULL; + graphics_stack_size = 0; } else { - memset(&graph_stack[id], 0, sizeof(struct graph_stack_t)); + memset(&graphics_stack[id], 0, sizeof(struct graphics_stack_t)); free_stack_slot = g_realloc(free_stack_slot, ++free_stack_slot_size * sizeof(int)); @@ -219,17 +219,17 @@ bool graph_shutdown(const int id, void *error_buffer) * and allows ulterior creations, suppressions or modifications of the arrows[] array * * draws the space() - * triggers graph_set_arrows() that modifies the list () and draws arrows + * triggers graphics_set_arrows() that modifies the list () and draws arrows * * Initialisation du générateur pseudo-aléatoire * Attention, les vertex centraux de chaque unité d'espace (cube) * peuvent être redondants (max 6) */ -void graph_model_setup (const int stack_id) +void graphics_model_setup (const int stack_id) { /* I N I T I A L D A T A S P E C I F I C A T I O N */ - struct graph_stack_t *graph_stack = NULL; // *graph_stack = &graph_stack[stack_id]; TODO + struct graphics_stack_t *graphics_stack = NULL; // *graphics_stack = &graphics_stack[stack_id]; TODO char dimension; long space_X; long space_Y; @@ -238,7 +238,7 @@ void graph_model_setup (const int stack_id) int density_max; char multiplicity; - dimension = model_get_dim(); + dimension = parse_model_get_dim(); g_print("[GRAPH DEBUG] dim = %d\n", dimension); @@ -248,16 +248,16 @@ void graph_model_setup (const int stack_id) switch(dimension) { case 3: - space_Z = model_get_dim_value("z"); + space_Z = parse_model_get_dim_value("z"); ; case 2: - space_Y = model_get_dim_value("y"); + space_Y = parse_model_get_dim_value("y"); ; // even in 1D, we must be able to see a grid (or not !) if (!space_Y) space_Y = 1; case 1: - space_X = model_get_dim_value("x"); + space_X = parse_model_get_dim_value("x"); ; if (!space_X) space_X = 1; @@ -270,39 +270,39 @@ void graph_model_setup (const int stack_id) g_print("[GRAPH DEBUG] z = %ld\n", space_Z); density_max = space_X * space_Y * space_Z; - graph_stack->arrows_nb = 0; + graphics_stack->arrows_nb = 0; - multiplicity = model_get_multiplicity(); + multiplicity = parse_model_get_multiplicity(); g_print("[GRAPH DEBUG] site_multiplicity = %d, density_max = %d\n", multiplicity, density_max); /* S P A C E D R A W I N G */ - graph_draw_space_ridges_vertex (stack_id, graph_stack->buffer_vertex_size, space_X, space_Y, space_Z); - graph_draw_space_ridges_lines (stack_id); - graph_draw_grids_on_space_faces_vertex (stack_id, space_X, space_Y, space_Z); - graph_draw_grids_on_space_faces_lines (stack_id, graph_stack->buffer_lines_size, space_X, space_Y, space_Z); + graphics_draw_space_ridges_vertex (stack_id, graphics_stack->buffer_vertex_size, space_X, space_Y, space_Z); + graphics_draw_space_ridges_lines (stack_id); + graphics_draw_grids_on_space_faces_vertex (stack_id, space_X, space_Y, space_Z); + graphics_draw_grids_on_space_faces_lines (stack_id, graphics_stack->buffer_lines_size, space_X, space_Y, space_Z); - graph_stack->buffer_vertex_0_arrow = graph_stack->buffer_vertex_size; - graph_stack->buffer_colors_0_arrow = graph_stack->buffer_colors_size; - graph_stack->buffer_lines_0_arrow = graph_stack->buffer_lines_size; + graphics_stack->buffer_vertex_0_arrow = graphics_stack->buffer_vertex_size; + graphics_stack->buffer_colors_0_arrow = graphics_stack->buffer_colors_size; + graphics_stack->buffer_lines_0_arrow = graphics_stack->buffer_lines_size; /* A R R O W S D R A W I N G */ char state_id[30] = {0}; struct arrow_t arrow = {0}; - assert(model_get_next_state((char *)&state_id)); + assert(parse_model_get_next_state((char *)&state_id)); g_print("[GRAPH DEBUG] first state is = %s\n", state_id); - announced_arrows_nb = model_get_state_arrows_count(state_id); + announced_arrows_nb = parse_model_get_state_arrows_count(state_id); g_print("[GRAPH DEBUG] announced_arrows_nb is = %ld\n", announced_arrows_nb); - while (model_get_next_arrow(&arrow, (char *)&state_id, dimension)) { + while (parse_model_get_next_arrow(&arrow, (char *)&state_id, dimension)) { g_print("[GRAPH DEBUG] cur arrow has x = %d\n", arrow.x); - graph_stack->arrows_nb = graph_set_arrow (stack_id, - graph_stack->arrows_nb, + graphics_stack->arrows_nb = graphics_set_arrow (stack_id, + graphics_stack->arrows_nb, space_X, space_Y, space_Z, @@ -313,7 +313,7 @@ void graph_model_setup (const int stack_id) arrow.z); } - if (graph_stack->arrows_nb != announced_arrows_nb) + if (graphics_stack->arrows_nb != announced_arrows_nb) g_printerr("ARGH : not all arrows have been parsed !\n"); } @@ -323,21 +323,21 @@ void graph_model_setup (const int stack_id) * @param gl_area, ptr to the gl_area widget * @return void */ -void graph_init_buffers(const int stack_id) +void graphics_init_buffers(const int stack_id) { - struct graph_stack_t *graph_stack = NULL; // *graph_stack = &graph_stack[stack_id]; TODO + struct graphics_stack_t *graphics_stack = NULL; // *graphics_stack = &graphics_stack[stack_id]; TODO //XXX - graph_model_setup(stack_id); + graphics_model_setup(stack_id); GLuint vao, vertex_buffer, color_buffer; glGenBuffers(1, &vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); glBufferData(GL_ARRAY_BUFFER, - graph_stack->buffer_vertex_size * - sizeof(graph_stack->buffer_vertex_origin[0]), - graph_stack->buffer_vertex_origin, + graphics_stack->buffer_vertex_size * + sizeof(graphics_stack->buffer_vertex_origin[0]), + graphics_stack->buffer_vertex_origin, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); @@ -345,9 +345,9 @@ void graph_init_buffers(const int stack_id) // colors glGenBuffers(1, &color_buffer); glBindBuffer(GL_ARRAY_BUFFER, color_buffer); - glBufferData(GL_ARRAY_BUFFER, graph_stack->buffer_colors_size * - sizeof(graph_stack->buffer_colors_origin[0]), - graph_stack->buffer_colors_origin, + glBufferData(GL_ARRAY_BUFFER, graphics_stack->buffer_colors_size * + sizeof(graphics_stack->buffer_colors_origin[0]), + graphics_stack->buffer_colors_origin, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); @@ -355,9 +355,9 @@ void graph_init_buffers(const int stack_id) glGenVertexArrays(1, &vao); glBindVertexArray(vao); - graph_stack->vao = vao; - graph_stack->position_buffer = vertex_buffer; - graph_stack->color_buffer = color_buffer; + graphics_stack->vao = vao; + graphics_stack->position_buffer = vertex_buffer; + graphics_stack->color_buffer = color_buffer; } /* @@ -367,9 +367,9 @@ void graph_init_buffers(const int stack_id) * * @return true if initialized */ -bool graph_init_shaders(const int stack_id) +bool graphics_init_shaders(const int stack_id) { - struct graph_stack_t *graph_stack = NULL; // *graph_stack = &graph_stack[stack_id]; TODO + struct graphics_stack_t *graphics_stack = NULL; // *graphics_stack = &graphics_stack[stack_id]; TODO char *vertex_shader; char *fragment_shader; int status; @@ -383,10 +383,10 @@ bool graph_init_shaders(const int stack_id) vertex_shader = read_file(VERTEX_SHADER_FILE); if (vertex_shader == NULL) return false; - vertex = graph_create_shader(stack_id, GL_VERTEX_SHADER, vertex_shader); + vertex = graphics_create_shader(stack_id, GL_VERTEX_SHADER, vertex_shader); if(vertex == 0) { - graph_stack->program = 0; + graphics_stack->program = 0; g_free(vertex_shader); return false; } @@ -395,11 +395,11 @@ bool graph_init_shaders(const int stack_id) fragment_shader = read_file(FRAG_SHADER_FILE); if (fragment_shader == NULL) return false; - fragment = graph_create_shader(stack_id, GL_FRAGMENT_SHADER, fragment_shader); + fragment = graphics_create_shader(stack_id, GL_FRAGMENT_SHADER, fragment_shader); if(fragment == 0) { glDeleteShader(vertex); - graph_stack->program = 0; + graphics_stack->program = 0; g_free(vertex_shader); g_free(fragment_shader); return false; @@ -408,7 +408,7 @@ bool graph_init_shaders(const int stack_id) // Link shaders to program program = glCreateProgram(); printf("\n------------------------------------------------------------------------------------------\n"); - printf("[debug] graph_init_shaders() : program = %d, vertex = %d, fragment = %d\n\ + printf("[debug] graphics_init_shaders() : program = %d, vertex = %d, fragment = %d\n\ exec > ** (myprogram:-----): WARNING ** : --:--:--:---: Linking failure: (address)\n", program, vertex, fragment); @@ -422,7 +422,7 @@ bool graph_init_shaders(const int stack_id) glAttachShader(program, vertex); glAttachShader(program, fragment); - printf("Failed to link the graphic stack to widgets ! <> see init.c graph_init_shaders()\n"); + printf("Failed to link the graphic stack to widgets ! <> see init.c graphics_init_shaders()\n"); printf("the error in not : vertex shader lacks `main' but : failed to link... (comment line 140)\n"); // https://registry.khronos.org/OpenGL-Refpages/gl4/html/glLinkProgram.xhtml // glLinkProgram(program); // Linking failure: (address) @@ -467,10 +467,10 @@ bool graph_init_shaders(const int stack_id) glDeleteShader(vertex); glDeleteShader(fragment); - graph_stack->program = program; - graph_stack->m = m; - graph_stack->v = v; - graph_stack->p = p; + graphics_stack->program = program; + graphics_stack->m = m; + graphics_stack->v = v; + graphics_stack->p = p; g_free(vertex_shader); g_free(fragment_shader); diff --git a/src/graphics/stack.c b/src/graphics/stack.c index 288bad0..ffbc8b5 100644 --- a/src/graphics/stack.c +++ b/src/graphics/stack.c @@ -38,7 +38,7 @@ static struct stack_index_t *stack_index = NULL; size_t stack_index_size = 0; -int graph_set_arrow (int stack_id, // 2024-06-27 DEBUG ! +int graphics_set_arrow (int stack_id, // 2024-06-27 DEBUG ! int arrows_nb, int space_X, int space_Y, @@ -48,7 +48,7 @@ int graph_set_arrow (int stack_id, // 2024-06-27 DEBUG ! int arrow_x, int arrow_y, int arrow_z) { - printf("graph_area.c > int graph_set_arrow (...) 2024-06-27 DEBUG\n"); + printf("graphics_area.c > int graphics_set_arrow (...) 2024-06-27 DEBUG\n"); return 0; } // 2024-06-27 DEBUG ! @@ -62,7 +62,7 @@ int graph_set_arrow (int stack_id, // 2024-06-27 DEBUG ! * * @returns stack_id */ -long graph_get_graph_stack(void *container_widget) +long graphics_get_graphics_stack(void *container_widget) { // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { @@ -80,7 +80,7 @@ long graph_get_graph_stack(void *container_widget) * * @returns stack_id */ -long graph_is_graph_stack_ready(void *container_widget) +long graphics_is_graphics_stack_ready(void *container_widget) { // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { @@ -98,20 +98,20 @@ long graph_is_graph_stack_ready(void *container_widget) * * @returns bool, true if success */ -bool graph_init_graph_stack(void *container_widget, GError *error_buffer) +bool graphics_init_graphics_stack(void *container_widget, GError *error_buffer) { - g_printerr("[debug] graph_init_graph_stack()\n"); + g_printerr("[debug] graphics_init_graphics_stack()\n"); - g_printerr("[debug] graph_init_graph_stack() : target is %p\n", container_widget); + g_printerr("[debug] graphics_init_graphics_stack() : target is %p\n", container_widget); // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { - g_printerr("[debug] graph_init_graph_stack() : i is %d\n", i); - g_printerr("[debug] graph_init_graph_stack() : target would be %p\n", + g_printerr("[debug] graphics_init_graphics_stack() : i is %d\n", i); + g_printerr("[debug] graphics_init_graphics_stack() : target would be %p\n", stack_index[i].container_widget); if (stack_index[i].container_widget == (void *)container_widget) { - stack_index[i].stack_id = graph_init(&error_buffer); - g_printerr("[debug] graph_init_graph_stack() : stack_id is %ld\n", + stack_index[i].stack_id = graphics_init(&error_buffer); + g_printerr("[debug] graphics_init_graphics_stack() : stack_id is %ld\n", stack_index[i].stack_id); if (stack_index[i].stack_id >= 0) return true; @@ -129,12 +129,12 @@ bool graph_init_graph_stack(void *container_widget, GError *error_buffer) * * @returns bool, true if success */ -bool graph_shutdown_graph_stack(void *container_widget, GError *error_buffer) +bool graphics_shutdown_graphics_stack(void *container_widget, GError *error_buffer) { // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { if (stack_index[i].container_widget == (void *)container_widget) { - if (graph_shutdown(stack_index[i].stack_id, + if (graphics_shutdown(stack_index[i].stack_id, &error_buffer) == false) { return false; } @@ -146,7 +146,7 @@ bool graph_shutdown_graph_stack(void *container_widget, GError *error_buffer) } -void graph_clean_stack_index(void) +void graphics_clean_stack_index(void) { // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { @@ -162,19 +162,19 @@ void graph_clean_stack_index(void) * * @returns bool, true if success */ -bool graph_render_stack(GtkWidget *container_widget) +bool graphics_render_stack(GtkWidget *container_widget) { // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { if (stack_index[i].container_widget == (void *)container_widget) { - graph_draw (stack_index[i].stack_id); + graphics_draw (stack_index[i].stack_id); return true; } } return false; } -//void graph_draw(const int stack_id) {printf("graph_area.c > void graph_draw(const int stack_id) (161)\n");} +//void graphics_draw(const int stack_id) {printf("graphics_area.c > void graphics_draw(const int stack_id) (161)\n");} /* * Look for stack entry and triggers OpenGL for drawing @@ -183,12 +183,12 @@ bool graph_render_stack(GtkWidget *container_widget) * * @returns bool, true if success */ -bool graph_update_axis_stack(GtkWidget *container_widget, int axis, int value) +bool graphics_update_axis_stack(GtkWidget *container_widget, int axis, int value) { // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { if (stack_index[i].container_widget == (void *)container_widget) { - graph_stack[stack_index[i].stack_id].rotation_angles[axis] = value; + graphics_stack[stack_index[i].stack_id].rotation_angles[axis] = value; gtk_widget_queue_draw((GtkWidget*)(stack_index[i].gl_area)); return true; } @@ -203,11 +203,11 @@ bool graph_update_axis_stack(GtkWidget *container_widget, int axis, int value) * * @returns bool, true if success */ -void graph_shutdown_all_graph_stacks(void) +void graphics_shutdown_all_graphics_stacks(void) { // look for stack_index entry for (int i = 0; i < stack_index_size; i++) { - graph_shutdown(stack_index[i].stack_id, NULL); + graphics_shutdown(stack_index[i].stack_id, NULL); } return; } @@ -263,20 +263,20 @@ GtkWidget *create_axis_slider(int axis) /* * Creates GLArea and indexes it * - * @params target_mode, meaning which graph_stack we're on + * @params target_mode, meaning which graphics_stack we're on * target_widget, meaning the box that will host the GLArea * * @returns bool, true if success */ -bool graph_setup_glarea(int target_mode, GtkWidget *target_widget) +bool graphics_setup_glarea(int target_mode, GtkWidget *target_widget) { GtkWidget *gl_area; - g_printerr("[debug] graph_setup_glarea()\n"); + g_printerr("[debug] graphics_setup_glarea()\n"); assert(target_widget); - g_printerr("[debug] graph_setup_glarea() : target is %p\n", target_widget); + g_printerr("[debug] graphics_setup_glarea() : target is %p\n", target_widget); if (stack_index == NULL) { stack_index = g_malloc(sizeof(struct stack_index_t)); @@ -314,9 +314,9 @@ bool graph_setup_glarea(int target_mode, GtkWidget *target_widget) stack_index[stack_index_size-1].gl_area = (void*)gl_area; - g_printerr("[debug] graph_setup_glarea() : set target to %p\n", target_widget); + g_printerr("[debug] graphics_setup_glarea() : set target to %p\n", target_widget); - g_printerr("[debug] graph_setup_glarea() : stack_index (@0x%p) had %ld elements\n", + g_printerr("[debug] graphics_setup_glarea() : stack_index (@0x%p) had %ld elements\n", stack_index, stack_index_size); diff --git a/src/parse.c b/src/parse.c index 628d706..3467145 100644 --- a/src/parse.c +++ b/src/parse.c @@ -44,9 +44,9 @@ #define SUCCESSFUL_READ_ARROW_XYZ (READ_SITE | READ_WEIGHT | READ_X | READ_Y | READ_Z) static xmlDocPtr model; -static xmlHashTablePtr model_hashtable; +static xmlHashTablePtr parse_model_hashtable; -bool model_init(const char *content, size_t length, const char *basename) +bool parse_parse_model_init(const char *content, size_t length, const char *basename) { xmlNode *node; @@ -77,9 +77,9 @@ bool model_init(const char *content, size_t length, const char *basename) return false; } - model_hashtable = xmlHashCreate(0); + parse_model_hashtable = xmlHashCreate(0); - if (model_hashtable == NULL) { + if (parse_model_hashtable == NULL) { g_printerr("Can't create model hash table !\n"); xmlFreeDoc(model); return false; @@ -88,10 +88,10 @@ bool model_init(const char *content, size_t length, const char *basename) return true; } -bool model_shutdown(void) +bool parse_model_shutdown(void) { xmlFreeDoc(model); - xmlHashFree(model_hashtable, NULL); + xmlHashFree(parse_model_hashtable, NULL); // Cleanup function for the XML library xmlCleanupParser(); @@ -142,14 +142,14 @@ static inline xmlChar* getLastTag(xmlChar *path) /******************************************************************************/ -static xmlNodePtr model_get_node(xmlChar *path) +static xmlNodePtr parse_model_get_node(xmlChar *path) { xmlNodePtr node; xmlChar *extrait; xmlChar *reste, *last; // Lookup for node from path in hash table - node = xmlHashLookup(model_hashtable, path); + node = xmlHashLookup(parse_model_hashtable, path); // Found a node in hash table if (node) { @@ -174,7 +174,7 @@ static xmlNodePtr model_get_node(xmlChar *path) while (node && xmlStrcmp(node->name, last)) { node = node->next; } - xmlHashAddEntry (model_hashtable, path, node); + xmlHashAddEntry (parse_model_hashtable, path, node); } return node; @@ -186,7 +186,7 @@ static xmlNodePtr model_get_node(xmlChar *path) /******************************************************************************/ -static inline long model_get_node_long_attrib(xmlNodePtr node, char *id) +static inline long parse_model_get_node_long_attrib(xmlNodePtr node, char *id) { xmlAttr *attribute; xmlChar* value; @@ -207,7 +207,7 @@ static inline long model_get_node_long_attrib(xmlNodePtr node, char *id) return 0; } -static inline bool model_get_node_str_attrib(xmlNodePtr node, +static inline bool parse_model_get_node_str_attrib(xmlNodePtr node, char *id, char *dest) { @@ -231,11 +231,11 @@ static inline bool model_get_node_str_attrib(xmlNodePtr node, /******************************************************************************/ -char model_get_dim(void) +char parse_model_get_dim(void) { // xmlAttr *attribute; // xmlChar* value; - xmlNodePtr node = model_get_node( + xmlNodePtr node = parse_model_get_node( (xmlChar *)"parameters/space-param/dimension"); if (xmlHasProp (node, (xmlChar *) "z")) return 3; @@ -244,22 +244,22 @@ char model_get_dim(void) return 0; } -long model_get_dim_value(const char *axis) +long parse_model_get_dim_value(const char *axis) { // xmlAttr *attribute; // xmlChar *value; // long ret_value; - xmlNodePtr node = model_get_node( + xmlNodePtr node = parse_model_get_node( (xmlChar *)"parameters/space-param/dimension"); - return model_get_node_long_attrib(node, (char *)axis); + return parse_model_get_node_long_attrib(node, (char *)axis); } -char model_get_multiplicity(void) +char parse_model_get_multiplicity(void) { // xmlAttr *attribute; // xmlChar* value; - xmlNodePtr node = model_get_node( + xmlNodePtr node = parse_model_get_node( (xmlChar *)"parameters/space-param/site_multiplicity"); if (node->children) @@ -269,7 +269,7 @@ char model_get_multiplicity(void) return 0; } -bool model_get_next_state(char *new_state_id) +bool parse_model_get_next_state(char *new_state_id) { static xmlNodePtr cur_node = NULL; // xmlAttr *attribute; @@ -277,7 +277,7 @@ bool model_get_next_state(char *new_state_id) if (cur_node == NULL) { // Get first state - cur_node = model_get_node((xmlChar *)"savedstates/state"); + cur_node = parse_model_get_node((xmlChar *)"savedstates/state"); } else { // Get next state @@ -288,14 +288,14 @@ bool model_get_next_state(char *new_state_id) } // Lookup in properties - if (model_get_node_str_attrib(cur_node, "id", new_state_id)) + if (parse_model_get_node_str_attrib(cur_node, "id", new_state_id)) return true; cur_node = NULL; return false; } -long model_get_state_arrows_count(const char *state_id) +long parse_model_get_state_arrows_count(const char *state_id) { xmlNodePtr cur_node = NULL; // xmlAttr *attribute; @@ -309,14 +309,14 @@ long model_get_state_arrows_count(const char *state_id) assert(state_id); // Get first state node - cur_node = model_get_node((xmlChar *)"savedstates/state"); + cur_node = parse_model_get_node((xmlChar *)"savedstates/state"); // Lookup in properties while (cur_node && cur_node->properties) { // attribute = cur_node->properties; < usage ? // Look for the id attribute - if (model_get_node_str_attrib(cur_node, "id", (char *)&temp_char)) { + if (parse_model_get_node_str_attrib(cur_node, "id", (char *)&temp_char)) { if (!xmlStrcmp((const xmlChar *)temp_char, (const xmlChar *)state_id)) { found = true; break; @@ -346,7 +346,7 @@ long model_get_state_arrows_count(const char *state_id) return value; } -bool model_get_next_arrow(struct arrow_t *new_arrow, +bool parse_model_get_next_arrow(struct arrow_t *new_arrow, const char *state_id, char dimension) { @@ -364,14 +364,14 @@ bool model_get_next_arrow(struct arrow_t *new_arrow, if (cur_node == NULL) { // Get first state node - cur_node = model_get_node((xmlChar *)"savedstates/state"); + cur_node = parse_model_get_node((xmlChar *)"savedstates/state"); // Lookup in properties while (cur_node && cur_node->properties) { attribute = cur_node->properties; // Look for the id attribute - if (model_get_node_str_attrib(cur_node, "id", (char *)&temp_char)) { + if (parse_model_get_node_str_attrib(cur_node, "id", (char *)&temp_char)) { if (!xmlStrcmp((xmlChar *)temp_char, (const xmlChar *)state_id)) { found = true; break; diff --git a/src/calls.c b/src/signal.c similarity index 92% rename from src/calls.c rename to src/signal.c index 04f63d3..77fadf9 100644 --- a/src/calls.c +++ b/src/signal.c @@ -64,14 +64,14 @@ static void on_auto_notification (const char *message) void on_windows_activation (GtkApplication *app, gpointer no_user_data) { - widget_head_set_MAIN_WINDOW (app); - widget_head_MAIN_WINDOW_design (widget_head_get_MAIN_WINDOW()); + widget_head_fix_MAIN_WINDOW (app); + widget_head_MAIN_WINDOW_design (widget_head_rec_MAIN_WINDOW()); - widget_head_set_DIALOG_WINDOW (app); - widget_head_DIALOG_WINDOW_design (widget_head_get_MAIN_WINDOW(), widget_head_get_DIALOG_WINDOW()); + widget_head_fix_DIALOG_WINDOW (app); + widget_head_DIALOG_WINDOW_design (widget_head_rec_MAIN_WINDOW(), widget_head_rec_DIALOG_WINDOW()); - widget_head_set_TEXT_WINDOW (app); - widget_head_TEXT_WINDOW_design (widget_head_get_MAIN_WINDOW(), widget_head_get_TEXT_WINDOW()); + widget_head_fix_TEXT_WINDOW (app); + widget_head_TEXT_WINDOW_design (widget_head_rec_MAIN_WINDOW(), widget_head_rec_TEXT_WINDOW()); } @@ -135,7 +135,7 @@ gboolean on_glarea_render(GtkGLArea *area, return false; } - if (graph_render_stack(gtk_widget_get_parent(GTK_WIDGET(area))) == false) { + if (graphics_render_stack(gtk_widget_get_parent(GTK_WIDGET(area))) == false) { on_auto_notification("Failed to render corresponding graphic stack !"); return false; } @@ -159,7 +159,7 @@ void on_glarea_realize(GtkWidget *widget) } // Link graphical stack to widget - if (graph_init_graph_stack(gtk_widget_get_parent(widget), + if (graphics_init_graphics_stack(gtk_widget_get_parent(widget), internal_error) == false) { on_auto_notification( "Failed to link the graphic stack to widgets !"); @@ -184,7 +184,7 @@ void on_glarea_unrealize(GtkWidget *widget) } // Destroy graphic stack - if (graph_shutdown_graph_stack(gtk_widget_get_parent(widget), + if (graphics_shutdown_graphics_stack(gtk_widget_get_parent(widget), internal_error) == false) { on_auto_notification( "Failed to shutdown the graphic stack !"); @@ -206,7 +206,7 @@ void on_axis_value_change(GtkAdjustment *adjustment, gpointer data) g_assert(axis >= 0 && axis < N_AXIS); /* Update the rotation angle */ - graph_update_axis_stack(container_widget, + graphics_update_axis_stack(container_widget, axis, gtk_adjustment_get_value(adjustment)); @@ -251,18 +251,18 @@ static void switch_STATE_RULES_DATA() switch (get_STATE_RULES_DATA()) { case (STATE) : - gtk_window_set_child (widget_head_get_MAIN_WINDOW(), - GTK_WIDGET (get_STATE_page())); + gtk_window_set_child (widget_head_rec_MAIN_WINDOW(), + GTK_WIDGET (widget_rec_STATE_page())); break; case (RULES) : - gtk_window_set_child (widget_head_get_MAIN_WINDOW(), - GTK_WIDGET (get_RULES_page())); + gtk_window_set_child (widget_head_rec_MAIN_WINDOW(), + GTK_WIDGET (widget_rec_RULES_page())); break; case (DATA) : - gtk_window_set_child (widget_head_get_MAIN_WINDOW(), - GTK_WIDGET (get_STOCK_page())); + gtk_window_set_child (widget_head_rec_MAIN_WINDOW(), + GTK_WIDGET (widget_rec_STOCK_page())); break; default : @@ -284,7 +284,7 @@ void on_toggle_EXEC_EDIT (GtkWidget *toggled_button, gpointer user_data) "text-editor-symbolic"); // https://docs.gtk.org/gtk4/class.Window.html TODO 2024-06-30 - // gtk_window_present (GTK_WINDOW (widget_head_get_DIALOG_WINDOW())); // works once only ! + // gtk_window_present (GTK_WINDOW (widget_head_rec_DIALOG_WINDOW())); // works once only ! set_EXEC_EDIT (EDIT); } @@ -350,14 +350,14 @@ void on_SITUATIONS_box_DO_RESET (GtkWidget *btt_reset, gpointer data) void on_clicked_search (GtkWidget *btt_menu, gpointer list_box) { // next line presents the text_window and works only once.\nIt should present a menu.\n"); // TODO - gtk_window_present (GTK_WINDOW (widget_head_get_TEXT_WINDOW())); + gtk_window_present (GTK_WINDOW (widget_head_rec_TEXT_WINDOW())); } void on_clicked_HOME (GtkWidget *btt_reset, gpointer data) { printf ("callback.on_clicked_HOME() button presents the dialog_window\ ( :- ) but it works only once.\n"); // TODO - gtk_window_present (GTK_WINDOW (widget_head_get_DIALOG_WINDOW())); + gtk_window_present (GTK_WINDOW (widget_head_rec_DIALOG_WINDOW())); } diff --git a/src/widget/labo.c b/src/widget/labo.c index 8057b57..6730b07 100644 --- a/src/widget/labo.c +++ b/src/widget/labo.c @@ -103,35 +103,35 @@ void learning_how_to_create_a_menu (GtkMenuButton* menu_button) { // Je veux qu void labo_let_us_create_a_complex_useless_and_expensive_tree (struct TreeNode_t *tree_root) { - struct TreeNode_t *a = create_user_tree_node("We, the people");add_child_node(tree_root, a); - struct TreeNode_t *b = create_user_tree_node("in Order to"); add_child_node(tree_root, b); - struct TreeNode_t *c = create_user_tree_node("do establish"); add_child_node(tree_root, c); - struct TreeNode_t *aa = create_user_tree_node("aware of"); add_child_node(a, aa); - struct TreeNode_t *aaa = create_user_tree_node("our rights"); add_child_node(aa, aaa); - struct TreeNode_t *aab = create_user_tree_node("our duties"); add_child_node(aa, aab); - struct TreeNode_t *aaaa = create_user_tree_node("read"); add_child_node(aaa, aaaa); - struct TreeNode_t *aaab = create_user_tree_node("write"); add_child_node(aaa, aaab); - struct TreeNode_t *aaac = create_user_tree_node("copy"); add_child_node(aaa, aaac); - struct TreeNode_t *aaad = create_user_tree_node("edit"); add_child_node(aaa, aaad); - struct TreeNode_t *aaaba= create_user_tree_node("code"); add_child_node(aaab, aaaba); - struct TreeNode_t *aaabb= create_user_tree_node("language"); add_child_node(aaab, aaabb); - struct TreeNode_t *aaabc= create_user_tree_node("any art..."); add_child_node(aaab, aaabc); - struct TreeNode_t *aaadb= create_user_tree_node("publish"); add_child_node(aaac, aaadb); - struct TreeNode_t *aaada= create_user_tree_node("create"); add_child_node(aaad, aaada); - struct TreeNode_t *aaba = create_user_tree_node("learn"); add_child_node(aab, aaba); - struct TreeNode_t *aabb = create_user_tree_node("help"); add_child_node(aab, aabb); - struct TreeNode_t *ba = create_user_tree_node("promote"); add_child_node(b, ba); - struct TreeNode_t *bb = create_user_tree_node("individual"); add_child_node(b, bb); - struct TreeNode_t *bc = create_user_tree_node("and common"); add_child_node(b, bc); - struct TreeNode_t *bca = create_user_tree_node("education"); add_child_node(bc, bca); - struct TreeNode_t *bcb = create_user_tree_node("mutual"); add_child_node(bc, bcb); - struct TreeNode_t *bcc = create_user_tree_node("support"); add_child_node(bc, bcc); - struct TreeNode_t *bcd = create_user_tree_node("health"); add_child_node(bc, bcd); - struct TreeNode_t *bcda = create_user_tree_node("mental"); add_child_node(bcd, bcda); - struct TreeNode_t *bcdb = create_user_tree_node("physical"); add_child_node(bcd, bcdb); - struct TreeNode_t *ca = create_user_tree_node("free"); add_child_node(c, ca); - struct TreeNode_t *cb = create_user_tree_node("code"); add_child_node(c, cb); - struct TreeNode_t *cc = create_user_tree_node("access"); add_child_node(c, cc); + struct TreeNode_t *a = widget_create_user_tree_node("We, the people");widget_add_child_node(tree_root, a); + struct TreeNode_t *b = widget_create_user_tree_node("in Order to"); widget_add_child_node(tree_root, b); + struct TreeNode_t *c = widget_create_user_tree_node("do establish"); widget_add_child_node(tree_root, c); + struct TreeNode_t *aa = widget_create_user_tree_node("aware of"); widget_add_child_node(a, aa); + struct TreeNode_t *aaa = widget_create_user_tree_node("our rights"); widget_add_child_node(aa, aaa); + struct TreeNode_t *aab = widget_create_user_tree_node("our duties"); widget_add_child_node(aa, aab); + struct TreeNode_t *aaaa = widget_create_user_tree_node("read"); widget_add_child_node(aaa, aaaa); + struct TreeNode_t *aaab = widget_create_user_tree_node("write"); widget_add_child_node(aaa, aaab); + struct TreeNode_t *aaac = widget_create_user_tree_node("copy"); widget_add_child_node(aaa, aaac); + struct TreeNode_t *aaad = widget_create_user_tree_node("edit"); widget_add_child_node(aaa, aaad); + struct TreeNode_t *aaaba= widget_create_user_tree_node("code"); widget_add_child_node(aaab, aaaba); + struct TreeNode_t *aaabb= widget_create_user_tree_node("language"); widget_add_child_node(aaab, aaabb); + struct TreeNode_t *aaabc= widget_create_user_tree_node("any art..."); widget_add_child_node(aaab, aaabc); + struct TreeNode_t *aaadb= widget_create_user_tree_node("publish"); widget_add_child_node(aaac, aaadb); + struct TreeNode_t *aaada= widget_create_user_tree_node("create"); widget_add_child_node(aaad, aaada); + struct TreeNode_t *aaba = widget_create_user_tree_node("learn"); widget_add_child_node(aab, aaba); + struct TreeNode_t *aabb = widget_create_user_tree_node("help"); widget_add_child_node(aab, aabb); + struct TreeNode_t *ba = widget_create_user_tree_node("promote"); widget_add_child_node(b, ba); + struct TreeNode_t *bb = widget_create_user_tree_node("individual"); widget_add_child_node(b, bb); + struct TreeNode_t *bc = widget_create_user_tree_node("and common"); widget_add_child_node(b, bc); + struct TreeNode_t *bca = widget_create_user_tree_node("education"); widget_add_child_node(bc, bca); + struct TreeNode_t *bcb = widget_create_user_tree_node("mutual"); widget_add_child_node(bc, bcb); + struct TreeNode_t *bcc = widget_create_user_tree_node("support"); widget_add_child_node(bc, bcc); + struct TreeNode_t *bcd = widget_create_user_tree_node("health"); widget_add_child_node(bc, bcd); + struct TreeNode_t *bcda = widget_create_user_tree_node("mental"); widget_add_child_node(bcd, bcda); + struct TreeNode_t *bcdb = widget_create_user_tree_node("physical"); widget_add_child_node(bcd, bcdb); + struct TreeNode_t *ca = widget_create_user_tree_node("free"); widget_add_child_node(c, ca); + struct TreeNode_t *cb = widget_create_user_tree_node("code"); widget_add_child_node(c, cb); + struct TreeNode_t *cc = widget_create_user_tree_node("access"); widget_add_child_node(c, cc); } void labo_create_a_simple_gtk_string_list () { diff --git a/src/widget/rules.c b/src/widget/rules.c index 80485b3..87c4698 100644 --- a/src/widget/rules.c +++ b/src/widget/rules.c @@ -29,10 +29,8 @@ #include "../../include/widget.h" -#define W 1920 // TODO 2024-06-30 -#define H 960 // Ad hoc (pour mon écran) -#define W_IMAGE_LOCAL W / 64 -#define H_IMAGE_LOCAL H / 64 +#define W_IMAGE_LOCAL 1920 / 64 // 1920 x 960 ad hoc (pour mon écran) +#define H_IMAGE_LOCAL 960 / 64 static GtkWidget *get_selected_rules_vpaned_new() { GtkPaned *EXEC_CONTROLS_pane = GTK_PANED (gtk_paned_new (GTK_ORIENTATION_VERTICAL)); @@ -42,14 +40,14 @@ static GtkWidget *get_selected_rules_vpaned_new() { gtk_paned_set_shrink_end_child (EXEC_CONTROLS_pane, FALSE); GtkBox *up_box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2)); - gtk_box_append (up_box, GTK_WIDGET (get_image_GLUTAMATE())); + gtk_box_append (up_box, GTK_WIDGET (widget_rec_image_GLUTAMATE())); gtk_box_append (up_box, GTK_WIDGET (gtk_separator_new (GTK_ORIENTATION_VERTICAL))); - gtk_box_append (up_box, GTK_WIDGET (get_image_GLUTAMINE())); + gtk_box_append (up_box, GTK_WIDGET (widget_rec_image_GLUTAMINE())); GtkBox *bottom_box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2)); - gtk_box_append (bottom_box, GTK_WIDGET (get_image_ATP())); + gtk_box_append (bottom_box, GTK_WIDGET (widget_rec_image_ATP())); gtk_box_append (bottom_box, GTK_WIDGET (gtk_separator_new (GTK_ORIENTATION_VERTICAL))); - gtk_box_append (bottom_box, GTK_WIDGET (get_image_AMP())); + gtk_box_append (bottom_box, GTK_WIDGET (widget_rec_image_AMP())); gtk_paned_set_start_child (EXEC_CONTROLS_pane, GTK_WIDGET (up_box)); gtk_paned_set_end_child (EXEC_CONTROLS_pane, GTK_WIDGET (bottom_box)); @@ -60,13 +58,13 @@ static GtkWidget *get_selected_rules_vpaned_new() { static GtkBox *get_rules_comparator_new(){ GtkBox *comparator = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 2)); gtk_widget_set_size_request (GTK_WIDGET (comparator), W_IMAGE_LOCAL, H_IMAGE_LOCAL); - gtk_box_append (comparator, GTK_WIDGET (get_image_ATP())); + gtk_box_append (comparator, GTK_WIDGET (widget_rec_image_ATP())); gtk_box_append (comparator, GTK_WIDGET(gtk_separator_new (GTK_ORIENTATION_HORIZONTAL))); - gtk_box_append (comparator, GTK_WIDGET (get_image_AMP())); + gtk_box_append (comparator, GTK_WIDGET (widget_rec_image_AMP())); gtk_box_append (comparator, GTK_WIDGET(gtk_separator_new (GTK_ORIENTATION_HORIZONTAL))); - gtk_box_append (comparator, GTK_WIDGET (get_image_GLUTAMATE())); + gtk_box_append (comparator, GTK_WIDGET (widget_rec_image_GLUTAMATE())); gtk_box_append (comparator, GTK_WIDGET(gtk_separator_new (GTK_ORIENTATION_HORIZONTAL))); - gtk_box_append (comparator, GTK_WIDGET (get_image_GLUTAMINE())); + gtk_box_append (comparator, GTK_WIDGET (widget_rec_image_GLUTAMINE())); gtk_box_append (comparator, GTK_WIDGET(gtk_separator_new (GTK_ORIENTATION_HORIZONTAL))); gtk_box_append (comparator, GTK_WIDGET (gtk_picture_new_for_filename ("/home/jean/Gem-Graph/gem-graph-client/data/image/histidine.png"))); gtk_box_append (comparator, GTK_WIDGET(gtk_separator_new (GTK_ORIENTATION_HORIZONTAL))); @@ -83,7 +81,7 @@ static GtkWidget *get_rules_tree_hpaned_new(){ // GtkWidget *arbre_des_règles = gtk_frame_new ("Arbre"); // GtkWidget *comparaison_des_règles_sélectionnées = gtk_frame_new ("Sélection"); - gtk_paned_set_start_child (H_tree_vs_comparison, GTK_WIDGET (get_user_rules_tree())); + gtk_paned_set_start_child (H_tree_vs_comparison, GTK_WIDGET (widget_rec_user_rules_tree())); gtk_paned_set_end_child (H_tree_vs_comparison, GTK_WIDGET (get_rules_comparator_new())); gtk_paned_set_position (H_tree_vs_comparison, 300); gtk_paned_set_wide_handle (H_tree_vs_comparison, TRUE); @@ -93,7 +91,7 @@ static GtkWidget *get_rules_tree_hpaned_new(){ return GTK_WIDGET (H_tree_vs_comparison); } -GtkWidget *get_RULES_page() { +GtkWidget *widget_rec_RULES_page() { GtkPaned *H_tree_vs_selected = GTK_PANED (gtk_paned_new (GTK_ORIENTATION_HORIZONTAL)); // GtkWidget *arbre_des_règles = gtk_frame_new ("Arbre des règles"); // GtkWidget *édition_de_la_règle_sélectionnée_n_1 = gtk_frame_new ("Inspection"); diff --git a/src/widget/state.c b/src/widget/state.c index 19c9cf9..d91dcd4 100644 --- a/src/widget/state.c +++ b/src/widget/state.c @@ -31,9 +31,6 @@ #include "../../include/widget.h" #include "../../include/signal.h" -#define W 1920 // TODO 2024-06-30 (Ad hoc pour mon écran) -#define H 960 -#define H_STYLES_PANE 30 #define UPPER_COMPARTMENT_PARTITION 600 #define LOWER_COMPARTMENT_PARTITION 1300 @@ -196,7 +193,7 @@ static GtkWidget *get_SPACE_VIEW_box() GtkBox *central_box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2)); // TODO - gtk_box_append (central_box, GTK_WIDGET (get_image_E_coli())); + gtk_box_append (central_box, GTK_WIDGET (widget_rec_image_E_coli())); // ui_setup_glarea (0, GTK_WIDGET (central_box)); gtk_box_append (central_box, GTK_WIDGET (gtk_separator_new (GTK_ORIENTATION_VERTICAL))); @@ -247,7 +244,7 @@ static GtkWidget *get_SEQUENCE_CONTROL_box() * - CONTRAST en haut permet de modifier un à un les contrastes des objets et des situations * afin de mieux mettre en évidence l'objet ou le phénomène d'intérêt */ -GtkWidget *get_STATE_page() +GtkWidget *widget_rec_STATE_page() { GtkBox *page_box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 2)); gtk_box_append (page_box, GTK_WIDGET (get_OBJECTS_and_SITUATIONS())); diff --git a/src/widget/stock.c b/src/widget/stock.c index 50c4383..5c2bed9 100644 --- a/src/widget/stock.c +++ b/src/widget/stock.c @@ -31,7 +31,7 @@ #include "../../include/signal.h" #include "../../include/widget.h" -GtkWidget *get_STOCK_page () { +GtkWidget *widget_rec_STOCK_page () { GtkBox *data_box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 32)); GtkWidget* frame_rule_effect = gtk_frame_new ("rule effect"); @@ -64,7 +64,7 @@ GtkWidget *get_STOCK_page () { return GTK_WIDGET (data_box); } -GtkWidget *get_STOCK_text (gchar *text_address) { +GtkWidget *widget_rec_STOCK_text (gchar *text_address) { GtkWidget *view = gtk_text_view_new (); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); gtk_text_buffer_set_text (buffer, read_file (text_address), -1); @@ -85,15 +85,15 @@ GtkWidget *get_STOCK_text (gchar *text_address) { /* T E X T S */ /******************************************************************************/ -gchar *get_text_address_THEORY () { +gchar *widget_rec_text_address_THEORY () { return "/home/jean/Gem-Graph/gem-graph-client/data/text/théorie.txt"; } -gchar *get_text_address_ABOUT_COMMANDS () { +gchar *widget_rec_text_address_ABOUT_COMMANDS () { return "/home/jean/Gem-Graph/gem-graph-client/data/text/about_commands.txt"; } -gchar *get_text_address_ANY () { +gchar *widget_rec_text_address_ANY () { return "/home/jean/Gem-Graph/gem-graph-client/data/text/any.txt"; } @@ -103,31 +103,31 @@ gchar *get_text_address_ANY () { /* I M A G E S */ /******************************************************************************/ -GtkWidget *get_image_E_coli(){ +GtkWidget *widget_rec_image_E_coli(){ GtkWidget *image = gtk_picture_new_for_filename ("/home/jean/Gem-Graph/gem-graph-client/data/image/E coli by D Goodsell.png"); return image; } -GtkWidget *get_image_GLUTAMATE(){ +GtkWidget *widget_rec_image_GLUTAMATE(){ GtkWidget *image = gtk_picture_new_for_filename ("/home/jean/Gem-Graph/gem-graph-client/data/image/glutamate.png"); return image; } -GtkWidget *get_image_GLUTAMINE(){ +GtkWidget *widget_rec_image_GLUTAMINE(){ GtkWidget *image = gtk_picture_new_for_filename ("/home/jean/Gem-Graph/gem-graph-client/data/image/glutamine.png"); return image; } -GtkWidget *get_image_ATP(){ +GtkWidget *widget_rec_image_ATP(){ GtkWidget *image = gtk_picture_new_for_filename ("/home/jean/Gem-Graph/gem-graph-client/data/image/ATP.png"); return image; } -GtkWidget *get_image_AMP(){ +GtkWidget *widget_rec_image_AMP(){ GtkWidget *image = gtk_picture_new_for_filename ("/home/jean/Gem-Graph/gem-graph-client/data/image/AMP.png"); return image; diff --git a/src/widget/topbar.c b/src/widget/topbar.c index c79c09b..243fd8a 100644 --- a/src/widget/topbar.c +++ b/src/widget/topbar.c @@ -32,7 +32,7 @@ #include "../../include/signal.h" #include "../../include/widget.h" -#define W_TEXT_WINDOW 700 +#define W_TEXT_WINDOW 700 // ad hoc (mais sans conséquences ici) #define H_TEXT_WINDOW 1000 @@ -43,17 +43,17 @@ static GtkWindow *main_window, *dialog_window, *text_window; static GtkButton *btt_STATE, *btt_RULES, *btt_DATA; -GtkWindow *widget_head_get_MAIN_WINDOW() { return main_window; } -GtkWindow *widget_head_get_DIALOG_WINDOW() { return dialog_window; } -GtkWindow *widget_head_get_TEXT_WINDOW() { return text_window; } +GtkWindow *widget_head_rec_MAIN_WINDOW() { return main_window; } +GtkWindow *widget_head_rec_DIALOG_WINDOW() { return dialog_window; } +GtkWindow *widget_head_rec_TEXT_WINDOW() { return text_window; } -void widget_head_set_MAIN_WINDOW (GtkApplication *app) +void widget_head_fix_MAIN_WINDOW (GtkApplication *app) { main_window = GTK_WINDOW (gtk_application_window_new (app)); } -void widget_head_set_DIALOG_WINDOW (GtkApplication *app) +void widget_head_fix_DIALOG_WINDOW (GtkApplication *app) { dialog_window = GTK_WINDOW (gtk_application_window_new (app)); } -void widget_head_set_TEXT_WINDOW (GtkApplication *app) +void widget_head_fix_TEXT_WINDOW (GtkApplication *app) { text_window = GTK_WINDOW (gtk_application_window_new (app)); } @@ -69,8 +69,8 @@ void widget_head_TEXT_WINDOW_design (GtkWindow *main_window, GtkWindow *text_win gtk_header_bar_set_title_widget (GTK_HEADER_BAR (header_bar), gtk_label_new (title)); gtk_window_set_titlebar (text_window, header_bar); - GtkWidget *child = get_STOCK_text (get_text_address_THEORY()); - child = get_STOCK_text (get_text_address_ABOUT_COMMANDS()); + GtkWidget *child = widget_rec_STOCK_text (widget_rec_text_address_THEORY()); + child = widget_rec_STOCK_text (widget_rec_text_address_ABOUT_COMMANDS()); gtk_window_set_child (GTK_WINDOW (text_window), GTK_WIDGET (child)); gtk_widget_set_size_request (GTK_WIDGET (child), W_TEXT_WINDOW, H_TEXT_WINDOW); diff --git a/src/widget/tree.c b/src/widget/tree.c index 8d7e9e1..5644807 100644 --- a/src/widget/tree.c +++ b/src/widget/tree.c @@ -31,10 +31,9 @@ #include "../../include/signal.h" #include "../../include/widget.h" -// GTK_ORIENTATION_VERTICAL GTK_ORIENTATION_HORIZONTAL - -void add_child_node (struct TreeNode_t *parent, struct TreeNode_t *child){ +void widget_add_child_node (struct TreeNode_t *parent, struct TreeNode_t *child) +{ if (parent->child) { struct TreeNode_t *cur = parent->child; while (cur && cur->next) {cur = cur->next;} @@ -42,14 +41,16 @@ void add_child_node (struct TreeNode_t *parent, struct TreeNode_t *child){ } else parent->child = child; } -struct TreeNode_t *create_user_tree_node (const gchar* text){ +struct TreeNode_t *widget_create_user_tree_node (const gchar* text) +{ struct TreeNode_t *node = g_malloc0 (sizeof(struct TreeNode_t)); node->text = g_strdup (text); node->child = NULL; // if (0) printf("create_user_tree_node %s\n", text); return node; } -static GListModel* get_user_tree_model_child (struct TreeNode_t *parent){ +static GListModel *get_user_tree_model_child (struct TreeNode_t *parent) +{ GtkStringList *list = NULL; if (parent) { if (0) printf("[get_user_tree_model_child] here is %s content : ", parent->text); @@ -60,12 +61,13 @@ static GListModel* get_user_tree_model_child (struct TreeNode_t *parent){ if (0) printf("%s ", child->text); child = child->next; } - } // else printf("hot.c GListModel* get_user_tree_model_child (struct TreeNode_t *parent) child = %d \n", parent); + } if (0) printf("\n"); return G_LIST_MODEL(list); } -static GListModel* get_user_tree_model (GObject *item, gpointer root){ +static GListModel *get_user_tree_model (GObject *item, gpointer root) +{ struct TreeNode_t *cur = (struct TreeNode_t *)root; struct TreeNode_t *parent = root; const gchar *string = gtk_string_object_get_string (GTK_STRING_OBJECT (item)); @@ -75,13 +77,15 @@ static GListModel* get_user_tree_model (GObject *item, gpointer root){ if (cur == NULL) {cur = parent->child; parent = cur;} } if (0) printf("[get_user_user_tree_model] looked for %s in %s item\n", cur->text, string); -// ! WARNING ! TODO CUR EST L'ENFANT, MAINTENANT DONC, SI CUR EST UNE FEUILLE, JE N'ATTEINDRAI PAS SON ENFANT +// ! WARNING ! TODO CUR EST L'ENFANT, MAINTENANT +// DONC, SI CUR EST UNE FEUILLE, JE N'ATTEINDRAI PAS SON ENFANT + return get_user_tree_model_child (cur); } -GtkScrolledWindow *get_user_rules_tree () +GtkScrolledWindow *widget_rec_user_rules_tree () { - struct TreeNode_t *tree_root = create_user_tree_node("root"); + struct TreeNode_t *tree_root = widget_create_user_tree_node("root"); labo_let_us_create_a_complex_useless_and_expensive_tree (tree_root); GtkStringList *model = gtk_string_list_new(NULL); @@ -114,4 +118,3 @@ GtkScrolledWindow *get_user_rules_tree () return scrolled_window; } -