/ - Diff - LCOM1920-T5G03 - FEUP Project Manager

proj/include/proj_func.h
49	49	typedef struct timer {
50	50	int time;
51	51	text_t *text;
52		char *array;
53	52	} text_timer_t;
54	53
55	54	text_timer_t* (timer_ctor)(const font_t *fnt);

     #define FONT_H_INCLUDED
     struct font;
     /**
      * @brief Font. Represents a set of glyphs that can be drawn for showing text.
      */
     typedef struct font font_t;
     /**
      * @brief Construct font.
+     *
      * The font is constructed from a provided path. That path is required to
      * contain glyphs with the name "ascii???.xpm2", files with format XPM2 where
      * instead of having "???" we have 3-digit ASCII codes, where the glyph with
      * that name map to that XPM2 file.
      * @param   s   Path to directory
      * @return      Pointer to font
      */
     font_t* (font_ctor)(const char *s);
     int     (font_dtor)(font_t *p);
     /**
      * @brief Destruct font.
      * @param   p   Pointer to font to be destroyed
      */
     void    (font_dtor)(font_t *p);
     /**
      * @brief Initialize font stuff.
+     *
      * More specifically, this involves loading the default font, which is currently consolas.
      * @return  SUCCESS if initialization was successful, false otherwise
      */
     int (font_init)(void);
     /**
      * @brief Get default font.
+     *
      * Currently, the default font is Consolas.
      * @return  Pointer to default font
      */
     const font_t* font_get_default(void);
     /**
      * @brief Get Consolas font.
      * @return Pointer to Consolas font
      */
     const font_t* font_get_consolas(void);
     int (font_free)(void);
     /**
      * @brief Free resources used on initialization of fonts.
      */
     void (font_free)(void);
     /**
      * @brief Enumeration of vertical alignment schemes.
      */
     typedef enum{
         text_valign_top    = -1,
         text_valign_center =  0,
         text_valign_bottom =  1
     } text_valign;
     /**
      * @brief Enumeration of horizontal alignment schemes.
      */
     typedef enum{
         text_halign_left   = -1,
         text_halign_center =  0,
-...
     } text_halign;
     struct text;
     /**
      * @brief Drawable text.
      */
     typedef struct text text_t;
     /**
      * @brief Construct text.
      * @param   fnt Font to draw the text
      * @param   txt String to be drawn
      * @return      Pointer to constructed text
      */
     text_t* (text_ctor)(const font_t *fnt, const char *txt);
     /**
      * @brief Destruct text.
      * @param   p   Pointer to text to be destroyed
      */
     void    (text_dtor)(text_t *p);
     char* (text_get_string)(const text_t *p);
     /**
      * @brief Set text string.
      * @param   p   Pointer to text
      * @param   txt String to be set
      */
     void (text_set_string)(text_t *p, const char *txt);
     /**
      * @brief Set text position.
      * @param   p   Pointer to text
      * @param   x   X-position of the text
      * @param   y   Y-position of the text
      */
     void (text_set_pos)   (text_t *p, int16_t x, int16_t y);
     /**
      * @brief Set text size (letter size).
      * @param   p       Pointer to text
      * @param   size    Letter size of the text
      */
     void (text_set_size)  (text_t *p, unsigned size);
     /**
      * @brief Set text color.
      * @param   p       Pointer to text
      * @param   color   Text color
      */
     void (text_set_color) (text_t *p, uint32_t color);
     /**
      * @brief Set text vertical alignment.
      * @param   p       Pointer to text
      * @param   valign  Vertical alignment of the text
      */
     void (text_set_valign)(text_t *p, text_valign valign);
     /**
      * @brief Set text horizontal alignment.
      * @param   p       Pointer to text
      * @param   halign  Horizontal alignment of the text
      */
     void (text_set_halign)(text_t *p, text_halign halign);
     /**
      * @brief Get string of the text.
      * @param   p       Pointer to text
      * @return  Pointer to string
      */
     const char* (text_get_string)(const text_t *p);
     /**
      * @brief Get text x-position.
      * @param   p   Pointer to text
      * @return      X-position of text
      */
     int16_t (text_get_x)  (const text_t *p);
     /**
      * @brief Get text y-position.
      * @param   p   Pointer to text
      * @return      Y-position of text
      */
     int16_t (text_get_y)  (const text_t *p);
     /**
      * @brief Draw text on the screen buffer.
      * @param   p   Pointer to text
      * @return      SUCCESS if operation was successful, false otherwise
      */
     int     (text_draw)   (const text_t *p);
     #endif //FONT_H_INCLUDED

     #include "errors.h"
     #include <assert.h>
     /// GLYPH
     /**
      * @brief Text glyph. Represents a letter that can be drawn.
      */
     typedef struct {
         uint16_t w, h;
         uint8_t *map;
     } glyph_t;
     /**
      * @brief Construct glyph.
      * @param   xpm XPM describing the glyph
      * @return      Pointer to created glyph
      */
     static glyph_t* (glyph_ctor)(const char **xpm){
         if(xpm == NULL) return NULL;
         glyph_t *ret = malloc(sizeof(glyph_t));
-...
+        }
         return ret;
+    }
     /**
      * @brief Destruct glyph.
      * @param   p   Pointer to glyph to be destroyed
      */
     static void (glyph_dtor)(glyph_t *p){
         if(p == NULL) return;
         free(p->map);
         free(p);
+    }
     /**
      * @brief Draw glyph to an alpha-buffer.
+     *
      * An alpha-buffer is an array of uint8_t that represents transparencies.
      * It proves fit as a tool for drawing text.
      * @param   p       Pointer to glyph to be drawn
      * @param   x       X-position to draw the glyph
      * @param   y       Y-position to draw the glyph
      * @param   alp_buf Alpha-buffer to which the glyph will be drawn
      * @param   W       Width of the alpha-buffer
      * @param   H       Height of the alpha-buffer
      */
     static int (glyph_draw_to_alpha_buffer)(const glyph_t *p, int16_t x, int16_t y, uint8_t *alp_buf, uint16_t W, uint16_t H){
         if(p == NULL) return NULL_PTR;
         for(int16_t h = 0; h < p->h; ++h){
-...
             return NULL;
+        }
+    }
     int (font_dtor)(font_t *p){
         if(p == NULL) return SUCCESS;
     void (font_dtor)(font_t *p){
         if(p == NULL) return;
         for(size_t i = 0; i < p->nchars; ++i)
             glyph_dtor(p->glyphs[i]);
         free(p->glyphs);
         free(p);
         return SUCCESS;
+    }
     static font_t *consolas     = NULL;
-...
+    }
     const font_t* font_get_default(void){ return default_font; }
     const font_t* font_get_consolas(void){ return consolas; }
     int (font_free)(void){
         int r;
         if((r = font_dtor(consolas))) return r;
     void (font_free)(void){
         font_dtor(consolas);
         consolas = NULL;
         default_font = NULL;
         return SUCCESS;
+    }
     /// TEXT
-...
         if(p->txt == NULL) return;
         strcpy(p->txt, txt);
+    }
     char* (text_get_string)(const text_t *p){return p->txt; }
     const char* (text_get_string)(const text_t *p){return p->txt; }
     void (text_set_pos)   (text_t *p, int16_t x, int16_t y){ p->x = x; p->y = y; }
     void (text_set_size)  (text_t *p, unsigned size       ){ p->size = size    ; }
     void (text_set_color) (text_t *p, uint32_t color      ){ p->color = color  ; }

         basic_sprite_dtor      (bsp_pistol   ); bsp_pistol    = NULL;
         basic_sprite_dtor      (bsp_nothing  ); bsp_nothing   = NULL;
         map_dtor               (map1         ); map1          = NULL;
         if(font_free()){ printf("Failed to free fonts\n"); return 1; }
         font_free();
         // Unsubscribe interrupts
         if (unsubscribe_all()) {

         if (ret == NULL) return NULL;
         ret->time = 0;
         ret->text = text_ctor(fnt, "000s");
         ret->array = text_get_string(ret->text);
         text_set_color(ret->text, TEXT_COLOR);
         return ret;
+    }
-...
     void (timer_update)(text_timer_t *p){
         if (p->time >= 999) return;
         p->time++;
         p->array[2] = p->time % 10 + '0';
         p->array[1] = (p->time/10) % 10 + '0';
         p->array[0] = (p->time/100) % 10 + '0';
         char buffer[100];
         sprintf(buffer, "%03ds", p->time);
         text_set_string(p->text, buffer);
+    }
     void (timer_reset)(text_timer_t *p){
         p->time = 0;
         p->array[2] = '0';
         p->array[1] = '0';
         p->array[0] = '0';
         text_set_string(p->text, "000s");
+    }
     void (timer_dtor)(text_timer_t *p){

Project

General

Profile

LCOM1920-T5G03

Revision 319