guifontname.c

The combined demo is dedicated for S1C33L05, so DMT33L05 should be used to load and run the demo. F

/* $id: guiFontname.c V1.0 2001/11/3 */
/***************************************************************************
 *    This source code has been made available to you by EPSON on an AS-IS
 *    basis. Anyone receiving this source is licensed under EPSON
 *    copyrights to use it in any way he or she deems fit, including
 *    copying it, modifying it, compiling it, and redistributing it either
 *    with or without modifications.
 *
 *    Any person who transfers this source code or any derivative work
 *    must include the EPSON copyright notice, this paragraph, and the
 *    preceding two paragraphs in the transferred software.
 *
 *    COPYRIGHT   EPSON  CORPORATION 2001
 *    LICENSED MATERIAL  -  PROGRAM PROPERTY OF EPSON
 **************************************************************************/


/***************************************************************************
 * FILE: guiFontname.c
 * MODULE: FONT
 *
 * PURPOSE: parse the font name to get information.
 *
 *
 * AUTHOR(S): ZhaoJZ
 * GROUP: GUI Group
 * DATE CREATED: 2001/11/3
 * REFERENCE DOCUMENT ID:
 * MODIFICATIONS:
 *    Date           userName          Description
 *    2001/11/3      ZhaoJZ            Create this file
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "sysGUI.h"

//#include "guiTotal.h"
#include "guiFont.h"

#include "guiFontname.h"


/* thereinafter reference to the defination of font's name */
#define NR_LOOP_FOR_STYLE   2
#define NR_LOOP_FOR_WIDTH   3
#define NR_LOOP_FOR_HEIGHT  4
#define NR_LOOP_FOR_CHARSET 5
/*************************************/

/******************************************************************
 * FUNCTION:    fontConvertFontType
 *
 * PURPOSE:
 *              convert type
 *
 * PARAMETERS
 *    Input:   	T_CONST T_BYTE* ---  the  name of font's type
 *    Output:
 *    InOut:
 *
 * Return value:T_WORD --- the name used by GUI
 * Reentrant : No
 *****************************************************************/
T_WORD fontConvertFontType(T_CONST T_BYTE *type)
{
    if(strcmp(type, FONT_TYPE_NAME_BITMAP_RAW) == 0)
        return FONT_TYPE_BITMAP_RAW;
    if(strcmp(type, FONT_TYPE_NAME_BITMAP_VAR) == 0)
        return FONT_TYPE_BITMAP_VAR;
    if(strcmp(type, FONT_TYPE_NAME_ALL) == 0)
        return FONT_TYPE_ALL;

    return -1;
}

/******************************************************************
 * FUNCTION:    fontGetFontTypeFromName
 *
 * PURPOSE:
 *              get the type from the font's name
 *
 * PARAMETERS
 *    Input:   	T_CONST T_BYTE* ---  font's name
 *    Output:
 *    InOut:
 *
 * Return value:T_WORD --- the name used by GUI
 * Reentrant : No
 *****************************************************************/
T_WORD fontGetFontTypeFromName(T_CONST T_BYTE* name)
{
    T_WORD i = 0;
    T_BYTE type[LEN_FONT_NAME + 1];

    while(name[i])
	{
        if(name[i] == '-')
		{
            type[i] = '\0';
            break;
        }

        type[i] = name[i];
        i++;
    }

    if(name[i] == '\0')
        return -1;

    return fontConvertFontType(type);
}

/******************************************************************
 * FUNCTION:    fnFNT_GetFamilyFromName
 *
 * PURPOSE:
 *              get the family of font from the font name
 *
 * PARAMETERS
 *    Input:    T_CONST T_BYTE* ---name
 *    Output:   T_BYTE* ---family
 *    InOut:
 *
 * Return value:T_BOOL --- if success then TRUE, else FALSE
 * Reentrant :  No
 *****************************************************************/
T_BOOL  fnFNT_GetFamilyFromName(T_CONST T_BYTE* name, T_BYTE* family)
{
	T_WORD i = 0;
    T_CONST T_BYTE* family_part;

    if((family_part = strchr(name, '-')) == NULL)
        return FALSE;
    if(*(++family_part) == '\0')
        return FALSE;

    while(family_part[i] && i <= LEN_FONT_NAME)
	{
        if(family_part[i] == '-')
		{
            family[i] = '\0';
            break;
        }

        family[i] = family_part[i];
        i++;
    }

    return TRUE;
}

/******************************************************************
 * FUNCTION:    fnFNT_ConvertStyle
 *
 * PURPOSE:
 *              convert the font style
 *
 * PARAMETERS
 *    Input:   T_CONST T_BYTE* --- the style of font
 *    Output:
 *    InOut:
 *
 * Return value:T_UWORD --- the value used by GUI
 * Reentrant : No
 *****************************************************************/
T_UWORD fnFNT_ConvertStyle(T_CONST T_BYTE* style_part)
{
	T_UWORD style = 0;

    switch(style_part[0])
	{
        case FONT_WEIGHT_BOLD:
            style |= FS_WEIGHT_BOLD;
            break;
        case FONT_WEIGHT_REGULAR:
            style |= FS_WEIGHT_REGULAR;
            break;
        case FONT_WEIGHT_ALL:
            style |= FS_WEIGHT_MASK;
        default:
            return 0xFFFFFFFF;
    }

    switch(style_part[1])
	{
        case FONT_SLANT_ITALIC:
            style |= FS_SLANT_ITALIC;
            break;
        case FONT_SLANT_ROMAN:
            style |= FS_SLANT_ROMAN;
            break;
        case FONT_SLANT_ALL:
            style |= FS_SLANT_MASK;
            break;
       default:
            return 0xFFFFFFFF;
    }

    switch(style_part[2])
	{
        case FONT_SETWIDTH_NORMAL:
            style |= FS_SETWIDTH_NORMAL;
            break;
        case FONT_SETWIDTH_ALL:
            style |= FS_SETWIDTH_MASK;
            break;
        default:
            return 0xFFFFFFFF;
    }

    switch(style_part[3])
	{
	    case FONT_SPACING_CHARCELL:
            style |= FS_SPACING_CHARCELL;
            break;
        case FONT_SPACING_ALL:
            style |= FS_SPACING_MASK;
            break;
        default:
            return 0xFFFFFFFF;
    }

    switch(style_part[4])
	{
        case FONT_UNDERLINE_LINE:
            style |= FS_UNDERLINE_LINE;
            break;
        case FONT_UNDERLINE_ALL:
            style |= FS_UNDERLINE_MASK;
            break;
        case FONT_UNDERLINE_NONE:
            style &= ~FS_UNDERLINE_MASK;
            break;
        default:
            return 0xFFFFFFFF;
    }

    switch(style_part[5])
	{
        case FONT_STRUCKOUT_LINE:
            style |= FS_STRUCKOUT_LINE;
            break;
        case FONT_STRUCKOUT_ALL:
            style |= FS_STRUCKOUT_MASK;
            break;
        case FONT_STRUCKOUT_NONE:
            style &= ~FS_STRUCKOUT_MASK;
            break;
        default:
            return 0xFFFFFFFF;
    }

    return style;
}

/******************************************************************
 * FUNCTION:    fontGetStyleFromName
 *
 * PURPOSE:
 *              get the style from the font's name
 *
 * PARAMETERS
 *    Input:    T_CONST T_BYTE * --- the style of font
 *    Output:
 *    InOut:
 *
 * Return value:T_UWORD --- the valued used by GUI
 * Reentrant :  No
 *****************************************************************/
T_UWORD fontGetStyleFromName(T_CONST T_BYTE *name)
{
    T_WORD i;
    T_CONST T_BYTE *style_part = name;

    for(i = 0; i < NR_LOOP_FOR_STYLE; i++)
	{
        if((style_part = strchr(style_part, '-')) == NULL)
            return 0xFFFFFFFF;

        if(*(++style_part) == '\0')
            return 0xFFFFFFFF;
    }

    return fnFNT_ConvertStyle(style_part);
}

/******************************************************************
 * FUNCTION:    fontGetWidthFromName
 *
 * PURPOSE:
 *              get the width of a character  from the font's name
 *
 * PARAMETERS
 *    Input:    T_CONST T_BYTE * --- the name of font
 *    Output:
 *    InOut:
 *
 * Return value:
		        T_WORD --- the font's width
 * Reentrant :  No
 *****************************************************************/
T_WORD fontGetWidthFromName(T_CONST T_BYTE *name)
{
    T_WORD i;
    T_BYTE width[LEN_FONT_NAME + 1];
    T_CONST T_BYTE *width_part = name;

    for(i = 0; i < NR_LOOP_FOR_WIDTH; i++)
	{
        if((width_part = strchr(width_part, '-')) == NULL)
            return -1;

        if(*(++width_part) == '\0')
            return -1;
    }

    i = 0;
    while(width_part[i])
	{
        if(width_part[i] == '-')
		{
            width[i] = '\0';
            break;
        }

        width[i] = width_part[i];
        i++;
    }

    if(width_part[i] == '\0')
        return -1;

    return atoi(width);
}

/******************************************************************
 * FUNCTION:    fontGetHeightFromName
 *
 * PURPOSE:
 *              get the height of a character  from the font's name
 *
 * PARAMETERS
 *    Input:    T_CONST T_BYTE * --- the name of font
 *    Output:
 *    InOut:
 *
 * Return value:T_WORD --- the font's height
 * Reentrant :  No
 *****************************************************************/
T_WORD fontGetHeightFromName(T_CONST T_BYTE *name)
{
    T_WORD i;
    T_BYTE height[LEN_FONT_NAME + 1];
    T_CONST T_BYTE *height_part = name;

    for(i = 0; i < NR_LOOP_FOR_HEIGHT; i++)
	{
        if((height_part = strchr(height_part, '-')) == NULL)
            return -1;
        if(*(++height_part) == '\0')
            return -1;
    }

    i = 0;
    while(height_part[i])
	{
        if(height_part[i] == '-')
		{
            height[i] = '\0';
            break;
        }

        height[i] = height_part[i];
        i++;
    }

    if(height_part[i] == '\0')
        return -1;

    return atoi(height);
}

/******************************************************************
 * FUNCTION:    fontGetCharsetFromName
 *
 * PURPOSE:
 *              get the  charset  from the font's name
 *
 * PARAMETERS
 *    Input:    T_CONST T_BYTE * --- the name of charset
 *    Output:   T_BYTE * --- the name of charset
 *    InOut:
 *
 * Return value:T_BOOL --- if success then TRUE,else FALSE
 * Reentrant :  No
 *****************************************************************/
T_BOOL fontGetCharsetFromName(T_CONST T_BYTE *name, T_BYTE *charset)
{
    T_WORD i;
    T_BYTE *delim;
    T_CONST T_BYTE* charset_part = name;

    for(i = 0; i < NR_LOOP_FOR_CHARSET; i++)
	{
        if((charset_part = strchr(charset_part, '-')) == NULL)
            return FALSE;
        if(*(++charset_part) == '\0')
            return FALSE;
    }

    if((delim = strchr(charset_part, ',')))
	{
        T_WORD len;
        len = delim - charset_part;
        strncpy (charset, charset_part, len);
        charset[len] = '\0';
        return TRUE;
    }

    strncpy(charset, charset_part, LEN_FONT_NAME);
    charset[LEN_FONT_NAME] = '\0';
    return TRUE;
}


/******************************************************************
 * FUNCTION:    fontGetCompatibleCharsetFromName
 *
 * PURPOSE:
 *              get the compatible charset  from the font's name
 *
 * PARAMETERS
 *    Input:    T_CONST T_BYTE * --- the name of charset
 *    Output:   T_BYTE * --- the name of charset
 *    InOut:
 *
 * Return value:T_BOOL --- if success then TRUE,else FALSE
 * Reentrant :  No
 *****************************************************************/
T_BOOL fontGetCompatibleCharsetFromName(T_CONST T_BYTE *name, T_BYTE *charset)
{
    T_WORD i;
    T_CONST T_BYTE* charset_part = name;

    for(i = 0; i < NR_LOOP_FOR_CHARSET; i++)
	{
        if((charset_part = strchr(charset_part, '-')) == NULL)
            return FALSE;
        if(*(++charset_part) == '\0')
            return FALSE;
    }

    if((charset_part = strchr(charset_part, ',')) == NULL)
        return FALSE;

    if(*(++charset_part) == '\0')
        return FALSE;

    strncpy(charset, charset_part, LEN_FONT_NAME);
    charset[LEN_FONT_NAME] = '\0';
    return TRUE;
}