key.c

一款收款机C源代码！因为是几年前的代码了

         :  key logical code. ( 0 -- MaxKey_Cntr - 1 )
*---------------------------------------------------------------------------------------*/
word key_logi_get(const word *Key_Tabl, word code, word Tabl_Len)
{
   word i;
   for( i = 0; i < Tabl_Len; i ++ )
   {
      if ( code == Key_Tabl[i] )
         break;
   }
   if( i >= Tabl_Len )				/* If the code not in the table, return 0FFH */
      i = KEY_END;
   return ( i );
}
/*----------------------------------------------------------------------------*
*   可以通过按键的命令字查找任意按键的描述符
*   返回值是 Bold
*----------------------------------------------------------------------------*/
byte Get_All_Key_Desc(char *dst,byte Max_Len, word CMD)
{
    char *tmp_str;
    const char *Str_Desc_Key[MAX_MODI_KEY];
    byte BOLD = 0;
    byte len;
    byte i;
    byte id;
    word idx;
    
    memset(dst, 0x20, Max_Len);
    if((CMD >= KD_1)&&(CMD <= KD_0))
    {
        BOLD = Get_Key_Desc(dst, Max_Len, CMD, digit_code_table, Prn_Digit_code_Tabl, MAX_MODI_KEY);
    }
    else if(CMD <= KD_MODI_END)
    {   
        for(i = 0; i < MAX_MODI_KEY; i++)
            Str_Desc_Key[i] = Prn_Modify_Key_Tabl[i];
        BOLD = Get_Key_Desc(dst, Max_Len, CMD, Modify_Key_Tabl, Str_Desc_Key, MAX_MODI_KEY);
    }
    else if((CMD >= KD_DP_ST)&&(CMD <= KD_DP_END))
    {
        memcpy(dst,dept[CMD-KD_DP_ST].desc, MAX_DESC_LEN_EX);
        BOLD = dept[CMD-KD_DP_ST].desc[MAX_DESC_LEN_EX];
    }
    else if((CMD >= KD_DPLU_ST)&&(CMD <= KD_DPLU_END))
    {
        if(Dplu_Pluno[CMD-KD_DPLU_ST] == 0)
        {
            len = strlen(Str_DirectPLU);
            memcpy(dst, Str_DirectPLU, len);
            LongtoAsc(dst+len, (CMD-KD_DPLU_ST+1), 3);
            BOLD = 0;
        }
        else
        {
            memcpy(dst,plu[Dplu_Pluno[CMD-KD_DPLU_ST]-1].desc, MAX_DESC_LEN_EX);
            BOLD = plu[Dplu_Pluno[CMD-KD_DPLU_ST]-1].desc[MAX_DESC_LEN_EX];
        }
    }
    else if((CMD >= KD_FIXED_ST)&&(CMD <= KD_FIXED_END))
    {
        for(i = 0; i < MAX_FIXED_KEY; i++)
            Str_Desc_Key[i] = Prn_Fixed_Key_Table[i];
        BOLD = Get_Key_Desc(dst, Max_Len, CMD, Fixed_Key_Table, Str_Desc_Key, MAX_FIXED_KEY);
    }
    else if((CMD >= KD_RPT_ST)&&(CMD <= KD_RPT_END))
    {
        for(i = 0; i < MAX_RPT_KEY; i++)
            Str_Desc_Key[i] = Prn_Rpt_Key_Table[i];
        BOLD = Get_Key_Desc(dst, Max_Len, CMD, Rpt_Key_Table, Str_Desc_Key, MAX_RPT_KEY);
    }
    else if((CMD >= KD_DTABLE_ST) && (CMD <= KD_DTABLE_END))
    {
        memcpy(dst,table[CMD-KD_DTABLE_ST].desc, MAX_DESC_LEN);
        //BOLD = table[CMD-KD_DP_ST].desc[MAX_DESC_LEN_EX];
    }
    else if ((CMD >= KD_VIRTUAL_ST) && (CMD <= KD_VIRTUAL_END))
    {
        i = CMD-KD_VIRTUAL_ST;
        id = Vir_Key[i].id;
        idx = Vir_Key[i].idx;
        if (idx == VIRTUAL_KEY_IDX_NULL)
        {
            // Null key, not description
        }
        else
        {
            if (id == VIR_KEY_PLU)
            {
                memcpy(dst, plu[idx].desc, MAX_DESC_LEN_EX);
                BOLD = plu[idx].desc[MAX_DESC_LEN_EX];
            }
            else if (id == VIR_KEY_CM)
            {
                len = strlen(KP_Sfx_Desc[idx]);
                if (len > MAX_BTN_DESC_LEN)
                    len = MAX_BTN_DESC_LEN;
                memcpy(dst, KP_Sfx_Desc[idx], len);
                //BOLD
            }
        }
    }
    else if ( (CMD >= KD_WAITER_ST) && (CMD <= KD_WAITER_END) )
    {
        memcpy(dst, waiter[CMD-KD_WAITER_ST].desc, MAX_DESC_LEN);
        //BOLD
    }
    
    return BOLD;
}

/*----------------------------------------------------------------------------*
*   通过按键的命令字在相应的按键汇总表中查找按键的描述符
*   返回值为BOLD
*----------------------------------------------------------------------------*/
byte Get_Key_Desc(char *dst,byte Max_Len, word CMD, const word *Key_Tabl, const char **Key_Desc_Tabl, word Tabl_Len)
{
    word i;
    byte lenth;

    memset(dst, 0x20, Max_Len);
    i = key_logi_get(Key_Tabl, CMD, Tabl_Len);
    
    if(i != KEY_END)
    {
        lenth = strlen(Key_Desc_Tabl[i]);
        lenth = (lenth > Max_Len)? Max_Len : lenth;
        memcpy(dst, Key_Desc_Tabl[i], lenth);
    }
    return 0;
}
/*
flag == 0: fill color
flag == 1: font_color
*/
byte Get_All_Key_Color(word CMD, byte flag)
{
    byte color = GRAY;
    word idx;
    if(CMD <= KD_0)
    {
        if(flag == 0)
            color = GRAY;
        else
            color = BLACK;
    }
    else if(CMD <= KD_MODI_END)
    {
            color = Get_Key_Color(CMD,Modify_Key_Tabl, Modify_Key_Color_Tabl, MAX_MODI_KEY);
        if(flag)
        {
            if((CMD == KD_D0)||(CMD == KD_T0)||(CMD == KD_DEC))
                color = BLACK;
            else
                color = ~color;
        }
    }
    else if((CMD >= KD_DP_ST)&&(CMD <= KD_DP_END))
    {
        if(flag == 0)
            color = dept[CMD-KD_DP_ST].fill_color;
        else
            color = dept[CMD-KD_DP_ST].font_color;    
    }
    else if((CMD >= KD_DPLU_ST)&&(CMD <= KD_DPLU_END))
    {
        if(Dplu_Pluno[CMD-KD_DPLU_ST] == 0)
        {
            if(flag == 0)
                color = DARKCYAN;
            else
                color = WHITE;
        }
        else
        {
            if(flag == 0)
                color = plu[Dplu_Pluno[CMD-KD_DPLU_ST]].fill_color;
            else
                color = plu[Dplu_Pluno[CMD-KD_DPLU_ST]].font_color;   
        }
    }
    else if((CMD >= KD_FIXED_ST)&&(CMD <= KD_FIXED_END))
    {
        color = Get_Key_Color(CMD, Fixed_Key_Table, Fixed_Key_Color_Table, MAX_FIXED_KEY);
        if(flag)
            color = ~color;
    }
    else if((CMD >= KD_RPT_ST)&&(CMD <= KD_RPT_END))
    {
        color = Get_Key_Color(CMD, Rpt_Key_Table, Rpt_Key_Color_Table, MAX_FIXED_KEY);
        if(flag)
            color = ~color;
    }
    else if((CMD >= KD_DTABLE_ST)&&(CMD <= KD_DTABLE_END))
    {
        if(flag == 0)
            color = table[CMD-KD_DTABLE_ST].fill_color;
        else
            color = table[CMD-KD_DTABLE_ST].font_color;    
    }
    else if((CMD >= KD_VIRTUAL_ST)&&(CMD <= KD_VIRTUAL_END))
    {
        idx = Vir_Key[CMD-KD_VIRTUAL_ST].idx;
        if (idx == VIRTUAL_KEY_IDX_NULL)
        {
            color = NULL_KEY_COLOR;     /* Read the null key color */
        }
        else
        {
            if(flag == 0)
                color = Vir_Key[CMD-KD_VIRTUAL_ST].fill_color;
            else
                color = Vir_Key[CMD-KD_VIRTUAL_ST].font_color;    
        }
    }
    else if ( (CMD >= KD_WAITER_ST) && (CMD <= KD_WAITER_END) )
    {
        if (flag == 0)
            color = WAITER_FILL_COLOR;
        else
            color = WAITER_FONT_COLOR;
    }

    return color;
}
/*----------------------------------------------------------------------------*
*   通过按键的命令字在相应的按键汇总表中查找按键的底色
*----------------------------------------------------------------------------*/
byte Get_Key_Color(word CMD, const word *Key_Tabl, const byte *Key_color_Tabl, word Tabl_Len)
{
    word i;
    i = key_logi_get(Key_Tabl, CMD, Tabl_Len);
    if(i == KEY_END)
        return GRAY;
    else
        return Key_color_Tabl[i];
}
/*-------------------------------------------------------------------------------------
*   初始化按键键盘布局
*   相对键盘重定义功能而言, 只针对销售状态下的键盘重定义. 
*   因此初始化部分也只针对销售部分的键盘列表
*   Flag == 0: Sale Main Keyboard
*   Flag == 1: Hard PLU Keyboard
*   Flag == 2: POS 键盘
*     保留flag标志的其他值.
*------------------------------------------------------------------------------------*/
void key_matrx_init(byte flag)
{
    word i;
    word *pp1;
    word *pp2;
    word Max_Key;

    if (flag == 0)
    {
   	    pp1 = (word *)Ts_KeyMap_Sale_Main;
        pp2 = FF_Key_SaleMain_Tabl;
        Max_Key = MAX_LAYOUT_KEY;
    }
    else if(flag == 1)
    {
   	    pp1 = (word *)Ts_KeyMap_Hardplu;
        pp2 = FF_Key_HardPLU_Tabl;
        Max_Key = MAX_LAYOUT_KEY;
    }
    else //POS 键盘
    {
        pp1 = (word *)Dft_POS_Key_Tabl;
        pp2 = FF_Key_Tabl;
        Max_Key = MAX_EXTEND_KEY;
    }
    
    for ( i = 0; i < Max_Key; i ++ )
        *pp2 ++ = *pp1 ++;

    if(flag == 0)
    {
        if(sysflag->soft_lock_flag == 1)				/* Use the soft control lock mode */
   	        Modi_Key(2, KD_MODE, flag);
    }
    else if(flag == 2)
    {
        PS2_GetFeedCode();
    }

}


/*----------------------------------------------------------------------------*
*   Initital the free function temporary key table
*   将修改过的按键布局保存到当前正在使用的键盘阵列中
*----------------------------------------------------------------------------*/
void  FF_Tmpkey_Init(byte flag)
{
    word i;
    word *pp1;
    word *pp2;
    word Max_Key;
   
    if (flag == 0)
    {
        pp1 = FF_Key_SaleMain_Tabl;
        Max_Key = MAX_LAYOUT_KEY;
    }
    else if(flag == 1)
    {
        pp1 = FF_Key_HardPLU_Tabl;
        Max_Key = MAX_LAYOUT_KEY;
    }
    else //if(flag == 2)
    {
        pp1 = FF_Key_Tabl;
        Max_Key = MAX_EXTEND_KEY;
    }
    
   pp2 = Tmp_Key_Tab;
   
   for ( i = 0; i < Max_Key; i ++ )
      *pp2 ++ = *pp1 ++;
}
void Update_DPPLU_Key(word Idx, byte flag)
{
    byte i; 
    word Cmd;

    if(flag == PLU)
    {
        Cmd = KD_DPLU_ST;
    }
    else if(flag == DEPT)
    {
        Cmd = KD_DP_ST + Idx;
    }
    else
        return;
    for(i = 0; i < MAX_LAYOUT_KEY; i++)
    {
        
    }
}
/*--------------------------------------------------------------------------------------
*  According to the logical key code, get the free Funcation key code.
*  当前只用于返回 POS 键盘的按键值
*-------------------------------------------------------------------------------------*/
word FF_Key_Get(word key_code )