mfw_mmi.c

是一个手机功能的模拟程序

/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_mmi.c       $|
| $Author: root $ CONDAT GmbH           $Revision: 1.1.1.1 $|
| CREATED: 21.09.98                     $Modtime:: 1.07.99 10:03    $|
| STATE  : code                                                      |
+--------------------------------------------------------------------+

   MODULE  : MFW_MMI

   PURPOSE : MFW test application

   EXPORT  :

   TO DO   :

   $History:: mfw_mmi.c                                             $
 *
 * *****************  Version 8  *****************
 * User: Es           Date: 6.07.99    Time: 12:21
 * Updated in $/GSM/DEV/MS/SRC/MFW
*/

#define ENTITY_MFW

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#if defined (NEW_FRAME)

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#else

#include "stddefs.h"
#include "custom.h"
#include "gsm.h"
#include "vsi.h"

#endif

#include "mfw_mfw.h"
#include "mfw_sys.h"
#include "mfw_win.h"
#include "mfw_edt.h"
#include "mfw_icn.h"
#include "mfw_mnu.h"
#include "mfw_kbd.h"
#include "mfw_tim.h"
#include "dspl.h"
#include "drv_key.h"
#include "drv_tmr.h"

#include "pcm.h"

#include "mfw_nm.h"
#include "mfw_sim.h"
#include "mfw_cm.h"

#include "mfw_mmi.h"



static U16 scrX, scrY;                  /* sreen size               */
static U8 mfwMem [2048];                /* mfw memory pool          */
//Default colour 
#define MFW_COLOUR			0x00000000,0x00FFFFFF
#define MFW_ICN_COLOUR		0x00000000,0x00FFFFFF

static int initialized = 0;

static void volInit (void);
static void volExit (void);
static void editInit (MfwHnd e);
static void editExit (void);
static void phoneInit (void);
static void phoneExit (void);
static void mainInit (void);
static void mainExit (void);




/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_MMI            |
| STATE   : code                        ROUTINE : mmi_main           |
+--------------------------------------------------------------------+

  PURPOSE : start MMI

*/

void mmi_main (void)
{
    mmiInit();
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_MMI            |
| STATE   : code                        ROUTINE : mmiInit            |
+--------------------------------------------------------------------+

  PURPOSE : initialize application

*/

void mmiInit (void)
{
    if (initialized)
        mmiExit();

    initialized = 1;

    mfwInit(mfwMem,sizeof(mfwMem));     /* MFW INITIALIZATION       */
    winInit(&scrX,&scrY);               /* init window handler      */
    edtInit();                          /* init editor handler      */
    icnInit();                          /* init icon handler        */
    mnuInit();                          /* init menu handler        */
    kbdInit();                          /* init keyboard handler    */
    timInit();                          /* init timer handler       */

                                        /* MMI MODULES SETUP        */
    volInit();                          /* init volume control      */
    mainInit();                         /* init main control        */
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_MMI            |
| STATE   : code                        ROUTINE : mmiExit            |
+--------------------------------------------------------------------+

  PURPOSE : exit application

*/

void mmiExit (void)
{
    if (!initialized)
        return;

    mainExit();
    volExit();

    timExit();                          /* finit timer handler      */
    kbdExit();                          /* finit keyboard handler   */
    mnuExit();                          /* finit menu handler       */
    icnExit();                          /* finit icon handler       */
    edtExit();                          /* finit edit handler       */
    winExit();                          /* finit window handler     */
    mfwExit();                          /* exit mfw                 */

    initialized = 0;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_MMI            |
| STATE   : code                        ROUTINE : volControl         |
+--------------------------------------------------------------------+

  PURPOSE : setup volume control

*/

#define MAX_VOLUME 10

static MfwHnd volWin;                   /* the volume window        */
static MfwHnd volKbd;                   /* the volume keyboard      */
static MfwHnd volTim;                   /* the volume timer         */
static int curVolume;                   /* current volume           */
static U32 curKey;                      /* current key              */

static void volShow (void)
{
    timStop(volTim);
    dspl_ClearAll();
    dspl_TextOut(20,12,DSPL_TXTATTR_NORMAL,"VOLUME");
    dspl_DrawRect(20,22,20+curVolume*6,22+5);
}

static int volEventWin (MfwEvt e, MfwWin *w)
{
    switch (e)
    {
        case MfwWinVisible:
            if (w->flags & MfwWinVisible)
                volShow();
            break;
        default:
            return 0;
    }

    return 1;
}

static int volEventKbd (MfwEvt e, MfwKbd *kc)
{
    curKey = e;
    volShow();
    if (curKey & KEY_MAKE)
        ((MfwTim *) mfwControl(volTim))->time = 500;
    else
        ((MfwTim *) mfwControl(volTim))->time = 2000;
    timStart(volTim);

    return 1;
}

static int volEventTim (MfwEvt e, MfwTim *tc)
{
    if (!(curKey & KEY_MAKE))
    {
        winHide(volWin);
        return 1;
    }

    if (curKey & KEY_VOLUP)
    {
        if (curVolume < MAX_VOLUME)
            curVolume++;
    }
    else
    {
        if (curVolume > 0)
            curVolume--;
    }
    volShow();
    timStart(volTim);

    return 1;
}

static void volInit (void)
{
    U32 events;

    events = KEY_VOLUP + KEY_VOLDOWN + KEY_MAKE;
    curVolume = 3;
    volWin = winCreate(0,0,MfwWinVisible,(MfwCb) volEventWin);
    volKbd = kbdCreate(0,events,(MfwCb) volEventKbd);
    volTim = timCreate(0,2000,(MfwCb) volEventTim);
}

static void volExit (void)
{
    timDelete(volTim);
    kbdDelete(volKbd);
    winDelete(volWin);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_MMI            |
| STATE   : code                        ROUTINE : editControl        |
+--------------------------------------------------------------------+

  PURPOSE : general editor control

*/

static MfwHnd myHandle = 0;             /* editors handle           */
static MfwHnd editTim;                  /* the editor timer         */

static U8 editControls [KCD_MAX] =      /* edit control keys:       */
{
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    ecBack, ecDel, ecNone, ecNone, ecUp, ecDown, ecLeft, ecRight,
    ecNone, ecNone, ecEnter, ecNone, ecNone, ecNone,
    ecNone, ecNone, ecEnter, ecNone, ecNone, ecNone, ecNone
};

static char editHeader [128];           /* editor information       */
static U8 editAlphaMode;                /* alpha mode flag          */
static U8 editAlphaLevel;               /* alpha level selected     */
static U8 editAlphaKey;                 /* alpha mode current key   */
static U8 editAlpha [10][4] =           /* alpha mode characters    */
{
    {'-','!','?',','},
    {'a','b','c','1'}, {'d','e','f','2'}, {'g','h','i','3'},
    {'j','k','l','4'}, {'m','n','o','5'}, {'p','q','r','6'},
    {'s','t','u','7'}, {'v','w','x','8'}, {'y','z',' ','9'}
};


static void editShowHeader (void)
{
    sprintf(editHeader,"%c [%c]",
        (editAlphaMode)?'A':'N',
        (editAlphaMode && editAlphaKey != KCD_MAX)?
            editAlpha[editAlphaKey][editAlphaLevel]:' ');
    dspl_TextOut(2,0,DSPL_TXTATTR_NORMAL,editHeader);
    dspl_DrawRect(1,8,98,30);
}

static int editEventTim (MfwEvt e, MfwTim *t)
{
    if (!editAlphaMode)
        return 1;

    edtChar(myHandle,editAlpha[editAlphaKey][editAlphaLevel]);
    editAlphaLevel = 3;
    editAlphaKey = KCD_MAX;

    return 1;
}

static int editEventKbd (MfwEvt e, MfwKbd *k)
{
    if (editAlphaMode)
    {
        if (editAlphaKey != KCD_MAX && editAlphaKey != k->code)
        {
            timStop(editTim);
            edtChar(myHandle,editAlpha[editAlphaKey][editAlphaLevel]);
            editAlphaLevel = 3;
            editAlphaKey = KCD_MAX;
        }
        if (k->code <= KCD_9)
        {
            editAlphaKey = k->code;
            editAlphaLevel++;
            if (editAlphaLevel > 3)
                editAlphaLevel = 0;
            editShowHeader();
            timStart(editTim);
            return 1;
        }
    }
    switch (k->code)
    {
        case KCD_CLEAR:
            return 0;
        case KCD_ABC:
            editAlphaMode = (U8) !editAlphaMode;
            if (editAlphaMode)
            {
                editAlphaLevel = 3;
                editAlphaKey = KCD_MAX;
            }
            editShowHeader();
            return 1;
        default:
            break;
    }
    edtChar(myHandle,editControls[k->code]);

    return 1;
}

static void editInit (MfwHnd e)
{
    myHandle = e;
    editTim = timCreate(0,1000,(MfwCb) editEventTim);

    editAlphaLevel = 3;
    editAlphaKey = KCD_MAX;
}

static void editExit (void)
{
    myHandle = 0;
    timDelete(editTim);
}