struct s_chart *f_chart_new(struct s_chart *supplied) {
struct s_chart *result = supplied;
if (!result)
if (!(result = (struct s_chart *) d_calloc(sizeof(struct s_chart), 1)))
d_die(d_error_malloc);
if (result->plane)
gtk_widget_destroy(result->plane);
if ((result->plane = gtk_drawing_area_new()))
g_signal_connect(G_OBJECT(result->plane), "expose-event", G_CALLBACK(p_chart_callback), result);
else
d_die(d_error_malloc);
return result;
}
struct s_attributes *p_object_attributes_malloc(size_t size, const char *type) {
struct s_attributes *result;
if ((result = (struct s_attributes *) d_malloc(size)))
result->type = type;
else
d_die(d_error_malloc);
return result;
}
struct s_object *p_object_malloc(const char *file, int line, const char *type, int flags) {
struct s_object *result;
if ((result = d_malloc_explicit(sizeof(struct s_object), file, line)))
p_object_prepare(result, file, line, type, (flags | e_flag_allocated));
else
d_die(d_error_malloc);
return result;
}
d_define_method(emitter, record)(struct s_object *self, const char *id) {
d_using(emitter);
struct s_signal *signal;
if ((signal = (struct s_signal *) d_malloc(sizeof(struct s_signal)))) {
strncpy(signal->id, id, (d_emitter_name_size-1));
f_list_append(&(emitter_attributes->signals), (struct s_list_node *)signal, e_list_insert_head);
} else
d_die(d_error_malloc);
return (void *)signal;
}
struct s_attributes *p_object_setup(struct s_object *object, struct s_method *virtual_table, struct s_attributes *attributes) {
struct s_virtual_table *node;
if ((node = (struct s_virtual_table *) d_malloc(sizeof(struct s_virtual_table)))) {
node->virtual_table = virtual_table;
node->type = attributes->type;
f_list_append(&(object->virtual_tables), (struct s_list_node *)node, e_list_insert_head);
f_list_append(&(object->attributes), (struct s_list_node *)attributes, e_list_insert_head);
} else
d_die(d_error_malloc);
return attributes;
}
d_define_method(container, add_drawable)(struct s_object *self, struct s_object *drawable, double position_x, double position_y) {
d_using(container);
struct s_container_drawable *current_container;
if ((current_container = (struct s_container_drawable *)d_malloc(sizeof(struct s_container_drawable)))) {
current_container->drawable = d_retain(drawable);
current_container->position_x = position_x;
current_container->position_y = position_y;
f_list_append(&(container_attributes->entries), (struct s_list_node *)current_container, e_list_insert_tail);
} else
d_die(d_error_malloc);
return self;
}
d_define_method(label, set_content_char)(struct s_object *self, char *string_content, TTF_Font *font, struct s_object *environment) {
d_using(label);
size_t string_length = f_string_strlen(string_content);
if (string_length > 0) {
if (label_attributes->string_content) {
/* realloc only if really needed */
if (label_attributes->size < (string_length+1)) {
if ((label_attributes->string_content = (char *)d_realloc(label_attributes->string_content, (string_length+1))))
label_attributes->size = (string_length+1);
else
d_die(d_error_malloc);
}
} else if ((label_attributes->string_content = (char *)d_malloc(string_length+1)))
label_attributes->size = (string_length+1);
else
d_die(d_error_malloc);
strncpy(label_attributes->string_content, string_content, string_length);
label_attributes->string_content[string_length] = '\0';
} else if (label_attributes->string_content)
memset(label_attributes->string_content, '\0', label_attributes->size);
p_label_update_texture(self, font, environment);
return self;
}
void *p_malloc(size_t dimension, const char *file, unsigned int line) {
struct s_memory_tail *tail;
struct s_memory_head *head;
size_t total_dimension = sizeof(struct s_memory_head) + dimension + sizeof(struct s_memory_tail);
void *pointer;
if ((pointer = (struct s_memory_head *)calloc(1, total_dimension))) {
head = (struct s_memory_head *)pointer;
tail = (struct s_memory_tail *)(pointer + sizeof(struct s_memory_head) + dimension);
pointer = (void *)(pointer + sizeof(struct s_memory_head));
head->next = v_memory_root;
if (v_memory_root)
v_memory_root->back = head;
v_memory_root = head;
head->dimension = dimension;
head->checksum = (unsigned int)d_memory_checksum;
tail->checksum = (unsigned int)d_memory_checksum;
tail->line = line;
tail->file = file;
} else
d_die(d_error_malloc);
return pointer;
}
struct s_interface *f_interface_initialize(struct s_interface *supplied, const char *builder_path) {
struct s_interface *result = supplied;
int index;
if (!result)
if (!(result = (struct s_interface *)d_malloc(sizeof(struct s_interface))))
d_die(d_error_malloc);
result->destroy = d_false;
if ((result->interface = gtk_builder_new()))
if ((gtk_builder_add_from_file(result->interface, builder_path, NULL))) {
d_assert(result->window = GTK_WINDOW(gtk_builder_get_object(result->interface, "v_window")));
for (index = 0; index < e_interface_chart_NULL; ++index) {
d_assert(f_chart_new(&(result->logic_charts[index])));
d_assert(f_chart_hook_interface(&(result->logic_charts[index]), "../components/UI/UI_scale_config.glade"));
f_chart_style(&(result->logic_charts[index]), "styles/base_graph.keys");
f_chart_style(&(result->logic_charts[index]), v_interface_chart_styles[index]);
d_assert(result->charts[index] = GTK_ALIGNMENT(gtk_builder_get_object(result->interface, v_interface_charts[index])));
gtk_container_add(GTK_CONTAINER(result->charts[index]), g_object_ref(result->logic_charts[index].plane));
}
for (index = 0; index < e_interface_label_NULL; ++index)
d_assert(result->labels[index] = GTK_LABEL(gtk_builder_get_object(result->interface, v_interface_labels[index])));
}
return result;
}
