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; }