E:/PPC/XFlib/source/xf_text.c

Go to the documentation of this file.

#ifdef __cplusplus
extern "C" {
#endif


#include "xf_text.h"
#include "xf_bg.h"
#include "xf_params.h"
#include <malloc.h>

#include "Text/all_gfx.h"

XF_Font *xf_deffonts[5] = {&xf_text0, &xf_text1, &xf_text2, &xf_text3, &xf_text4};
u32 xf_deffontsize[5] = {sizeof(xf_text0_Font), sizeof(xf_text1_Font), sizeof(xf_text2_Font), sizeof(xf_text3_Font), sizeof(xf_text4_Font)};
        
XF_Font *xf_fonts[16] = {};

XF_TextTemp XF_LetterPos;
XF_TextSlot_type *XF_TextSlot[N_BG] = {}; // Vide /*[256]*/;


xf_textinfo_type xf_textinfo = {0, 1, ALIGN_LEFT, 32, 0}; // Alpha = 32, bg !





extern inline void XF_AddLetterPos(s16 Letter, s16 x, s16 y){
        XF_LetterPos.Letter[XF_LetterPos.NLetters].Letter = Letter;
        XF_LetterPos.Letter[XF_LetterPos.NLetters].X = x;
        XF_LetterPos.Letter[XF_LetterPos.NLetters].Y = y;
        XF_LetterPos.NLetters++;        
}



/* Michoko EDITION */
void XF_DoAlign(u16 start, s16 x, s16 maxx, u8 justify, u8 align){
   s16 i;
   s16 width = (maxx+1)-x;
//   XF_Print(0, "%d   \n", width);
   
        if(align == ALIGN_RIGHT){ // Cas simple, on rajoute la différence de largeur à toutes les lettres...
                width++;
                for(i = start; i < XF_LetterPos.NLetters; i++) XF_LetterPos.Letter[i].X += width;
        }     
        else if(align == ALIGN_CENTER){ // Cas simple, on rajoute la moitié de la largeur à toutes les lettres...
                width = (width+1)>>1;
                for(i = start; i < XF_LetterPos.NLetters; i++) XF_LetterPos.Letter[i].X += width;
        }    
        else if(justify && (align == ALIGN_JUSTIFY)){ // Cas relou ^^
                //u8 nletters = XF_LetterPos.NLetters-start; // Nombre de lettres
                u8 justify = 0; // Décallage à faire au début...
                u8 spaces = 0;
                u8 change = 0;
                u8 quickadd = 0;
                
                u8 nletters = XF_LetterPos.NLetters-1 - start;
                if(nletters < width){ // Less letters than the width to add, add 1 pixel/letter...
                        quickadd = 1;
                        width -= nletters;
                }
                // Compter le nombre d'espaces
                for(i = start; i < XF_LetterPos.NLetters-1; i++) if(XF_LetterPos.Letter[i].Letter == ' ') spaces++;
                
                for(i = start; i < XF_LetterPos.NLetters; i++) {
                        justify+= quickadd;
                   XF_LetterPos.Letter[i].X += justify;
                   if((XF_LetterPos.Letter[i].Letter == ' ')&&width){
                      change = (width+(spaces>>1))/spaces;
                                justify+=change;                 
                                width-=change; // Moins à corriger par la suite...  
                                spaces--;   
                   }   
                }   
        }    
                
}   


void XF_DoLetterPos(s16 basex, s16 basey, s16 maxx, s16 maxy, char* text, u8 size, u8 alpha, s8 letterspacing, s8 linespacing, s8 align, s32 limit){
        s16 x = basex; s16 y = basey;
        s16 width, letterstart;
        u8 lx, letter;
        s16 i;
        
        XF_LetterPos.NLetters = 0;
        letterstart = 0;
        
        if((align == ALIGN_JUSTIFY)||(align == ALIGN_LEFT)) limit += 100; // Pour bien caler la ligne
        
        for(i = 0; (i < limit+100)&&(text[i]); i++){
           letter = text[i]; 
           lx = xf_fonts[size]->LetterWidth[letter]+letterspacing;
           
           if((letter == '\n') || ((x+lx > maxx)&&(letter != ' '))){ // retour ligne, ou on dépasse...
                
                        
                        width = x - basex; // LARGEUR !

      if(letter == '\n')XF_AddLetterPos(letter, x, y); // Retour ligne à mettre dans le tableau
      else if(letter == ' ') XF_AddLetterPos(letter, x, y); // Si espace, on met à la suite
      else {
         // Sinon, on revient en arrière pour pas couper un mot !
         while(text[i-1] != ' ') { i--; x -= xf_fonts[size]->LetterWidth[letter] + letterspacing; XF_LetterPos.NLetters--;} // Retirer les lettres et la largeur
                   letter = text[i]; 
                   lx = xf_fonts[size]->LetterWidth[letter] + letterspacing;     
                        x--; // Moins de largeur        
      }  
                          
   
              // Calculer différence de largeur...
                        if(text[i-1] == ' ') x-= xf_fonts[size]->LetterWidth[' ']; // Retirer la largeur de l'espace      
                
                   if(y+ xf_fonts[size]->LetterHeight * 2 > maxy) {
                break; // EXIT !        
                        }   
                                              
              // Retour ligne ! Voir si besoin d'aligne le texte d'un côté ou de l'autre, centrer, etc...
                        XF_DoAlign(letterstart, x, maxx, (letter != '\n'), align); // Autorise le justify que si pas '\'n
   
   
              x = basex;
              y += xf_fonts[size]->LetterHeight +linespacing;
              
           
              
              
              letterstart = XF_LetterPos.NLetters; // Première lettre de cette ligne !
              if(letter > 32) {
                           XF_AddLetterPos(letter, x, y);
                           x += lx;              
              }               

                   
           }   
           else{
                   XF_AddLetterPos(letter, x, y);
                   x += lx;   
                }               
        }   
        if(text[i-1] == ' ') x-= xf_fonts[size]->LetterWidth[' ']; // Retirer la largeur de l'espace     
        XF_DoAlign(letterstart, x, maxx, (y + xf_fonts[size]->LetterHeight * 2 > maxy), align);

        // End Position
        XF_LetterPos.Letter[XF_LetterPos.NLetters].X = x;
        XF_LetterPos.Letter[XF_LetterPos.NLetters].Y = y;

}


void xf_textdecompress(u8 size){
        u16 temp;

        // On malloc la structure
        xf_fonts[size] = (XF_Font*)malloc(sizeof(XF_Font));
        
        xf_fonts[size]->LetterStart = xf_deffonts[size]->LetterStart; // On pointe au même endroit
        xf_fonts[size]->LetterWidth = xf_deffonts[size]->LetterWidth; // On pointe au même endroit
        xf_fonts[size]->LetterHeight = xf_deffonts[size]->LetterHeight; // Meme valeur
                
        xf_fonts[size]->Image = (u16*)malloc(xf_deffontsize[size]*16); // Gros malloc... on va en faire le mask :D
        
        s32 i, j;
        u16 *buffer = (u16*)xf_fonts[size]->Image;
        u8 *img = (u8*)xf_deffonts[size]->Image;
        
        for(i = 0; i < xf_deffontsize[size]; i++){
                // On fout en 8 pixels...
                for(j = 0; j < 8; j++){
                        temp = ((img[i])>>j)&1;
                        buffer[i*8+j] = temp*0xFFFF;
                        //XF_DebugText(j, 2, "%d", temp);
                }       
                //XF_WaitFor(Stylus.Held);
        }
        
        //XF_DebugText(0, 3, "%d => %d   ", size, xf_deffontsize[size]);


}

void xf_cleanfonts(void){
        u8 i;
        
        
        for(i = 0; i < 5; i++){
                if(xf_fonts[i] != 0){
                        // On libère !
                        free(xf_fonts[i]->Image);
                        free(xf_fonts[i]);
                }
                
                xf_fonts[i] = 0;
        }

        for(i = 5; i < 16; i++){
                if(xf_fonts[i] != 0){
                        // On libère !
                        free(xf_fonts[i]->Image);
                        free(xf_fonts[i]->LetterStart);                 
                        free(xf_fonts[i]->LetterWidth);                 
                        free(xf_fonts[i]);              
                }
                xf_fonts[i] = 0;
        }
}

/*

typedef struct{
        s32 NLetters;
        u8 Size;
        u16 Color;
        XF_Letter *Letter;
} XF_TextSlot_type;
XF_TextSlot_type XF_TextSlot[32];*/




s16 XF_CreateTextEx(u8 bg, u8 slot, s16 basex, s16 basey, s16 maxx, s16 maxy, char* text, u16 color, u8 size, u8 alpha, s8 letterspacing, s8 linespacing, s8 align, s32 limit){
        s16 i;
        
        

        
//      return 0;
        
        if(xf_fonts[size] == 0) {
                if(size < 5) xf_textdecompress(size);
                else return 0; // On ne fait rien !
        }
        

        XF_TextSlot[bg][slot].Color = color;
        XF_TextSlot[bg][slot].Size = size;      
        
        XF_TextSlot[bg][slot].letterspacing = letterspacing;
        XF_TextSlot[bg][slot].linespacing = linespacing;
        XF_TextSlot[bg][slot].align = align;
        XF_TextSlot[bg][slot].alpha = alpha;
                
        XF_DoLetterPos(basex, basey, maxx, maxy, text, size, alpha, letterspacing, linespacing, align, limit);
        
        if(limit > XF_LetterPos.NLetters) limit = XF_LetterPos.NLetters; // Plus short que prévu
        XF_LetterPos.NLetters = limit;
        
        // On compare à la taille d'avant...
        if((XF_TextSlot[bg][slot].Letter == 0) || (limit > XF_TextSlot[bg][slot].MallocSize)){
                if(XF_TextSlot[bg][slot].Letter == 0) free(XF_TextSlot[bg][slot].Letter);
                XF_TextSlot[bg][slot].MallocSize = XF_LetterPos.NLetters + 16; // Un peu de marge
                XF_TextSlot[bg][slot].Letter = (XF_Letter*)malloc(sizeof(XF_Letter)*(XF_TextSlot[bg][slot].MallocSize+1));
        }



        // Enregistrer les limites
        XF_TextSlot[bg][slot].x0 = basex;
        XF_TextSlot[bg][slot].y0 = basey;
        XF_TextSlot[bg][slot].x1 = maxx;
        XF_TextSlot[bg][slot].y1 = maxy;        
        
        for(i = 0; i < limit; i++) XF_TextSlot[bg][slot].Letter[i] = XF_LetterPos.Letter[i]; // On copie tout !
        XF_TextSlot[bg][slot].NLetters = XF_LetterPos.NLetters;
        XF_TextSlot[bg][slot].Alpha = xf_textinfo.alpha;
        
        return limit;
}



void XF_ResetTextBg(u8 bg){
        u16 slot;
        
//      return;
        
        for(slot = 0; slot < TEXT_SLOTS; slot++)        {
                XF_TextSlot[bg][slot].NLetters = 0;
                if(XF_TextSlot[bg][slot].Letter != 0) free(XF_TextSlot[bg][slot].Letter);
                XF_TextSlot[bg][slot].Letter = 0;
        }
}



void XF_LoadTextBg(u8 number){

        if(XF_TextSlot[number] == 0) {
                XF_TextSlot[number] = (XF_TextSlot_type*)malloc(sizeof(XF_TextSlot_type)*TEXT_SLOTS);
                s32 i;
                for(i = 0; i < TEXT_SLOTS; i++) {
                        XF_TextSlot[number][i].NLetters = 0;
                        XF_TextSlot[number][i].Letter = 0;
                }
        }

        XF_BgDelete(number);
        

        xf_bg[number].Alive = 1;
        xf_bg[number].BgMode = BG_FONT;

        xf_bg[number].Priority = number; // Priorité classique
        
        xf_bg[number].ScrollX = 0;
        xf_bg[number].ScrollY = 0;


        xf_bg[number].Alpha = ALPHA_MAX; // Fully visible

        xf_bg[number].Full = 0; // Never full, uses tiles
        XF_LetterPos.NLetters = 0; // Rien
        
        XF_SetDefaultTextBg(number); // Ecrire sur ce fond à l'avenir :p
}



void XF_CopyLetter(u16 *buffer, u16 color, s32 width, s32 height, s32 x, s32 y, u8 alpha);
void XF_CopyPlainLetter(u16 *mask, u16 color, s32 width, s32 height, s32 x, s32 y, u8 alpha) ;


void XF_ShowTextBg(u8 number){
        s16 i, slot;
        u8 letter, size, height;
        u16 color;
        u8 alpha;
        XF_TextSlot_type *txtslot;
//      return;
        
        for(slot = 0; slot < TEXT_SLOTS; slot++){
                txtslot = &XF_TextSlot[number][slot];
                
                
                if((txtslot != 0) && (txtslot->NLetters > 0) && (txtslot->Alpha > 0)){
                        alpha = txtslot->Alpha;
                        size = txtslot->Size;   
                        u16 *data = xf_fonts[size]->Image;
                        height = xf_fonts[size]->LetterHeight;
                                
                        if(size < 5){
                                color = txtslot->Color;

                                // Pas de couleurs farfelues
                                for(i = 0; i < XF_TextSlot[number][slot].NLetters; i++) {
                                        letter = txtslot->Letter[i].Letter;
                                        XF_CopyPlainLetter((u16*)(data + ((xf_fonts[size]->LetterStart[letter])>>1)), color, xf_fonts[size]->LetterWidth[letter], height, txtslot->Letter[i].X, txtslot->Letter[i].Y, alpha);

                                }
                        }
                        else{
                                for(i = 0; i < XF_TextSlot[number][slot].NLetters; i++) {
                                        letter = txtslot->Letter[i].Letter;
                                        XF_CopyLetter((u16*)(data + xf_fonts[size]->LetterStart[letter]), 1, xf_fonts[size]->LetterWidth[letter], height, txtslot->Letter[i].X, txtslot->Letter[i].Y, alpha);

                                }       
                        }
                }
        }


}

void XF_ClearText(u8 slot){
        XF_TextSlot[xf_textinfo.bg][slot].NLetters = 0; // POUF
}



#ifdef __cplusplus
}
#endif

---