gem-graph/gem-graph-client
gem-graph
/
gem-graph-client
3
0
Fork 0
Code Issues 14 Pull Requests Projects Releases Activity

Use parsed model to define dimension and space size of GLArea

This commit is contained in:
Adrien Bourmault 2024-01-11 22:27:52 +01:00
parent d50ce9afe1
commit 0da55ac88b
Signed by: neox
GPG Key ID: 2974E1D5F25DFCC8
10 changed files with 341 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/graphics.h
View File

@ -312,9 +312,8 @@ static inline void print_stack(int stack_id)
n++;
}
/*** TEST ***/
void main_test_graphics (const int stack_id);
void graphics_model_setup (const int stack_id);
/*
* Structure describing an arrow

3
include/parsing.h
View File

@ -28,5 +28,8 @@
#include "../include/base.h"
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);

2
include/ui.h
View File

@ -129,7 +129,7 @@ void on_openfile_response(GtkNativeDialog *native,
int response,
GemGraphClientWindow *self);
void on_openfile_response_complete(GObject *source_object,
void ui_model_loading(GObject *source_object,
GAsyncResult *result,
GemGraphClientWindow *self);

1
manifest.scm
View File

@ -18,6 +18,7 @@
"glu"
"glew"
"glfw"
"cglm"
"libepoxy"
"pango@1.90.0"
"xorgproto"

71
src/graphics/graphics.c
View File

@ -27,6 +27,7 @@
#include <time.h>
#include "../../include/base.h"
#include "../../include/ui.h"
#include "../../include/parsing.h"
#include "../../include/graphics.h"
#define TEST 0
@ -177,6 +178,11 @@ bool graphics_shutdown(const int id, void *error_buffer)
stack = &graphic_stack[id];
//XXX
free(stack->arrows_ptr);
stack->arrows_ptr = NULL;
stack->arrows_nb = 0;
glDeleteBuffers(1, &stack->position_buffer);
glDeleteBuffers(1, &stack->color_buffer);
glDeleteProgram(stack->program);
@ -220,7 +226,7 @@ bool graphics_shutdown(const int id, void *error_buffer)
* Attention, les vertex centraux de chaque unité d'espace (cube)
* peuvent être redondants (max 6)
*/
void main_test_graphics (const int stack_id)
void graphics_model_setup (const int stack_id)
{
/*------------------------------------------------------------------------*/
@ -229,19 +235,39 @@ void main_test_graphics (const int stack_id)
/*------------------------------------------------------------------------*/
struct graphic_stack_t *stack = &graphic_stack[stack_id];
srand(time(NULL)); int rand(void); void srand(unsigned int seed);
int randomize = 10, console = 0, space_X = 1, space_Y = 1, space_Z = 1;
stack->arrows_nb = 0;
char dimension = model_get_dim();
if (randomize) {
space_X = 1 + rand() % randomize;
space_Y = 1 + rand() % randomize;
space_Z = 1 + rand() % randomize;
g_print("[GRAPH DEBUG] dim = %d\n", dimension);
long space_X = 1;
long space_Y = 1;
long space_Z = 1;
switch(dimension) {
case 3:
space_Z = model_get_dim_value("z");
case 2:
space_Y = model_get_dim_value("y");
// even in 1D, we must be able to see a grid
if (!space_Y)
space_Y = 1;
case 1:
space_X = model_get_dim_value("x");
if (!space_X)
space_X = 1;
default:
break;
}
int density_max = space_X * space_Y * space_Z, specified_arrows_nb = density_max;
/* int max = fmax(space_X, space_Y); max = fmax(max, space_Z); */
g_print("[GRAPH DEBUG] x = %ld\n", space_X);
g_print("[GRAPH DEBUG] y = %ld\n", space_Y);
g_print("[GRAPH DEBUG] z = %ld\n", space_Z);
int density_max = space_X * space_Y * space_Z;
stack->arrows_nb = 0;
/*------------------------------------------------------------------------*/
@ -271,8 +297,7 @@ void main_test_graphics (const int stack_id)
/*------------------------------------------------------------------------*/
if (randomize) for (int i = 0; i < specified_arrows_nb; i++)
{
for (int i = 0; i < density_max; i++) {
stack->arrows_nb =
set_arrow (stack_id, stack->arrows_nb, space_X, space_Y, space_Z,
1, // load
@ -280,26 +305,6 @@ void main_test_graphics (const int stack_id)
rand() % space_X, // x
rand() % space_Y, // y
rand() % space_Z); // z
if (i > 0 && i % 1000 == 0) printf("|");
if (i > 0 && i % 100000 == 0) printf("\n");
}
else for (int i = 0; i < 6; i++)
stack->arrows_nb =
set_arrow (stack_id, stack->arrows_nb, 1, 1, 1, 1, i, 0, 0, 0);
int max_arrows_nb = stack->arrows_nb;
/*--------------------------------------------------------------------------------*/
/* F R E E */
/* ( F R E E 'S P A C E' : S E E G R A P H I C S H U T D O W N ) */
/*--------------------------------------------------------------------------------*/
free(stack->arrows_ptr);
stack->arrows_ptr = NULL;
stack->arrows_nb = 0;
}
}

2
src/graphics/init.c
View File

@ -40,7 +40,7 @@ void graphics_init_buffers(const int stack_id)
struct graphic_stack_t *stack = &graphic_stack[stack_id];
//XXX
main_test_graphics (stack_id);
graphics_model_setup(stack_id);
GLuint vao, vertex_buffer, color_buffer;

2
src/graphics/shaders/shader.vert
View File

@ -11,7 +11,7 @@ out vec4 color;
void main(void)
{
float zoom = 1.5f, chrominance = 1, luminance = 1;
float zoom = 1.1f, chrominance = 1, luminance = 1;
gl_Position =
projection_matrix * view_matrix * model_matrix * vec4(in_position, zoom);
color = vec4 (chrominance * in_color.rgb, luminance);

621
src/parsing/parsing.c
View File

@ -35,9 +35,13 @@
#include "../../include/base.h"
static xmlDocPtr model;
static xmlHashTablePtr model_hashtable;
bool model_init(char *content, size_t length, char *basename)
bool model_init(const char *content, size_t length, const char *basename)
{
xmlNode *node;
/*
* this initialize the library and check potential ABI mismatches
* between the version it was compiled for and the actual shared
@ -45,380 +49,343 @@ bool model_init(char *content, size_t length, char *basename)
*/
LIBXML_TEST_VERSION
xmlDocPtr doc;
model = xmlReadMemory(content, length, basename, NULL, 0);
doc = xmlReadMemory(content, length, basename, NULL, 0);
if (doc == NULL ) {
if (model == NULL ) {
return false;
}
g_free(basename);
g_free(content);
node = xmlDocGetRootElement(model);
if (node == NULL) {
g_printerr("Empty XML model !\n");
xmlFreeDoc(model);
return false;
}
if (xmlStrcmp(node->name, (xmlChar *) "gem-graph-model")) {
g_printerr("document of the wrong type, root node != gem-graph-model\n");
xmlFreeDoc(model);
return false;
}
model_hashtable = xmlHashCreate(0);
if (model_hashtable == NULL) {
g_printerr("Can't create model hash table !\n");
xmlFreeDoc(model);
return false;
}
return true;
}
/* node = xmlDocGetRootElement(doc); */
bool model_shutdown(void)
{
xmlFreeDoc(model);
xmlHashFree(model_hashtable, NULL);
/* if (node == NULL) { */
/* fprintf(stderr,"empty document\n"); */
/* xmlFreeDoc(doc); */
/* return false; */
/* } */
// Cleanup function for the XML library
xmlCleanupParser();
/* if (xmlStrcmp(node->name, (xmlChar *) "gem-graph-model")) { */
/* fprintf(stderr,"document of the wrong type, root node != gem-graph-model\n"); */
/* xmlFreeDoc(doc); */
/* return false; */
/* } */
// This is to debug memory for regression tests
xmlMemoryDump();
/* my_table = xmlHashCreate(10); */
/* xmlDocPtr my_tree = xmlReadIO, */
/* xmlInputReadCallback ioread, */
/* xmlInputCloseCallback ioclose, */
/* void * ioctx, */
/* const char * URL, */
/* const char * encoding, */
/* int options); */
return true;
}
/******************************************************************************/
/* bool model_shutdown(char *docname){ */
static xmlNodePtr getNextChild(xmlNodePtr node, xmlChar *last)
{
while (node != NULL && xmlStrcmp(node->name, last)) {
// printf(" <>--- line n°%lu <%s>\n", xmlGetLineNo(node), node->name);
node = node->next;
}
return node;
}
/* * Cleanup function for the XML library. */
/* */
/* xmlCleanupParser(); */
/* * this is to debug memory for regression tests */
/* */
/* xmlMemoryDump(); */
static xmlChar* splitStrAtSlash(xmlChar *toSplit)
{
toSplit = (xmlChar *)xmlStrchr(toSplit, '/');
toSplit = xmlStrsub (toSplit, 1, xmlStrlen(toSplit));
return toSplit;
}
/* return true; */
/* } */
static xmlChar* getFirstTag(xmlChar *path)
{
xmlChar *preop = path;
path = (xmlChar *)xmlStrchr(path, '/');
path = xmlStrsub (path, 1, xmlStrlen(path));
/******************************************************************************/
printf("%s = %s + / + %s\n", preop,\
xmlStrsub (preop, 0, xmlStrlen(preop) - xmlStrlen(path) - 1), path);
/* static xmlNodePtr getNextChild(xmlNodePtr node, xmlChar *last){ */
/* while (node != NULL && xmlStrcmp(node->name, last)) { */
/* // printf(" <>--- line n°%lu <%s>\n", xmlGetLineNo(node), node->name); */
/* node = node->next; */
/* } */
/* return node; */
/* } */
return xmlStrsub (preop, 0, xmlStrlen(preop) - xmlStrlen(path) - 1);
}
/* static xmlChar* splitStrAtSlash(xmlChar *toSplit){ */
/* toSplit = (xmlChar *)xmlStrchr(toSplit, '/'); */
/* toSplit = xmlStrsub (toSplit, 1, xmlStrlen(toSplit)); */
/* return toSplit; */
/* } */
static xmlChar* getLastTag(xmlChar *path)
{
while ((ulong)xmlStrchr (path, '/')) path = splitStrAtSlash((xmlChar *)path);
/* static xmlChar* getFirstTag(xmlChar *path){ */
/* xmlChar *preop = path; */
/* path = (xmlChar *)xmlStrchr(path, '/'); */
/* path = xmlStrsub (path, 1, xmlStrlen(path)); */
/* printf("%s = %s + / + %s\n", preop,\ */
/* xmlStrsub (preop, 0, xmlStrlen(preop) - xmlStrlen(path) - 1), path); */
/* return xmlStrsub (preop, 0, xmlStrlen(preop) - xmlStrlen(path) - 1); */
/* } */
/* static xmlChar* getLastTag(xmlChar *path){ */
/* while ((ulong)xmlStrchr (path, '/')) path = splitStrAtSlash((xmlChar *)path); */
/* // printf("last tag in the path = <%s>\n", path); */
/* return path; // which is no more the given path but only its last tag ! */
/* } */
// printf("last tag in the path = <%s>\n", path);
return path; // which is no more the given path but only its last tag !
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/* static xmlNodePtr model_get_node(xmlChar *path) */
static xmlNodePtr model_get_node(xmlChar *path)
{
xmlNodePtr node;
xmlChar *extrait;
xmlChar *reste, *last, *affich;
// Lookup for node from path in hash table
node = xmlHashLookup(model_hashtable, path);
// Found a node in hash table
if (node) {
return node;
// no node found in hash table
} else {
reste = path;
affich = reste;
last = getLastTag(reste);
node = xmlDocGetRootElement(model);
while (xmlStrchr (reste, '/')) {
extrait = getFirstTag(reste);
reste = splitStrAtSlash((xmlChar *)reste);
node = node->xmlChildrenNode;
node = getNextChild(node, extrait);
}
if(node && xmlStrcmp(node->name, last)) {
node = node->xmlChildrenNode;
while (node && xmlStrcmp(node->name, last)) {
node = node->next;
}
xmlHashAddEntry (model_hashtable, path, node);
}
return node;
}
return NULL;
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
static long model_get_node_attrib(xmlNodePtr node)
{
long value = 0;
if (node && node->properties) {
xmlAttr* attribute = node->properties;
xmlChar* value_txt = NULL;
char *ptr;
while(attribute && attribute->name && attribute->children) {
value_txt = xmlNodeListGetString(node->doc, attribute->children, 1);
value = strtol((char *)value_txt, &ptr, 10);
printf ("model_get_node_attrib <%s> = %s = %ld\n",\
attribute->name, value_txt, value);
attribute = attribute->next;
}
}
return value;
}
static long model_get_state_arrows_nb(xmlNodePtr node)
{
long arrows_nb= 0;
printf ("VRB0 model_get_state_arrows_nb <%s> start at line %ld\n",
node->name, xmlGetLineNo(node));
while (node && node->next) {
printf ("%s %ld >", (xmlChar *)node->name, arrows_nb);
if (!xmlStrcmp(node->name, (xmlChar *)"arrow")) ++arrows_nb;
printf (" %ld ", arrows_nb);
node = node->next;
}
printf ("\n");
printf ("VRB0 model_get_state_arrows_nb = %ld end at line %ld\n",
arrows_nb, xmlGetLineNo(node));
return arrows_nb;
}
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
char model_get_dim(void)
{
xmlAttr *attribute;
xmlChar* value;
xmlNodePtr node = model_get_node(
(xmlChar *)"parameters/space-param/dimension");
if (xmlHasProp (node, (xmlChar *) "z")) return 3;
if (xmlHasProp (node, (xmlChar *) "y")) return 2;
if (xmlHasProp (node, (xmlChar *) "x")) return 1;
return 0;
}
long model_get_dim_value(const char *axis)
{
xmlAttr *attribute;
xmlChar *value;
long ret_value;
xmlNodePtr node = model_get_node(
(xmlChar *)"parameters/space-param/dimension");
if (node && node->properties) {
attribute = node->properties;
while(attribute && attribute->name && attribute->children) {
if (!xmlStrcmp(attribute->name, (const xmlChar *)axis)) {
value = xmlNodeListGetString(node->doc, attribute->children, 1);
ret_value = strtol((char *)value, NULL, 0);
xmlFree(value);
return ret_value;
}
attribute = attribute->next;
}
}
return 0;
}
char model_get_cond_tree (xmlChar *path)
{
xmlNodePtr node = model_get_node(path);
node = node->xmlChildrenNode;
node = getNextChild(node, (xmlChar *)"condition");
node = xmlCopyNodeList (node->xmlChildrenNode);
printf("model_get_cond_tree(\"%s\") > line n°%ld\n", path, xmlGetLineNo(node));
return 0;
}
int model_get_cond (xmlChar *path, xmlChar *node_id)
{
xmlNodePtr node = model_get_node(path);
printf("model_get_cond(...) {...node->name = %s...}\n", node->name);
node = getNextChild(node->next, (xmlChar *)"condition");
node = getNextChild(node->next, (xmlChar *)"condition");
if (xmlHasProp (node, (xmlChar *) "site")) {
printf(" node %s has attribute site\n", node->name);
}
if (xmlHasProp (node, (xmlChar *) "node_id")) {
printf(" node %s has attribute %s with value %hhn %s %s\n",
node->name,
xmlHasProp (node, (xmlChar *) "node_id")->name,
xmlGetProp (node, (xmlChar *) "node_id"),
(xmlChar *)"?! xmlGetProp is deprecated !",
(xmlChar *)"");
}
node = getNextChild(node->next, (xmlChar *)"condition");
return 0;
}
int model_get_multiplicity (xmlChar *path)
{
xmlNodePtr node = model_get_node(path);
if (node)
return (int)strtol((char *)xmlNodeGetContent(node), NULL, 0);
return 0;
}
int model_get_objects_list(xmlChar *path)
{
return xmlGetLineNo(model_get_node(path));
}
xmlChar *model_get_states_list(xmlChar *path)
{
xmlNodePtr node = model_get_node(path);
return (xmlChar *)xmlNodeGetContent(node);
}
/* long model_get_state_arrows_count(xmlChar *path, long n) */
/* { */
/* xmlNodePtr node; */
/* // Ici, je sais que c'est le 'PREMIER' état qui est demandé car n == 0 */
/* char compl[] = "/state/arrow"; */
/* char *new_p = calloc(1, (sizeof(compl) + strlen((char *)path)) * sizeof(char)); */
/* strcat(new_p, (char *)path); */
/* strcat(new_p + strlen((char *)path), compl); // printf("%s\n", new_p); */
/* // Lookup for node from path in hash table */
/* node = xmlHashLookup(my_table, path); */
/* // Found a node in hash table */
/* if(node){ */
/* if (VRB0) printf("xmlHashLookup (my_table, path: <%s>, tag: <%s> @>%p)\n", */
/* path, node->name, node); */
/* assert(node > (xmlNodePtr)2048); */
/* return node; */
/* // no node found in hash table */
/* } else { */
/* xmlChar *reste = path, *last = reste, *affich = reste; */
/* last = getLastTag(last); */
/* xmlNodePtr node = xmlDocGetRootElement(doc); */
/* if (VRB1) printf("line n° %lu : tag <%s> reste = %s\n",\ */
/* xmlGetLineNo(node), (xmlChar *)node->name, (xmlChar *)affich); */
/* xmlChar *extrait; */
/* while ((ulong)xmlStrchr (reste, '/')){ */
/* extrait = getFirstTag(reste); //printf("extrait = %s\n", extrait); */
/* reste = splitStrAtSlash((xmlChar *)reste);//printf("reste = %s\n", reste); */
/* node = node->xmlChildrenNode; */
/* node = getNextChild(node, extrait); */
/* if (VRB1) printf("line n°%lu : tag <%s> reste = %s\n",\ */
/* xmlGetLineNo(node), (xmlChar *)extrait, (xmlChar *)reste); */
/* } */
/* if(node != NULL && xmlStrcmp(node->name, last)) { */
/* node = node->xmlChildrenNode; */
/* while (node != NULL && xmlStrcmp(node->name, last)) { */
/* node = node->next; */
/* } */
/* if (VRB1) printf("line n°%lu : tag <%s>\n",\ */
/* xmlGetLineNo(node), (xmlChar *)node->name); */
/* xmlHashAddEntry (my_table, path, node); */
/* } */
/* if (VRB0) printf("VRB0 xmlHashAddEntry (my_table, path: <%s>, tag: <%s> @>%p)\n",\ */
/* path, node->name, node); */
/* return node; */
/* } */
/* return NULL; // ? */
/* } */
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/* static long model_get_node_attrib(xmlNodePtr node) */
/* { */
/* long value = 0; */
/* if (node && node->properties) { */
/* xmlAttr* attribute = node->properties; */
/* xmlChar* value_txt = NULL; */
/* char *ptr; */
/* while(attribute && attribute->name && attribute->children) */
/* { */
/* value_txt = xmlNodeListGetString(node->doc, attribute->children, 1); */
/* value = strtol((char *)value_txt, &ptr, 10); */
/* if (VRB3) printf ("model_get_node_attrib <%s> = %s = %ld\n",\ */
/* attribute->name, value_txt, value); */
/* attribute = attribute->next; */
/* } */
/* } */
/* return value; */
/* } */
/* static long model_get_state_arrows_nb(xmlNodePtr node) */
/* { */
/* long arrows_nb= 0; */
/* if (VRB0) printf ("VRB0 model_get_state_arrows_nb <%s> start at line %ld\n",\ */
/* node->name, xmlGetLineNo(node)); */
/* while (node && node->next){ */
/* if (VRB2) printf ("%s %ld >", (xmlChar *)node->name, arrows_nb); */
/* if (!xmlStrcmp(node->name, (xmlChar *)"arrow")) ++arrows_nb; */
/* if (VRB2) printf (" %ld ", arrows_nb); */
/* node = node->next; */
/* } */
/* if (VRB2) printf ("\n"); */
/* if (VRB0) printf ("VRB0 model_get_state_arrows_nb = %ld end at line %ld\n",\ */
/* arrows_nb, xmlGetLineNo(node)); */
/* return arrows_nb; */
/* } */
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/* char model_get_dim(xmlChar *path){ */
/* xmlNodePtr node = model_get_node(path); if (VRB2) printf("@node = %p ", node); */
/* if (node && node->properties) { */
/* xmlAttr* attribute = node->properties; */
/* while(attribute && attribute->name && attribute->children) */
/* { */
/* xmlChar* value = xmlNodeListGetString(node->doc, attribute->children, 1); */
/* // printf ("model_get_dim %s = %s\n", attribute->name, value); */
/* xmlFree(value); */
/* attribute = attribute->next; */
/* } */
/* } */
/* if (xmlHasProp (node, (xmlChar *) "z")) return 3; */
/* if (xmlHasProp (node, (xmlChar *) "y")) return 2; */
/* if (xmlHasProp (node, (xmlChar *) "x")) return 1; */
/* return 0; */
/* } */
/* int model_get_dim_value(xmlChar *path, xmlChar *axis){ */
/* xmlNodePtr node = model_get_node(path); */
/* //xmlNodePtr node= xmlTextReadernoderentNode(reader); */
/* if (node && node->properties) { */
/* xmlAttr* attribute = node->properties; */
/* while(attribute && attribute->name && attribute->children) */
/* { */
/* xmlChar* value = xmlNodeListGetString(node->doc, attribute->children, 1); */
/* if (!xmlStrcmp(attribute->name, axis)) */
/* return (int)strtol((char *)value, NULL, 0); */
/* } */
/* } */
/* return 0; */
/* } */
/* char model_get_cond_tree (xmlChar *path){ */
/* xmlNodePtr node = model_get_node(path); */
/* node = node->xmlChildrenNode; */
/* node = getNextChild(node, (xmlChar *)"condition"); */
/* node = xmlCopyNodeList (node->xmlChildrenNode); */
/* printf("model_get_cond_tree(\"%s\") > line n°%ld\n", path, xmlGetLineNo(node)); */
/* return 0; */
/* } */
/* int model_get_cond (xmlChar *path, xmlChar *node_id){ */
/* xmlNodePtr node = model_get_node(path); */
/* printf("model_get_cond(...) {...node->name = %s...}\n", node->name); */
/* node = getNextChild(node->next, (xmlChar *)"condition"); */
/* node = getNextChild(node->next, (xmlChar *)"condition"); */
/* if (xmlHasProp (node, (xmlChar *) "site")) { */
/* printf(" node %s has attribute site\n", node->name); */
/* } */
/* if (xmlHasProp (node, (xmlChar *) "node_id")) { */
/* printf(" node %s has attribute %s with value %hhn %s %s\n",\ */
/* node->name,\ */
/* xmlHasProp (node, (xmlChar *) "node_id")->name,\ */
/* xmlGetProp (node, (xmlChar *) "node_id"),\ */
/* (xmlChar *)"?! xmlGetProp is deprecated !",\ */
/* (xmlChar *)""); */
/* } */
/* node = getNextChild(node->next, (xmlChar *)"condition"); */
/* return 0; */
/* } */
/* long model_get_dim_X (xmlChar *path){ */
/* xmlNodePtr node = xmlHashLookup(my_table, (xmlChar *)"get_X"); */
/* if(node){ */
/* //if (VRB1){ */
/* printf("get_X > tag <%s> found in hash table\n",\ */
/* node->name); // node->name = "x" */
/* //} */
/* return (long)xmlHashLookup(my_table, (xmlChar *)"get_X"); //TODO */
/* }else{ */
/* xmlNodePtr node = model_get_node(path); // node = dimension */
/* if (node && node->properties) { */
/* xmlAttr* attribute = node->properties; */
/* while(attribute && attribute->name && attribute->children) */
/* { */
/* xmlChar* value = xmlNodeListGetString(node->doc, attribute->children, 1); */
/* if (!xmlStrcmp(attribute->name, (xmlChar *)"x")) { */
/* xmlHashAddEntry (my_table, (xmlChar *)"get_X", attribute); */
/* return (int)strtol((char *)value, NULL, 0); */
/* } */
/* } */
/* } */
/* } */
/* return 0; */
/* } */
/* int model_get_dim_Y (xmlChar *path){ */
/* printf("model_get_dim_Y(%s)\n", path); */
/* return 0; */
/* } */
/* int model_get_dim_Z (xmlChar *path){ */
/* printf("model_get_dim_Z(%s)\n", path); */
/* return 0; */
/* } */
/* int model_get_multiplicity (xmlChar *path){ */
/* xmlNodePtr node = model_get_node(path); */
/* if(node) return (int)strtol((char *)xmlNodeGetContent(node), NULL, 0); */
/* return 0; */
/* } */
/* int model_get_objects_list(xmlChar *path){ */
/* return xmlGetLineNo(model_get_node(path)); */
/* } */
/* xmlChar *model_get_states_list(xmlChar *path){ */
/* xmlNodePtr node = model_get_node(path); */
/* return (xmlChar *)xmlNodeGetContent(node); */
/* } */
/* long model_get_state_arrows_count(xmlChar *path, long n){ */
/* // Ici, je sais que c'est le 'PREMIER' état qui est demandé car n == 0 */
/* char compl[] = "/state/arrow"; */
/* char *new_p = calloc(1, (sizeof(compl) + strlen((char *)path)) * sizeof(char)); */
/* strcat(new_p, (char *)path); */
/* strcat(new_p + strlen((char *)path), compl); // printf("%s\n", new_p); */
/* xmlNodePtr node = model_get_node((xmlChar *)new_p); */
/* long size = model_get_state_arrows_nb(node); */
/* int dim = model_get_dim((xmlChar *)"parameters/space-param/dimension"); */
/* if (VRB0) printf("VRB0 model_get_saved_state(size = %ld)->%p<-attrib dim = %d size = %ld\n",\ */
/* xmlNodePtr node = model_get_node((xmlChar *)new_p); */
/* long size = model_get_state_arrows_nb(node); */
/* int dim = model_get_dim((xmlChar *)"parameters/space-param/dimension"); */
/* printf("VRB0 model_get_saved_state(size = %ld)->%p<-attrib dim = %d size = %ld\n",\ */
/* size, (xmlNodePtr)model_get_node_attrib(node), dim, size * ( 2 + dim ) * sizeof(int)); */
/* int c = 0; */
/* int *t = calloc(1, (size * ( 2 + dim ) * sizeof(int))); */
/* // int rk = 0; */
/* // int *s = calloc(1, ( 2 + dim ) * sizeof(int)); */
/* int c = 0; */
/* int *t = calloc(1, (size * ( 2 + dim ) * sizeof(int))); */
/* // int rk = 0; */
/* // int *s = calloc(1, ( 2 + dim ) * sizeof(int)); */
/* if(1) */
/* { */
/* long arrows_nb= 0; */
/* if (VRB4) printf ("VRB4 model_get_state_arrows_nb <%s> start at line %ld\n",\ */
/* if(1) */
/* { */
/* long arrows_nb= 0; */
/* printf ("VRB4 model_get_state_arrows_nb <%s> start at line %ld\n",\ */
/* node->name, xmlGetLineNo(node)); */
/* while (node && node->next){ */
/* while (node && node->next){ */
/* if (!xmlStrcmp(node->name, (xmlChar *)"arrow")) ++arrows_nb; */
/* if (VRB4 && !xmlStrcmp(node->name, (xmlChar *)"arrow")) printf ("VRB4 %s-%ld ",\ */
/* if (!xmlStrcmp(node->name, (xmlChar *)"arrow")) printf ("VRB4 %s-%ld ",\ */
/* (xmlChar *)node->name, arrows_nb); */
/* if (node && node->properties) { */
/* xmlAttr* attribute = node->properties; */
/* while(attribute) */
/* { */
/* xmlChar* value = xmlNodeListGetString(node->doc, attribute->children, 1); */
/* if (VRB4) printf("v=%s ", value); */
/* printf("v=%s ", value); */
/* *(t + c) = strtol((char*)value, NULL, 0); */
/* ++c; */
/* xmlFree(value); */
/* xmlFree(value); */
/* attribute = attribute->next; */
/* } */
/* if (VRB4) printf("\n"); */
/* printf("\n"); */
/* } */
/* node = node->next; */
/* } */
/* if (VRB4) printf ("VRB4 model_get_state_arrows_nb = %ld end at line %ld\n",\ */
/* } */
/* printf ("VRB4 model_get_state_arrows_nb = %ld end at line %ld\n",\ */
/* arrows_nb, xmlGetLineNo(node)); */
/* if (VRB4) for(int k = 0; k < c; k++) printf("%d ", *(t + k)); printf("\n"); */
/* return arrows_nb; */
/* for(int k = 0; k < c; k++) printf("%d ", *(t + k)); printf("\n"); */
/* return arrows_nb; */
/* } */
/* return (long) size * ( 2 + dim ) * sizeof(int); */
/* } */
int model_get_state(xmlChar *path, xmlChar *state_id)
{
printf("model_get_state (%s -> %s state)\n", path, state_id);
return 0;
}
/* return (long) size * ( 2 + dim ) * sizeof(int); */
/* } */
int model_get_conditions_list(xmlChar *path)
{
printf("model_get_conditions_list(%s)\n", path);
return 0;
}
/* int model_get_state(xmlChar *path, xmlChar *state_id){ */
/* printf("model_get_state (%s -> %s state)\n", path, state_id); */
/* return 0; */
/* } */
/* int model_get_conditions_list(xmlChar *path){ */
/* printf("model_get_conditions_list(%s)\n", path); */
/* return 0; */
/* } */
/* int model_get_transitions_list(xmlChar *path){ */
/* printf("model_get_transitions_list(%s)\n", path); */
/* return 0; */
/* } */
int model_get_transitions_list(xmlChar *path)
{
printf("model_get_transitions_list(%s)\n", path);
return 0;
}

22
src/ui/events.c
View File

@ -157,6 +157,8 @@ void on_closefile_action(GSimpleAction *action,
g_assert(GEM_GRAPH_CLIENT_IS_APPLICATION(self));
model_shutdown();
ui_disable_action("closefile");
ui_disable_action("savefile");
ui_disable_action("runmode");
@ -306,16 +308,16 @@ void on_openfile_response(GtkNativeDialog *native,
// Load asynchroneously not to block control flow
g_file_load_contents_async (file,
NULL,
(GAsyncReadyCallback)on_openfile_response_complete,
(GAsyncReadyCallback)ui_model_loading,
self);
}
g_object_unref(native);
}
void on_openfile_response_complete(GObject *source_object,
GAsyncResult *result,
GemGraphClientWindow *self)
void ui_model_loading(GObject *source_object,
GAsyncResult *result,
GemGraphClientWindow *self)
{
GFile *file = G_FILE(source_object);
@ -335,18 +337,21 @@ void on_openfile_response_complete(GObject *source_object,
&error);
// In case of error, print a warning to the standard error output
if (error != NULL)
{
g_printerr("Unable to open “%s”: %s\n",
if (error != NULL) {
g_printerr("Unable to open “%s”: %s\n",
g_file_peek_path(file),
error->message);
ui_send_internal_notification("Unable to open file !");
g_free(error);
g_free(basename);
g_free(content);
return;
}
if (model_init(content, length, basename) == false) {
ui_send_internal_notification("Error while loading the model");
g_free(basename);
g_free(content);
return;
}
@ -357,5 +362,8 @@ void on_openfile_response_complete(GObject *source_object,
ui_enable_action("presentmode");
ui_enable_action("togglesidebar");
ui_set_stack(RUN_MODE);
g_free(basename);
g_free(content);
}

8
src/ui/graphics.c
View File

@ -281,12 +281,12 @@ bool ui_setup_glarea(int target_mode, GtkWidget *target_widget)
gl_area = GTK_WIDGET(gtk_gl_area_new());
assert(gl_area);
//gtk_widget_set_size_request(gl_area, 1000, 1000);
gtk_gl_area_set_auto_render(GTK_GL_AREA(gl_area), true);
gtk_widget_set_hexpand(gl_area, TRUE);
gtk_widget_set_vexpand(gl_area, TRUE);
gtk_widget_set_halign(gl_area, GTK_ALIGN_CENTER);
gtk_widget_set_valign(gl_area, GTK_ALIGN_CENTER);
gtk_widget_set_size_request(gl_area, 500, 500);
gtk_gl_area_set_auto_render(GTK_GL_AREA(gl_area), true);
//gtk_widget_set_halign(gl_area, GTK_ALIGN_CENTER);
//gtk_widget_set_valign(gl_area, GTK_ALIGN_CENTER);
// The main "draw" call for GtkGLArea
g_signal_connect(GTK_GL_AREA(gl_area),