axwin2 - Working on GUI, implemented image loading
[tpg/acess2.git] / Usermode / Applications / axwin2_src / WM / video_text.c
1 /*
2  * Acess GUI (AxWin) Version 2
3  * By John Hodge (thePowersGang)
4  */
5 #include "common.h"
6
7 typedef struct sGlyph {
8         struct sGlyph   *Next;
9         struct sGlyph   *Prev;
10         
11         uint32_t        Codepoint;
12         
13         // Effective dimensions (distance to move 'cursor')
14         short   Width;
15         short   Height;
16         
17         // Distance from the current cursor position to render at
18         short   OffsetX;
19         short   OffsetY;
20         
21         // True dimensions (size of the bitmap
22         short   TrueWidth;
23         short   TrueHeight;
24         
25         // Bitmap Data
26         uint8_t Bitmap[];       // 8-bit alpha
27         
28 }       tGlyph;
29
30 struct sFont {
31         struct sFont    *Next;
32          int    ReferenceCount;
33         
34         tGlyph  *AsciiGlyphs[128];      // Glyphs 0-127
35         
36         tGlyph  *FirstGlyph;
37         tGlyph  *LastGlyph;
38         
39         tGlyph  *(*CacheGlyph)(struct sFont *this, uint32_t Codepoint);
40         
41 };
42
43
44 // === PROTOTYPES ===
45  int    Video_DrawText(short X, short Y, short W, short H, tFont *Font, uint32_t Color, char *Text);
46 tGlyph  *_GetGlyph(tFont *Font, uint32_t Codepoint);
47 void    _RenderGlyph(short X, short Y, tGlyph *Glyph, uint32_t Color);
48 tGlyph  *_SystemFont_CacheGlyph(tFont *Font, uint32_t Codepoint);
49  int    ReadUTF8(const char *Input, uint32_t *Output);
50
51 // === GLOBALS ===
52 tFont   gSystemFont = {
53         CacheGlyph: _SystemFont_CacheGlyph
54 };
55
56 // === CODE ===
57 /**
58  * \brief Draw text to the screen
59  */
60 int Video_DrawText(short X, short Y, short W, short H, tFont *Font, uint32_t Color, char *Text)
61 {
62          int    xOfs = 0;
63         tGlyph  *glyph;
64         uint32_t        ch = 0;
65
66         _SysDebug("Video_DrawText: (X=%i,Y=%i,W=%i,H=%i,Font=%p,", X, Y, W, H, Font);
67         _SysDebug("  Color=%08x,Text='%s')", Color, Text);
68         
69         // Check the bounds
70         if(W < 0 || X < 0 || X >= giScreenWidth)        return 0;
71         if(X + W > giScreenWidth)       W = giScreenWidth - X;
72         
73         if(H < 0 || Y < 0 || Y >= giScreenHeight)       return 0;
74         if(Y + H > giScreenHeight)      H = giScreenHeight - Y;
75         
76         // Handle NULL font (system default monospace)
77         if( !Font )     Font = &gSystemFont;
78         
79         while( *Text )
80         {
81                 // Read character
82                 Text += ReadUTF8(Text, &ch);
83                 
84                 // Find (or load) the glyph
85                 glyph = _GetGlyph(Font, ch);
86                 if( !glyph )    continue ;      // If not found, just don't render it
87                 
88                 // End render if it will overflow the perscribed range
89                 if( xOfs + glyph->TrueWidth > W )
90                         break;
91                 
92                 xOfs += glyph->Width;
93                 _RenderGlyph(X + xOfs, Y, glyph, Color);
94         }
95         
96         return xOfs;
97 }
98
99 void Video_GetTextDims(tFont *Font, const char *Text, int *W, int *H)
100 {
101          int    w=0, h=0;
102         uint32_t        ch;
103         tGlyph  *glyph;
104         if( !Font )     Font = &gSystemFont;
105         
106         while( *Text )
107         {
108                 Text += ReadUTF8(Text, &ch);
109                 glyph = _GetGlyph(Font, ch);
110                 if( !glyph )    continue;
111                 
112                 w += glyph->Width;
113                 if( h < glyph->Height ) h = glyph->Height;
114         }
115         
116         if(W)   *W = w;
117         if(H)   *H = h;
118 }
119
120 tGlyph  *_GetGlyph(tFont *Font, uint32_t Codepoint)
121 {
122         tGlyph  *next = NULL, *prev = NULL;
123         tGlyph  *new;
124         
125         // Check for ASCII
126         if( Codepoint < 128 )
127         {
128                 if( Font->AsciiGlyphs[Codepoint] == NULL ) {
129                         Font->AsciiGlyphs[Codepoint] = Font->CacheGlyph(Font, Codepoint);
130                 }
131                 
132                 return Font->AsciiGlyphs[Codepoint];
133         }
134         
135         // If within the range
136         if( Font->FirstGlyph && Font->FirstGlyph->Codepoint < Codepoint && Codepoint < Font->LastGlyph->Codepoint )
137         {
138                 // Find what end is "closest"
139                 if( Codepoint - Font->FirstGlyph->Codepoint < Font->LastGlyph->Codepoint - Codepoint )
140                 {
141                         // Start from the bottom
142                         for( next = Font->FirstGlyph;
143                                  next && next->Codepoint < Codepoint;
144                                  prev = next, next = next->Next
145                                  );
146                         
147                         if( next->Codepoint == Codepoint )
148                                 return next;
149                         
150                 }
151                 else
152                 {
153                         // Start at the top
154                         // NOTE: The roles of next and prev are reversed here to allow 
155                         //       the insert to be able to assume that `prev` is the
156                         //       previous entry, and `next` is the next.
157                         for( prev = Font->LastGlyph;
158                                  prev && prev->Codepoint > Codepoint;
159                                  next = prev, prev = prev->Prev
160                                  );
161                         if( prev->Codepoint == Codepoint )
162                                 return prev;
163                 }
164         }
165         else
166         {
167                 // If below first
168                 if( !Font->FirstGlyph ||  Font->FirstGlyph->Codepoint > Codepoint ) {
169                         prev = NULL;
170                         next = Font->FirstGlyph;
171                 }
172                 // Above last
173                 else {
174                         prev = Font->LastGlyph;
175                         next = NULL;
176                 }
177         }
178         
179         // Load new
180         new = Font->CacheGlyph(Font, Codepoint);
181         if( !new )      return NULL;
182         
183         // Add to list
184         // - Forward link
185         if( prev ) {
186                 new->Next = prev->Next;
187                 prev->Next = new;
188         }
189         else {
190                 new->Next = Font->FirstGlyph;
191                 Font->FirstGlyph = new;
192         }
193         
194         // - Backlink
195         if( next ) {
196                 new->Prev = next->Prev;
197                 next->Prev = new;
198         }
199         else {
200                 new->Prev = Font->LastGlyph;
201                 Font->LastGlyph = new;
202         }
203         
204         // Return
205         return new;
206 }
207
208 /**
209  */
210 void _RenderGlyph(short X, short Y, tGlyph *Glyph, uint32_t Color)
211 {
212          int    xStart = 0, yStart = 0;
213          int    x, y;
214         uint32_t        *outBuf;
215         uint8_t *inBuf;
216         // TODO: Implement
217
218         X += Glyph->OffsetX;
219         if( X < 0 ) {   // If -ve, skip the first -X collums
220                 xStart = -X;
221                 X = 0;
222         }
223
224         Y += Glyph->OffsetY;
225         if( Y < 0 ) {   // If -ve, skip the first -Y lines
226                 yStart = -Y;
227                 Y = 0;
228         }
229
230         outBuf = gpScreenBuffer + Y*giScreenWidth + X;
231         inBuf = Glyph->Bitmap + yStart*Glyph->TrueWidth;
232
233         for( y = yStart; y < Glyph->TrueHeight; y ++ )
234         {
235                 for( x = xStart; x < Glyph->TrueWidth; x ++ )
236                 {
237                         outBuf[x] = Video_AlphaBlend( outBuf[x], Color, inBuf[x] );
238                 }
239                 outBuf += giScreenWidth;
240                 inBuf += Glyph->TrueWidth;
241
242         }
243 }
244
245 // Load system font (8x16 monospace)
246 #include "font_8x16.h"
247
248 /*
249  */
250 tGlyph *_SystemFont_CacheGlyph(tFont *Font, uint32_t Codepoint)
251 {
252          int    i;
253         uint8_t index = 0;
254         tGlyph  *ret;
255         uint8_t *data;
256
257         _SysDebug("_SystemFont_CacheGlyph: (Font=%p, Codepoint=0x%06x)", Font, Codepoint);
258         
259         if( Codepoint < 128 ) {
260                 index = Codepoint;
261         }
262         else {
263                 index = '?';    // Unknowns come out as a question mark
264         }
265
266         _SysDebug(" index = %i", index);
267
268         ret = malloc( sizeof(tGlyph) + FONT_WIDTH*FONT_HEIGHT );
269         if( !ret ) {
270                 _SysDebug("ERROR: malloc(%i) failed", sizeof(tGlyph) + FONT_WIDTH*FONT_HEIGHT);
271                 return NULL;
272         }
273
274         ret->Codepoint = Codepoint;
275
276         ret->Width = FONT_WIDTH;
277         ret->Height = FONT_HEIGHT;
278         
279         ret->TrueWidth = FONT_WIDTH;
280         ret->TrueHeight = FONT_HEIGHT;
281
282         ret->OffsetX = 0;
283         ret->OffsetY = 0;
284         
285         data = &VTermFont[index * FONT_HEIGHT];
286
287         for( i = 0; i < FONT_HEIGHT; i ++ )
288         {
289                 ret->Bitmap[ i * 8 + 0 ] = data[i] & (1 << 7) ? 255 : 0;
290                 ret->Bitmap[ i * 8 + 1 ] = data[i] & (1 << 6) ? 255 : 0;
291                 ret->Bitmap[ i * 8 + 2 ] = data[i] & (1 << 5) ? 255 : 0;
292                 ret->Bitmap[ i * 8 + 3 ] = data[i] & (1 << 4) ? 255 : 0;
293                 ret->Bitmap[ i * 8 + 4 ] = data[i] & (1 << 3) ? 255 : 0;
294                 ret->Bitmap[ i * 8 + 5 ] = data[i] & (1 << 2) ? 255 : 0;
295                 ret->Bitmap[ i * 8 + 6 ] = data[i] & (1 << 1) ? 255 : 0;
296                 ret->Bitmap[ i * 8 + 7 ] = data[i] & (1 << 0) ? 255 : 0;
297         }
298
299         return ret;
300 }
301
302
303 /**
304  * \fn int ReadUTF8(char *Input, uint32_t *Val)
305  * \brief Read a UTF-8 character from a string
306  */
307 int ReadUTF8(const char *Input, uint32_t *Val)
308 {
309         const uint8_t   *str = (const uint8_t *)Input;
310         *Val = 0xFFFD;  // Assume invalid character
311         
312         // ASCII
313         if( !(*str & 0x80) ) {
314                 *Val = *str;
315                 return 1;
316         }
317         
318         // Middle of a sequence
319         if( (*str & 0xC0) == 0x80 ) {
320                 return 1;
321         }
322         
323         // Two Byte
324         if( (*str & 0xE0) == 0xC0 ) {
325                 *Val = (*str & 0x1F) << 6;      // Upper 6 Bits
326                 str ++;
327                 if( (*str & 0xC0) != 0x80)      return -1;      // Validity check
328                 *Val |= (*str & 0x3F);  // Lower 6 Bits
329                 return 2;
330         }
331         
332         // Three Byte
333         if( (*str & 0xF0) == 0xE0 ) {
334                 *Val = (*str & 0x0F) << 12;     // Upper 4 Bits
335                 str ++;
336                 if( (*str & 0xC0) != 0x80)      return -1;      // Validity check
337                 *Val |= (*str & 0x3F) << 6;     // Middle 6 Bits
338                 str ++;
339                 if( (*str & 0xC0) != 0x80)      return -1;      // Validity check
340                 *Val |= (*str & 0x3F);  // Lower 6 Bits
341                 return 3;
342         }
343         
344         // Four Byte
345         if( (*str & 0xF1) == 0xF0 ) {
346                 *Val = (*str & 0x07) << 18;     // Upper 3 Bits
347                 str ++;
348                 if( (*str & 0xC0) != 0x80)      return -1;      // Validity check
349                 *Val |= (*str & 0x3F) << 12;    // Middle-upper 6 Bits
350                 str ++;
351                 if( (*str & 0xC0) != 0x80)      return -1;      // Validity check
352                 *Val |= (*str & 0x3F) << 6;     // Middle-lower 6 Bits
353                 str ++;
354                 if( (*str & 0xC0) != 0x80)      return -1;      // Validity check
355                 *Val |= (*str & 0x3F);  // Lower 6 Bits
356                 return 4;
357         }
358         
359         // UTF-8 Doesn't support more than four bytes
360         return 4;
361 }
362
363
364
365

UCC git Repository :: git.ucc.asn.au