archive/guilib/ufont.c

/* ufont.c */

#include "ufont.h"

#include "oslib/osfile.h"


#define MALLOC_CHUNK 256


struct ufont_font
{
  font_f handle[65536];
  char character[65536];
  unsigned int handles_used;
  font_f handles[256];
};


os_error error_exists = { error_FONT_NOT_FOUND, "Fonts file not found" };
os_error error_memory = { error_FONT_NO_ROOM, "Insufficient memory for font" };
os_error error_size = { error_FONT_BAD_FONT_FILE, "Wrong size of font file" };


/*
 *  UFont_FindFont
 *
 *  => as Font_FindFont, but
 *     font_name does not support '\' qualifiers
 *
 *  <= as Font_FindFont, but
 *     handle is 32-bit
 */

os_error *
xufont_find_font(char const *font_name,
                 int xsize,
                 int ysize,
                 int xres,
                 int yres,
                 struct ufont_font **font,
                 int *xres_out,
                 int *yres_out)
{
  char *old_font;
  char *fonts_file;
  char file_name[256];
  fileswitch_object_type obj_type;
  int code;
  int handle;
  unsigned int size;
  os_error *error;

  /* find size of Fonts file */
  strcpy(file_name, font_name);
  strcat(file_name, ".Fonts");
  error = xosfile_read_stamped_path(file_name, "UFont:", &obj_type, NULL, NULL, &size, NULL, NULL);
  if (error != NULL) return error;
  if (obj_type != fileswitch_IS_FILE) return &error_exists;

  /* allocate memory */
  fonts_file = malloc(size);
  if (fonts_file == NULL) return &error_memory;

  *font = malloc(sizeof(struct ufont_font));
  if (*font == NULL) return &error_memory;

  /* load Fonts */
  error = xosfile_load_stamped_path(file_name, fonts_file, "UFont:", NULL, NULL, NULL, NULL, NULL);
  if (error != NULL) return error;

  /* open all fonts listed in Fonts */
  for (old_font = fonts_file, handle = 0; old_font - fonts_file < size;
       old_font += strlen(old_font) + 1, handle++)
  {
/*     #ifdef DEBUG */
/*     printf("%i %s: ", handle, old_font); */
/*     #endif */

    error = xfont_find_font(old_font, xsize, ysize, xres, yres,
                            &(*font)->handles[handle], xres_out, yres_out);
    if (error != NULL) return error;

/*     #ifdef DEBUG */
/*     printf("%i\n", (*font)->handles[handle]); */
/*     #endif */
  }
  (*font)->handles_used = handle;

  /* free Fonts */
  free(fonts_file);

  /* load Data */
  strcpy(file_name, font_name);
  strcat(file_name, ".Data");
  error = xosfile_load_stamped_path(file_name, (byte *) (*font), "UFont:",
                                    NULL, NULL, NULL, &size, NULL);
  if (error != NULL) return error;
  if (size != 2*65536) return &error_size;

  /* change font indexes to font handles */
  for (code = 0; code < 65536; code++)
    (*font)->handle[code] = (*font)->handles[(*font)->handle[code]];

  return NULL;
}


/*
 *  UFont_LoseFont
 *
 *  => font handle as returned by UFont_FindFont
 */

os_error *
xufont_lose_font(struct ufont_font *font)
{
  unsigned int handle;
  os_error *error;

  /* close all fonts used */
  for (handle = 0; handle < font->handles_used; handle++)
  {
    error = xfont_lose_font(font->handles[handle]);
    if (error != NULL) return error;
  }

  /* free font structure */
  free(font);

  return NULL;
}


/*
 *  UFont_Paint
 *
 *  => font handle as returned by UFont_FindFont
 *     string is unicode (2 byte characters), see UFont_Convert
 *     other parameters as Font_Paint
 */

os_error *
xufont_paint(struct ufont_font *font,
             wchar_t const *string,
             font_string_flags flags,
             int xpos,
             int ypos,
             font_paint_block const *block,
             os_trfm const *trfm,
             unsigned int length)
{
  char *result;
  os_error *error;

  if ((flags & font_GIVEN_LENGTH) == 0) length = 0x7fffffff;

  error = xufont_convert(font, string, length, &result, NULL);
  if (error != NULL) return error;

  error = xfont_paint(result[1], result,
                      (flags & (~font_GIVEN_LENGTH)) | font_GIVEN_FONT,
                      xpos, ypos, block, trfm, 0);
  if (error != NULL) { free(result); return error; }

  free(result);

  return NULL;
}


/*
 *  UFont_Convert
 *
 *  => initial font
 *     unicode string to convert
 *     length to convert (characters)
 *
 *     control sequences in string (all 2 byte):
 *
 *        9, dx_low, dx_middle, dx_high   (each 2 byte, but maximum 255)
 *       11, dy_low, dy_middle, dy_high                 "
 *       19, r, g, b, R, G, B, max                      "
 *       25, underline_position, underline_thickness    "
 *       26, font_handle                  (4 bytes, ie. 2 wide characters)
 *       27, m1, m2, m3, m4               (each matrix entry 4 bytes,
 *       28, m1, m2, m3, m4, m5, m6        ie. 2 wide characters)
 *
 *  <= string converted to Font_Paint format
 *     table of offsets in unicode string
 */

os_error *
xufont_convert(struct ufont_font *font,
               wchar_t const *string,
               unsigned int length,
               char **presult,
               unsigned int **ptable)
{
  char *result;
  unsigned int string_index = 0;
  unsigned int result_index = 0;
  unsigned int i;
  unsigned int current_size = MALLOC_CHUNK;
  unsigned int *table;
  font_f current_font = 0;

  result = malloc(MALLOC_CHUNK);
  if (result == NULL) return &error_memory;

  if (ptable != NULL)
  {
    table = malloc(MALLOC_CHUNK * sizeof(unsigned int));
    if (table == NULL) return &error_memory;
  }

  while ((string[string_index] != 0) && (string_index < length))
  {
/*     #ifdef DEBUG */
/*     printf("0x%x ", string[string_index]); */
/*     #endif */

    if (result_index + 32 > current_size)
    {
      current_size += MALLOC_CHUNK;

      result = realloc(result, current_size);
      if (result == NULL) return &error_memory;

      if (ptable != NULL)
      {
        table = realloc(result, current_size * sizeof(unsigned int));
        if (table == NULL) return &error_memory;
      }
    }

    if (ptable != NULL) table[result_index] = string_index;

    switch (string[string_index])
    {
      case 9:
      case 11:
      {
        if (ptable != NULL)
          table[result_index + 1] = table[result_index + 2] = table[result_index + 3] = string_index;

        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        break;
      }
      case 19:
      {
        if (ptable != NULL)
          table[result_index + 1] = table[result_index + 2] = table[result_index + 3] =
          table[result_index + 4] = table[result_index + 5] = table[result_index + 6] =
                                                              table[result_index + 7] = string_index;

        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        break;
      }
      case 25:
      {
        if (ptable != NULL)
          table[result_index + 1] = table[result_index + 2] = string_index;

        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        result[result_index++] = string[string_index++];
        break;
      }
      case 26:
      {
        string_index++;
        font = (struct ufont_font *) ((string[string_index + 1] << 16) | string[string_index]);
        break;
      }
      case 27:
      {
        if (ptable != NULL)
          for (i = result_index + 1; i < ((result_index + 1 + 16 + 3) & (unsigned int) (~3)); i++)
            table[i] = string_index;

        result[result_index++] = string[string_index++];
        result_index = (result_index + 3) & (unsigned int) (~3);
        for (i = 0; i < 8; i++)
        {
          result[result_index++] = string[string_index] & 0xff;
          result[result_index++] = string[string_index++] >> 8;
        }
        break;
      }
      case 28:
      {
        if (ptable != NULL)
          for (i = result_index + 1; i < ((result_index + 1 + 24 + 3) & (unsigned int) (~3)); i++)
            table[i] = string_index;

        result[result_index++] = string[string_index++];
        result_index = (result_index + 3) & (unsigned int) (~3);
        for (i = 0; i < 12; i++)
        {
          result[result_index++] = string[string_index] & 0xff;
          result[result_index++] = string[string_index++] >> 8;
        }
        break;
      }
      default:
      {
        if (font->handle[(unsigned int) string[string_index]] != current_font)
        {
          if (ptable != NULL)
            table[result_index + 1] = table[result_index + 2] = string_index;

          result[result_index++] = 26;
          result[result_index++] = current_font = font->handle[(unsigned int) string[string_index]];

/*           #ifdef DEBUG */
/*           printf("{%i} ", current_font); */
/*           #endif */
        }
        result[result_index++] = font->character[(unsigned int) string[string_index++]];

/*         #ifdef DEBUG */
/*         printf("[0x%x] ", result[result_index - 1]); */
/*         #endif */

        break;
      }
    }
  }
  result[result_index] = 0;

  *presult = result;
  if (ptable != NULL)
  {
    table[result_index] = string_index;
    *ptable = table;
  }

/*   #ifdef DEBUG */
/*   printf("\n"); */

/*   for (result_index = 0; result[result_index] != 0; result_index++) */
/*     printf("0x%x ", result[result_index]); */
/*   printf("\n"); */
/*   #endif */

  return NULL;
}


/*
 *  UFont_ScanString
 *
 *  => font handle as returned by UFont_FindFont
 *     string is unicode (2 byte characters), see UFont_Convert
 *     split length is index in string, not pointer
 *     other parameters as Font_ScanString
 *
 *  <= as Font_ScanString
 */

extern os_error *
xufont_scan_string(ufont_f font,
                   wchar_t const *string,
                   font_string_flags flags,
                   int x,
                   int y,
                   font_scan_block const *block,
                   os_trfm const *trfm,
                   unsigned int length,
                   int *split_length,
                   int *x_out,
                   int *y_out,
                   int *length_out)
{
  char *result;
  char *split_point;
  unsigned int *table;
  os_error *error;

  if ((flags & font_GIVEN_LENGTH) == 0) length = 0x7fffffff;

  error = xufont_convert(font, string, length, &result, &table);
  if (error != NULL) return error;

/*   #ifdef DEBUG */
/*   { */
/*     unsigned int i; */
/*     for (i = 0; i < 200; i++) */
/*       printf("%i ", table[i]); */
/*     printf("\n"); */
/*   } */
/*   #endif */

  error = xfont_scan_string((font_f) result[1], result,
                      (flags & (~font_GIVEN_LENGTH)) | font_GIVEN_FONT,
                      x, y, block, trfm, 0,
                      &split_point, x_out, y_out, length_out);
  if (error != NULL) { free(result); return error; }

  if (split_length != NULL)
    *split_length = table[split_point - result];

  free(result);
  free(table);

  return NULL;
}
1	james	16	/* ufont.c */
2
3			#include "ufont.h"
4
5			#include "oslib/osfile.h"
6
7
8			#define MALLOC_CHUNK 256
9
10
11			struct ufont_font
12			{
13			font_f handle[65536];
14			char character[65536];
15			unsigned int handles_used;
16			font_f handles[256];
17			};
18
19
20			os_error error_exists = { error_FONT_NOT_FOUND, "Fonts file not found" };
21			os_error error_memory = { error_FONT_NO_ROOM, "Insufficient memory for font" };
22			os_error error_size = { error_FONT_BAD_FONT_FILE, "Wrong size of font file" };
23
24
25			/*
26			* UFont_FindFont
27			*
28			* => as Font_FindFont, but
29			* font_name does not support '\' qualifiers
30			*
31			* <= as Font_FindFont, but
32			* handle is 32-bit
33			*/
34
35			os_error *
36			xufont_find_font(char const *font_name,
37			int xsize,
38			int ysize,
39			int xres,
40			int yres,
41			struct ufont_font **font,
42			int *xres_out,
43			int *yres_out)
44			{
45			char *old_font;
46			char *fonts_file;
47			char file_name[256];
48			fileswitch_object_type obj_type;
49			int code;
50			int handle;
51			unsigned int size;
52			os_error *error;
53
54			/* find size of Fonts file */
55			strcpy(file_name, font_name);
56			strcat(file_name, ".Fonts");
57			error = xosfile_read_stamped_path(file_name, "UFont:", &obj_type, NULL, NULL, &size, NULL, NULL);
58			if (error != NULL) return error;
59			if (obj_type != fileswitch_IS_FILE) return &error_exists;
60
61			/* allocate memory */
62			fonts_file = malloc(size);
63			if (fonts_file == NULL) return &error_memory;
64
65			*font = malloc(sizeof(struct ufont_font));
66			if (*font == NULL) return &error_memory;
67
68			/* load Fonts */
69			error = xosfile_load_stamped_path(file_name, fonts_file, "UFont:", NULL, NULL, NULL, NULL, NULL);
70			if (error != NULL) return error;
71
72			/* open all fonts listed in Fonts */
73			for (old_font = fonts_file, handle = 0; old_font - fonts_file < size;
74			old_font += strlen(old_font) + 1, handle++)
75			{
76			/* #ifdef DEBUG */
77			/* printf("%i %s: ", handle, old_font); */
78			/* #endif */
79
80			error = xfont_find_font(old_font, xsize, ysize, xres, yres,
81			&(*font)->handles[handle], xres_out, yres_out);
82			if (error != NULL) return error;
83
84			/* #ifdef DEBUG */
85			/* printf("%i\n", (font)->handles[handle]); /
86			/* #endif */
87			}
88			(*font)->handles_used = handle;
89
90			/* free Fonts */
91			free(fonts_file);
92
93			/* load Data */
94			strcpy(file_name, font_name);
95			strcat(file_name, ".Data");
96			error = xosfile_load_stamped_path(file_name, (byte ) (font), "UFont:",
97			NULL, NULL, NULL, &size, NULL);
98			if (error != NULL) return error;
99			if (size != 2*65536) return &error_size;
100
101			/* change font indexes to font handles */
102			for (code = 0; code < 65536; code++)
103			(font)->handle[code] = (font)->handles[(*font)->handle[code]];
104
105			return NULL;
106			}
107
108
109			/*
110			* UFont_LoseFont
111			*
112			* => font handle as returned by UFont_FindFont
113			*/
114
115			os_error *
116			xufont_lose_font(struct ufont_font *font)
117			{
118			unsigned int handle;
119			os_error *error;
120
121			/* close all fonts used */
122			for (handle = 0; handle < font->handles_used; handle++)
123			{
124			error = xfont_lose_font(font->handles[handle]);
125			if (error != NULL) return error;
126			}
127
128			/* free font structure */
129			free(font);
130
131			return NULL;
132			}
133
134
135			/*
136			* UFont_Paint
137			*
138			* => font handle as returned by UFont_FindFont
139			* string is unicode (2 byte characters), see UFont_Convert
140			* other parameters as Font_Paint
141			*/
142
143			os_error *
144			xufont_paint(struct ufont_font *font,
145			wchar_t const *string,
146			font_string_flags flags,
147			int xpos,
148			int ypos,
149			font_paint_block const *block,
150			os_trfm const *trfm,
151			unsigned int length)
152			{
153			char *result;
154			os_error *error;
155
156			if ((flags & font_GIVEN_LENGTH) == 0) length = 0x7fffffff;
157
158			error = xufont_convert(font, string, length, &result, NULL);
159			if (error != NULL) return error;
160
161			error = xfont_paint(result[1], result,
162			(flags & (~font_GIVEN_LENGTH)) \| font_GIVEN_FONT,
163			xpos, ypos, block, trfm, 0);
164			if (error != NULL) { free(result); return error; }
165
166			free(result);
167
168			return NULL;
169			}
170
171
172			/*
173			* UFont_Convert
174			*
175			* => initial font
176			* unicode string to convert
177			* length to convert (characters)
178			*
179			* control sequences in string (all 2 byte):
180			*
181			* 9, dx_low, dx_middle, dx_high (each 2 byte, but maximum 255)
182			* 11, dy_low, dy_middle, dy_high "
183			* 19, r, g, b, R, G, B, max "
184			* 25, underline_position, underline_thickness "
185			* 26, font_handle (4 bytes, ie. 2 wide characters)
186			* 27, m1, m2, m3, m4 (each matrix entry 4 bytes,
187			* 28, m1, m2, m3, m4, m5, m6 ie. 2 wide characters)
188			*
189			* <= string converted to Font_Paint format
190			* table of offsets in unicode string
191			*/
192
193			os_error *
194			xufont_convert(struct ufont_font *font,
195			wchar_t const *string,
196			unsigned int length,
197			char **presult,
198			unsigned int **ptable)
199			{
200			char *result;
201			unsigned int string_index = 0;
202			unsigned int result_index = 0;
203			unsigned int i;
204			unsigned int current_size = MALLOC_CHUNK;
205			unsigned int *table;
206			font_f current_font = 0;
207
208			result = malloc(MALLOC_CHUNK);
209			if (result == NULL) return &error_memory;
210
211			if (ptable != NULL)
212			{
213			table = malloc(MALLOC_CHUNK * sizeof(unsigned int));
214			if (table == NULL) return &error_memory;
215			}
216
217			while ((string[string_index] != 0) && (string_index < length))
218			{
219			/* #ifdef DEBUG */
220			/* printf("0x%x ", string[string_index]); */
221			/* #endif */
222
223			if (result_index + 32 > current_size)
224			{
225			current_size += MALLOC_CHUNK;
226
227			result = realloc(result, current_size);
228			if (result == NULL) return &error_memory;
229
230			if (ptable != NULL)
231			{
232			table = realloc(result, current_size * sizeof(unsigned int));
233			if (table == NULL) return &error_memory;
234			}
235			}
236
237			if (ptable != NULL) table[result_index] = string_index;
238
239			switch (string[string_index])
240			{
241			case 9:
242			case 11:
243			{
244			if (ptable != NULL)
245			table[result_index + 1] = table[result_index + 2] = table[result_index + 3] = string_index;
246
247			result[result_index++] = string[string_index++];
248			result[result_index++] = string[string_index++];
249			result[result_index++] = string[string_index++];
250			result[result_index++] = string[string_index++];
251			break;
252			}
253			case 19:
254			{
255			if (ptable != NULL)
256			table[result_index + 1] = table[result_index + 2] = table[result_index + 3] =
257			table[result_index + 4] = table[result_index + 5] = table[result_index + 6] =
258			table[result_index + 7] = string_index;
259
260			result[result_index++] = string[string_index++];
261			result[result_index++] = string[string_index++];
262			result[result_index++] = string[string_index++];
263			result[result_index++] = string[string_index++];
264			result[result_index++] = string[string_index++];
265			result[result_index++] = string[string_index++];
266			result[result_index++] = string[string_index++];
267			result[result_index++] = string[string_index++];
268			break;
269			}
270			case 25:
271			{
272			if (ptable != NULL)
273			table[result_index + 1] = table[result_index + 2] = string_index;
274
275			result[result_index++] = string[string_index++];
276			result[result_index++] = string[string_index++];
277			result[result_index++] = string[string_index++];
278			break;
279			}
280			case 26:
281			{
282			string_index++;
283			font = (struct ufont_font *) ((string[string_index + 1] << 16) \| string[string_index]);
284			break;
285			}
286			case 27:
287			{
288			if (ptable != NULL)
289			for (i = result_index + 1; i < ((result_index + 1 + 16 + 3) & (unsigned int) (~3)); i++)
290			table[i] = string_index;
291
292			result[result_index++] = string[string_index++];
293			result_index = (result_index + 3) & (unsigned int) (~3);
294			for (i = 0; i < 8; i++)
295			{
296			result[result_index++] = string[string_index] & 0xff;
297			result[result_index++] = string[string_index++] >> 8;
298			}
299			break;
300			}
301			case 28:
302			{
303			if (ptable != NULL)
304			for (i = result_index + 1; i < ((result_index + 1 + 24 + 3) & (unsigned int) (~3)); i++)
305			table[i] = string_index;
306
307			result[result_index++] = string[string_index++];
308			result_index = (result_index + 3) & (unsigned int) (~3);
309			for (i = 0; i < 12; i++)
310			{
311			result[result_index++] = string[string_index] & 0xff;
312			result[result_index++] = string[string_index++] >> 8;
313			}
314			break;
315			}
316			default:
317			{
318			if (font->handle[(unsigned int) string[string_index]] != current_font)
319			{
320			if (ptable != NULL)
321			table[result_index + 1] = table[result_index + 2] = string_index;
322
323			result[result_index++] = 26;
324			result[result_index++] = current_font = font->handle[(unsigned int) string[string_index]];
325
326			/* #ifdef DEBUG */
327			/* printf("{%i} ", current_font); */
328			/* #endif */
329			}
330			result[result_index++] = font->character[(unsigned int) string[string_index++]];
331
332			/* #ifdef DEBUG */
333			/* printf("[0x%x] ", result[result_index - 1]); */
334			/* #endif */
335
336			break;
337			}
338			}
339			}
340			result[result_index] = 0;
341
342			*presult = result;
343			if (ptable != NULL)
344			{
345			table[result_index] = string_index;
346			*ptable = table;
347			}
348
349			/* #ifdef DEBUG */
350			/* printf("\n"); */
351
352			/* for (result_index = 0; result[result_index] != 0; result_index++) */
353			/* printf("0x%x ", result[result_index]); */
354			/* printf("\n"); */
355			/* #endif */
356
357			return NULL;
358			}
359
360
361			/*
362			* UFont_ScanString
363			*
364			* => font handle as returned by UFont_FindFont
365			* string is unicode (2 byte characters), see UFont_Convert
366			* split length is index in string, not pointer
367			* other parameters as Font_ScanString
368			*
369			* <= as Font_ScanString
370			*/
371
372			extern os_error *
373			xufont_scan_string(ufont_f font,
374			wchar_t const *string,
375			font_string_flags flags,
376			int x,
377			int y,
378			font_scan_block const *block,
379			os_trfm const *trfm,
380			unsigned int length,
381			int *split_length,
382			int *x_out,
383			int *y_out,
384			int *length_out)
385			{
386			char *result;
387			char *split_point;
388			unsigned int *table;
389			os_error *error;
390
391			if ((flags & font_GIVEN_LENGTH) == 0) length = 0x7fffffff;
392
393			error = xufont_convert(font, string, length, &result, &table);
394			if (error != NULL) return error;
395
396			/* #ifdef DEBUG */
397			/* { */
398			/* unsigned int i; */
399			/* for (i = 0; i < 200; i++) */
400			/* printf("%i ", table[i]); */
401			/* printf("\n"); */
402			/* } */
403			/* #endif */
404
405			error = xfont_scan_string((font_f) result[1], result,
406			(flags & (~font_GIVEN_LENGTH)) \| font_GIVEN_FONT,
407			x, y, block, trfm, 0,
408			&split_point, x_out, y_out, length_out);
409			if (error != NULL) { free(result); return error; }
410
411			if (split_length != NULL)
412			*split_length = table[split_point - result];
413
414			free(result);
415			free(table);
416
417			return NULL;
418			}