/*******************************************************************************

                    CONDAT (UK)

********************************************************************************

 This software product is the property of Condat (UK) Ltd and may not be
 disclosed to any third party without the express permission of the owner.

********************************************************************************

 $Project name: Basic MMI
 $Project code: BMI (6349)
 $Module:       MmiDialogs
 $File:         MmiDialogs.c
 $Revision:     1.0

 $Author:       Condat(UK)
 $Date:         25/10/00

********************************************************************************

 Description:MMI Information dialogue handling.


********************************************************************************

 $History: MmiDialogs.c

    May 23, 2007    DR: OMAPS00127483  x0pleela
    Description:   Phonelock - Unable to unlock the phone during incoming call with ringer...
    Solution: Made changes in the function dialog_info_win_resize_cb() to restart the ringer set for
            incoming call or alarm after thr phone is unlocked.

    Apr 03, 2007    ER: OMAPS00122561  x0pleela
    Description:   [ACI] Phone lock feature has to be supported by ACI
    Solution: Phone Lock ER implementation

    x0066814 06 Dec 2006, OMAPS00106825
    The window height calculation related to wrapping should be skipped when no
    string wrapping is done

    Mar 11, 2006   REF:DR:OMAPS00061467  x0035544
    Description:   27.22.4.13.3 SET UP CALL (display of icons) fails.
    Solution: Assigned the default values for icon data  for the structure display_info in the function
    dlg_zeroDisplayData(). copied icon data in to the structure data->IconData and provided functionality
    in the function dialog_info_win_resize_cb() to display icon data appropriately on the dialog screen for SAT
    call setup.

       Sep 06 2005  REF:  MMI-SPR-33548  x0012849 Jagan
       Description : A dialog  with long message  is not displayed properly.
       Solution : The no of lines in a dialog is increased from 4 to 15.

    Feb 24, 2005 REF: CRR MMI-SPR-29102 xnkulkar
       Description: The phone resets when user presses the ''End All' key while the SMSs are being deleted.
       Solution: As the user has already confirmed that all SMS messages are to be deleted, ''End All' key
            press is ignored till the delete operation is over.
            xrashmic 08 Feb, 2005 MMI-SPR-27853
       Moved the T_dialog_info structure from MmiDialogs.c to MmiDialogs.h


       xrashmic 08 Feb, 2005 MMI-SPR-27853
       Moved the T_dialog_info structure from MmiDialogs.c to MmiDialogs.h

    Aug 25, 2004    REF: CRR 24904   Deepa M.D
    Bug:cleanup compile switches used for Go-lite
    Fix:COLOURDISPLAY compiler switch has been added to the functions which are
    used only for the normal color build.

    Aug 16, 2004    REF: CRR 24323   Deepa M.D
    Bug:Clenup of sprintf used for tracing
    Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX


    Sep 01, 2004    REF: CRR 21380  Deepa M.D
    Bug:Not getting proper display, When Messages Memory is Full.
    Fix:Assigning TextId and TextString will not display both the messages.
    Hence we need to use TextId and TextString2 or TextId2 and TextString

    Jun 04,2004 CRR:13601 xpradipg - SASKEN
    Description: CFO interrogation display : Timer to long
    Fix: Timer is enabled for the information dialog. It times out after 5 seconds from the last key
    press.
    25/10/00            Original Condat(UK) BMI version.

 $End

*******************************************************************************/


/*******************************************************************************

                                Include Files

*******************************************************************************/
#define ENTITY_MFW

/* includes */
#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_win.h"
#include "mfw_kbd.h"
/* SPR#1428 - SH - New Editor changes */
#ifndef NEW_EDITOR
#include "mfw_edt.h"
#endif
#include "mfw_tim.h"
#include "mfw_phb.h"
#include "mfw_sms.h"
#include "mfw_icn.h"
#include "mfw_mnu.h"
#include "mfw_lng.h"
#include "mfw_sat.h"
#include "mfw_mme.h"
#include "mfw_nm.h"

#include "dspl.h"

#include "ksd.h"
#include "psa.h"

#include "MmiMain.h"
#include "MmiDummy.h"
//JVJE #include "MmiMsgsEdit.h"
//#include "MmiLists.h"
#include "MmiMmi.h"

#include "MmiDialogs.h"
#include "MmiLists.h"
#include "MmiMenu.h"
#include "MmiSoftKeys.h"

/* JF Modified
*/
#include "MmiBookController.h"
#include "cus_aci.h"

#include "prim.h"
#ifndef PCM_2_FFS
#include "pcm.h"
#endif

#include "mmiColours.h"

void dlg_initDisplayData_type( T_DISPLAY_DATA *displayInfo, U32 displayCol, int dlgType, T_BITMAP* dlgBitmap , int dlgSKFormat );

/*
 * START NEW PART
 */

static T_MFW_HND   dialog_info_create    (T_MFW_HND  parent_win);
static void        dialog_info           (T_MFW_HND  win,
                                          USHORT event, SHORT value, void * parameter);

/* x0039928 - Lint warning fix
static int         dialog_info_win_cb    (T_MFW_EVENT event, T_MFW_WIN * win); */
static int  dialog_info_win_resize_cb (T_MFW_EVENT event, T_MFW_WIN * win);

static T_MFW_CB    dialog_info_tim_cb    (T_MFW_EVENT event, T_MFW_TIM * tc);
static int         dialog_info_kbd_cb    (T_MFW_EVENT event, T_MFW_KBD * keyboard);
static int         dialog_info_kbd_long_cb (T_MFW_EVENT event, T_MFW_KBD * keyboard);
void mmi_dialogs_insert_animation_CB (T_MFW_EVENT event, T_MFW_TIM *tc);
void mmi_dialogs_animation_new_CB (T_MFW_EVENT event, T_MFW_TIM *tc);


MfwRect calcLayout( int dlgType, int dataSx, int dataSy, int bmpSx, int bmpSy)
{
    MfwRect area;
    int px,py;
    int sx =0,sy = 0;

    TRACE_EVENT_P5("dlgType,= %d, dataSx = %d, dataSy = %d, bmpSx = %d, bmpSy = %d", dlgType, dataSx, dataSy, bmpSx, bmpSy);

    /*Adjust area available for drawing by the border */
    switch (dlgType & DLG_BORDER_VERTICAL)
    {
        case DLG_BORDER_VERTICAL_0: sx =bmpSx;          break;
        case DLG_BORDER_VERTICAL_1: sx =bmpSx*6/8;      break;
        case DLG_BORDER_VERTICAL_2: sx =bmpSx*4/8;      break;
        case DLG_BORDER_VERTICAL_3: sx =bmpSx*3/8;      break;
    }
    if (sx < dataSx)
        sx = dataSx;
    px = 0;

    switch (dlgType & DLG_BORDER_HORIZONTAL)
    {
        case DLG_BORDER_HORIZONTAL_0:   sy =bmpSy;          break;
        case DLG_BORDER_HORIZONTAL_1:   sy =bmpSy*6/8;      break;
        case DLG_BORDER_HORIZONTAL_2:   sy =bmpSy*4/8;      break;
        case DLG_BORDER_HORIZONTAL_3:   sy =bmpSy*3/8;      break;
    }
    if (sy < dataSy)
        sy = dataSy;
    py = 0;

    switch (dlgType & (DLG_INFO_LAYOUT_LEFT | DLG_INFO_LAYOUT_RIGHT))
    {
        case DLG_INFO_LAYOUT_CENTRE:    //display info in centre of display
            px = px + (sx-dataSx)/2;
            sx = dataSx;
            break;
        case DLG_INFO_LAYOUT_RIGHT: //all info is displayed at the foot of trhe display
            px = px+(sx-dataSx);
            sx = dataSx;
            break;
        case DLG_INFO_LAYOUT_LEFT:      //display all info at the top of the bitmap
            sx = dataSx;
            break;
        default:                        //display info over entire area
            break;
    }

    switch (dlgType & (DLG_INFO_LAYOUT_BOTTOM   | DLG_INFO_LAYOUT_TOP))
    {
        case DLG_INFO_LAYOUT_CENTRE:                            //display info in centre of display
            py = py + (sy-dataSy)/2;
            sy = dataSy;
            break;
        case DLG_INFO_LAYOUT_BOTTOM:    //all info is displayed at the foot of trhe display
            py = py+(sy-dataSy);
            sy = dataSy;
            break;
        case DLG_INFO_LAYOUT_TOP:       //display all info at the top of the bitmap
            sy = dataSy;
            break;
        default:                        //display info over entire area
            break;
    }
    area.px = px;   area.py = py;
    area.sx = sx;   area.sy = sy;   //Area sx/sy must be no smaller than dataSx/Sy
    return (area);
}


/*******************************************************************************

 $Function:     info_dialog

 $Description:  Common information dialog

 $Returns:      Dialogue info win

 $Arguments:    parent win, display info

*******************************************************************************/
T_MFW_HND info_dialog (T_MFW_HND        parent_win,
                       T_DISPLAY_DATA * display_info)
{
  T_MFW_HND win;
  TRACE_FUNCTION("info_dialog()");
  display_info->SoftKeyStrings = FALSE;

  win = dialog_info_create (parent_win);

  if (win NEQ NULL)
  {
    SEND_EVENT (win, DIALOG_INIT, 0, display_info);
  }
  return win;
}


/*******************************************************************************

 $Function:     info_dialog_softkeystrings

 $Description:  Common information dialog, sets "softkeystrings" to TRUE

 $Returns:      Dialogue info win

 $Arguments:    parent win, display info, leftsoftkey, rightsoftkey

*******************************************************************************/
T_MFW_HND info_dialog_softkeystrings (T_MFW_HND parent_win, T_DISPLAY_DATA * display_info)
{
  T_MFW_HND win;

  display_info->SoftKeyStrings = TRUE;
  win = dialog_info_create (parent_win);

  if (win NEQ NULL)
  {
    SEND_EVENT (win, DIALOG_INIT, 0, display_info);
  }
  return win;
}


/*******************************************************************************

 $Function:     dialog_info_create

 $Description:  Creation of an information dialog

 $Returns:      Dialogue info win

 $Arguments:    parent win

*******************************************************************************/
static T_MFW_HND dialog_info_create (T_MFW_HND parent_win)
{
  T_MFW_WIN     * win_data;
  T_dialog_info *  data = (T_dialog_info *)ALLOC_MEMORY (sizeof (T_dialog_info));
  TRACE_FUNCTION ("dialog_info_create()");

  data->info_win = win_create (parent_win, 0, E_WIN_VISIBLE
                            , (T_MFW_CB)dialog_info_win_resize_cb);

  if (data->info_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  data->mmi_control.dialog   = (T_DIALOG_FUNC)dialog_info;
  data->mmi_control.data     = data;
  data->parent_win           = parent_win;
  win_data                   = ((T_MFW_HDR *)data->info_win)->data;
  win_data->user             = (void *)data;

  /*
   * return window handle
   */
  return data->info_win;
}


/*******************************************************************************

 $Function:     dialog_info_destroy

 $Description:  Destruction of an information dialog

 $Returns:      void

 $Arguments:    win

*******************************************************************************/
void dialog_info_destroy (T_MFW_HND own_window)
{
  T_MFW_WIN     * win  = ((T_MFW_HDR *)own_window)->data;
  T_dialog_info * data = (T_dialog_info *)win->user;

  TRACE_FUNCTION ("dialog_info_destroy()");

  if (own_window == NULL)
  {
    TRACE_EVENT ("Error :- Called with NULL Pointer");
    return;
  }

  if (data)
  {
    /*
     * Exit TIMER & KEYBOARD Handle
     */
    kbd_delete (data->info_kbd);
    tim_delete (data->info_tim);

    if(data->animation_timer != 0)
    {
        timDelete(data->animation_timer);

        if (data->icon != 0)
            icnDelete(data->icon);
    }

    /*
     * Delete WIN Handler
     */
    win_delete (data->info_win);
    /*
     * Free Memory
     */
    FREE_MEMORY ((void *)data, sizeof (T_dialog_info));
  }
}

void dlg_zeroDisplayData( T_DISPLAY_DATA *displayInfo)
{
    TRACE_EVENT("dlg_zeroDisplayData()");
    if (displayInfo == NULL)
        return;
    memset (displayInfo, 0x00, sizeof(T_DISPLAY_DATA));

    displayInfo->LeftSoftKey    = 0;
    displayInfo->RightSoftKey   = 0;
    displayInfo->LSKString      = NULL;
    displayInfo->RSKString      = NULL;
    displayInfo->TextString     = NULL;
    displayInfo->TextString2    = NULL;

    displayInfo->WrapStrings    = 0;

    displayInfo->TextId         = 0;
    displayInfo->TextId2        = 0;

    displayInfo->SoftKeyStrings = FALSE;

    displayInfo->Identifier     = 0;
    displayInfo->anim_time      = 0;
    displayInfo->number_of_frames   = 0;
    displayInfo->current_frame      = 0;
//x0035544 Feb 07, 2006 DR:OMAPS00061467
#ifdef FF_MMI_SAT_ICON
    displayInfo->IconData.width  = 0;
    displayInfo->IconData.height = 0;
    displayInfo->IconData.dst    = NULL;
    displayInfo->IconData.selfExplanatory = FALSE;
#endif
    dlg_initDisplayData_events( displayInfo, NULL, 0, 0);

    /* GW#2294 COLOUR_STATUS has been used for all popups - change this to default instead of COLOUR_POPUP .*/
    dlg_initDisplayData_type( displayInfo, COLOUR_STATUS, 0, NULL, 0 );

    /* GW #2294 02/07/03 - The default bitmap is set-up here to allow us to disable it for some dialogs (if required) */
    displayInfo->bgdBitmap = icon_getBgdBitmap(BGD_CLOUD);
}

void dlg_initDisplayData_TextId( T_DISPLAY_DATA *displayInfo, int lsk, int rsk, int str1, int str2, int colId)
{
    if (displayInfo == NULL)
        return;
    dlg_zeroDisplayData(displayInfo);
    displayInfo->LeftSoftKey    = (USHORT)lsk;
    displayInfo->RightSoftKey   = (USHORT)rsk;
    displayInfo->TextId         = str1;
    displayInfo->TextId2        = str2;
    displayInfo->displayCol     = colId ;
}

void dlg_initDisplayData_TextStr( T_DISPLAY_DATA *displayInfo, int lsk, int rsk,char *str1, char *str2, int colId)
{
    if (displayInfo == NULL)
        return;
    dlg_zeroDisplayData(displayInfo);
    displayInfo->LeftSoftKey    = (USHORT)lsk;
    displayInfo->RightSoftKey   = (USHORT)rsk;
    displayInfo->TextString     = str1;
    displayInfo->TextString2    = str2;
    displayInfo->displayCol     = colId ;
}

void dlg_initDisplayData_events( T_DISPLAY_DATA *displayInfo, T_VOID_FUNC callback, int timer, T_MFW_EVENT keyEvents)
{
    displayInfo->Callback       = callback;
    displayInfo->Time           = timer;
    displayInfo->KeyEvents      = keyEvents;
}

void dlg_initDisplayData_type( T_DISPLAY_DATA *displayInfo, U32 displayCol, int dlgType, T_BITMAP* dlgBitmap, int dlgSkFormat )
{
    displayInfo->displayCol = displayCol;
    displayInfo->dlgType    = dlgType;
    displayInfo->bgdBitmap  = dlgBitmap;
}

/*******************************************************************************

 $Function:     dialog_info

 $Description:  Dialog function for information dialog

 $Returns:      void

 $Arguments:    win, window handle event, value, parameter

*******************************************************************************/
static void dialog_info (T_MFW_HND win, USHORT event, SHORT value,
			 void * parameter)
{
  T_MFW_WIN      * win_data     = ((T_MFW_HDR *)win)->data;
  T_dialog_info  * data         = (T_dialog_info *)win_data->user;
  T_DISPLAY_DATA * display_info = (T_DISPLAY_DATA *)parameter;
  TRACE_FUNCTION ("dialog_info()");

  switch (event)
  {
    case DIALOG_INIT:
      /*
       * Initialize dialog
       */
#if defined (WIN32)
      {
          /***************************Go-lite Optimization changes Start***********************/

          //Aug 16, 2004    REF: CRR 24323   Deepa M.D
          TRACE_EVENT_P1( "Identifier %d", display_info->Identifier);
          /***************************Go-lite Optimization changes end***********************/

      }
#endif
      /*
       * Create timer and keyboard handler
       */
    data->info_tim             = tim_create (win, display_info->Time, (T_MFW_CB)dialog_info_tim_cb);
    data->info_kbd             = kbd_create (win, KEY_ALL, (T_MFW_CB)dialog_info_kbd_cb);
    data->info_kbd_long = kbd_create(win,KEY_ALL|KEY_LONG,(MfwCb)dialog_info_kbd_long_cb);

      /*
       * Store any other data
       */
      data->KeyEvents            = display_info->KeyEvents;
      data->TextString           = display_info->TextString;
      data->LeftSoftKey          = display_info->LeftSoftKey;
      data->RightSoftKey         = display_info->RightSoftKey;
      data->SoftKeyStrings      = display_info->SoftKeyStrings; // SH - TRUE if using strings rather than IDs
      data->LSKString           = display_info->LSKString;      // Text for left soft key
      data->RSKString           = display_info->RSKString;      // Text for right soft key
      data->TextId               = display_info->TextId;
      data->Identifier           = display_info->Identifier;
      data->Callback             = display_info->Callback;
      data->TextString2          = display_info->TextString2;
      data->TextId2              = display_info->TextId2;
      data->WrapStrings         = display_info->WrapStrings;    //GW-SPR#762

      data->dlgCol              = display_info->displayCol;
      data->dlgType             = display_info->dlgType;
      data->dlgBgdBitmap        = display_info->bgdBitmap;
      data->dlgSkFormat         = 0;
      data->current_frame       = display_info->current_frame;
      data->number_of_frames    = display_info->number_of_frames;
      data->icon_array          = (MfwIcnAttr*)display_info->icon_array;
      data->animation_timer     = 0;
//x0035544 Feb 07, 2006 DR:OMAPS00061467
#ifdef FF_MMI_SAT_ICON
     if(display_info->IconData.dst != NULL)
    {
         data->IconData.width       = display_info->IconData.width;
         data->IconData.height  = display_info->IconData.height;
         data->IconData.dst     = display_info->IconData.dst;
      data->IconData.selfExplanatory    = display_info->IconData.selfExplanatory;
    }
    else
    {
      data->IconData.dst = NULL;
      data->IconData.selfExplanatory = FALSE;
      data->IconData.width =0;
      data->IconData.height =0;
       }
#endif

      TRACE_EVENT_P1("anim_time = %d", display_info->anim_time);
      TRACE_EVENT_P1("data->anim_time = %d", data->anim_time);
      if (display_info->anim_time != 0)
      {
        data->animation_timer = timCreate(win,display_info->anim_time,(MfwCb)mmi_dialogs_animation_new_CB);
        timStart(data->animation_timer);
      }

      if (display_info->Time NEQ FOREVER)
        tim_start (data->info_tim);
      win_show (win);

      mme_backlightOnEvent();
      break;

    case DIALOG_DESTROY:
        dialog_info_destroy(win);
    break;
  }
}


/*******************************************************************************

 $Function:     dialog_info_win_cb

 $Description:  Callback function for information dialog

 $Returns:      void

 $Arguments:    window handle event, win

GW SPR#2294 02/07/03 -  Removed Unicode specific code as the 'display' routines called to calculate
                the string length and output the text should correctly handle the 0x80 unicode tag
                at the start.
                Modified the display code to wrap the text in the second text string.
                Modified the window drawing code so that if the text will not fit in the dialog box
                with the background bitmap, a pop-up 'box' will be drawn instead. If this will still
                not be large enough, the entire screen is used.
                For the C-sample, there is no bitmap.
                Modified the code to use an array of values to position the text output.
GW SPR#2294 08/07/03 - Added code to expand the dialog box to include the animation (if any).

*******************************************************************************/
// Allow 4 lines of text (0..3) for dialogs
// Sep 06 2005  REF:  MMI-SPR-33548  x0012849
// To display a dialog properly when it contain lengthy message - No of lines increased.
#define MAX_DLG_LINES   (15)
//Allow up to 40 chars of text on a dialog line
#define MAX_WRAP_CHAR  (42)
//Allow us to wrap text from line 2 to lines 2,3 and 4 lines
#define MAX_WRAP_LINES (MAX_DLG_LINES-1)

#define DLG_USE_BITMAP          0x0001      //use bitmap if present
#define DLG_USE_RECTANGLE       0x0002      //use a rectangle
#define DLG_USE_FULL_SCREEN     0x0004      //use full-screen

#define DLG_LINE1 0
#define DLG_LINE2 1

static int dialog_info_win_resize_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
    T_dialog_info * data = (T_dialog_info *)win->user;
//     T_DISPLAY_DATA * display_info;   // RAVI
    int xPos[MAX_DLG_LINES];
    int yPos[MAX_DLG_LINES];
    // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
    //The  size of array  str and strlen are increased by 1, so that the last elements holds data
    // which is used while wrapping the text.
    char* str[MAX_DLG_LINES+1];
    int strLen[MAX_DLG_LINES+1];
    int i;
    char* lskStr,*rskStr;
    int wx = 0;  //,wy,sx=0,sy=0; // RAVI
    int wy = 0;   // RAVI
    int sx = 0;     // RAVI
    int sy = 0;     // RAVI
    int fullScreen = DLG_USE_RECTANGLE;
    int yOfs;
    int yBmpOfs = 0;
    MfwRect skArea;
    //x0035544 Feb 15, 2006. DR:OMAPS00061467
#ifdef FF_MMI_SAT_ICON
    USHORT      titleIconWidth = 0;
#endif
    MfwRect area;
    int scrWidth = 0; //available width for the display // RAVI - Assignment to 0.
    // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
    // temp_ptr  is used  while wrapping the text.
    // Now str2[][] is not required.
    char *temp_ptr;
    int nChar;

    /* t_font_bitmap bmp; */ /* Warning  Removal - x0020906 - 24-08-2006 */
//  t_font_bitmap* bmpPtr = &bmp;  // RAVI - Not Referenced.

    int drawWinType;
    int nLines;

    int linePos=0;
    int lineLen = 0;
    int wrapLine = 0; /*GW #2294*/ // x0066814 06 Dec 2006, OMAPS00106825

    const int charWidth = dspl_GetTextExtent("0",1);
    TRACE_FUNCTION ("dialog_info_win_resize_cb()");


    memset(str,'\0',sizeof(str));  /* x0039928 - Lint warning fix */
    memset(strLen,0,sizeof(strLen));
//x0035544 Feb 15, 2006. DR:OMAPS00061467
#ifdef FF_MMI_SAT_ICON
    if (data->IconData.dst != NULL)
    {
        if (data->IconData.width > TITLE_ICON_WIDTH)
        {
            titleIconWidth = TITLE_ICON_WIDTH;
        }
        else
        {
            titleIconWidth = data->IconData.width ;
        }
    }
    else
    {
        titleIconWidth = 0;
    }

#endif
    if (data EQ 0)
	return 1;

    switch (event)
    {
    //x0pleela 15 May, 2007 DR: OMAPS00127483
    //Added the following code to handle ringer for incoming call and alarm in phone unlocked state.
    //the ringer for incoming call or alarm is restarted here after unlocking the phone.
    case E_WIN_RESUME:
        break;

    case E_WIN_VISIBLE:
        if (win->flags & E_WIN_VISIBLE)
        {
        TRACE_EVENT("dialog_info_win_resize_cb: E_WIN_VISIBLE");

            /*
             * Print the information dialog
             */
            for (i=0;i<MAX_DLG_LINES;i++)
            {
                xPos[i]=0;
                yPos[i] = Mmi_layout_line_height()*i;
                str[i]=NULL;
                strLen[i]=0;
            }
                // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
                // Assign the values to last elments of the array str and strLen
                str[MAX_DLG_LINES] = NULL;
                strLen[MAX_DLG_LINES] = 0;
            yOfs = Mmi_layout_line_height()/4;
            if (data->TextId != 0)
                str[DLG_LINE1] = MmiRsrcGetText(  data->TextId);
            else
                str[DLG_LINE1] = data->TextString;

            if (data->TextId2 != 0)
                str[DLG_LINE2] = MmiRsrcGetText(  data->TextId2);
                else
                str[DLG_LINE2] = data->TextString2;

            if (data->SoftKeyStrings!=0)
            {
                lskStr = data->LSKString;
                rskStr = data->RSKString;
            }
            else
            {
                if (data->LeftSoftKey != TxtNull)
                    lskStr = MmiRsrcGetText(data->LeftSoftKey);
                else
                    lskStr = NULL;

                if (data->RightSoftKey != TxtNull)
                    rskStr = MmiRsrcGetText(data->RightSoftKey);
                else
                    rskStr = NULL;
            }

            if ((str[DLG_LINE1]!= NULL) || (str[DLG_LINE2]!=NULL))
            {   //Draw a window for status info
                if (str[DLG_LINE2] == NULL)
                {
                    sy = Mmi_layout_line_height()+yOfs*2; // 18 or 12

                }
                else
                {
                    sy = Mmi_layout_line_height()*2+yOfs*3; // 33 or 22
                }

                //MC, if (Mmi_getCurrentLanguage() != CHINESE_LANGUAGE)
                {   //calculate longest string - use this to calc width of window
                    sx = 0;
                    if ((lskStr!=NULL) || (rskStr!=NULL))
                    {
                        sy = sy+Mmi_layout_softkeyHeight()+yOfs*2;
                        sx = sx + 10;
                        if (lskStr != NULL)
                        {
                            sx = sx + dspl_GetTextExtent(lskStr, 0);
                        }
                        if (rskStr != NULL)
                        {
                            sx = sx + dspl_GetTextExtent(rskStr,0);
                        }

                    }
                    for (i=DLG_LINE1;i<=DLG_LINE2;i++)
                    {
                        strLen[i] = dspl_GetTextExtent(str[i],0);
                    }

                    /* Work out the desired width of the dialog. If we can wrap line 2 and it is long, wrap it */
                    if (data->WrapStrings & WRAP_STRING_2)
                        nLines = MAX_WRAP_LINES;
                    else
                        nLines = 1;
#ifdef COLOURDISPLAY
                    if (data->dlgBgdBitmap!=NULL)
                    {
                        //we only have room to split line 2 into 'max_lines_dlg_popup' lines in the pop-up.
                        //NB this should be calculated depending on the height of the popup bitmap.
                        const int max_lines_dlg_popup=2;
                        if (nLines>max_lines_dlg_popup)
                            nLines = max_lines_dlg_popup;
                        scrWidth = (data->dlgBgdBitmap->area.sx * 3)/4; //the max width is about 3/4 of the pop-up
                        if ( (strLen[DLG_LINE2] > (scrWidth-charWidth)*nLines) ||
                            (strLen[DLG_LINE1] > scrWidth))
                        {
                            //recalculate width below.
                            if (data->WrapStrings & WRAP_STRING_2)
                                nLines = MAX_WRAP_LINES;
                            fullScreen = DLG_USE_RECTANGLE;
                    }
                    else
                        {
                            fullScreen = DLG_USE_BITMAP;
                            //Leave width as is
                        }
                    }
#else
                    //On a C-sample, limit pop-up lines to 2 extra (any more - use entire screen)
                    {
                        const int max_lines_dlg_popup=2;
                        if (nLines>max_lines_dlg_popup)
                            nLines = max_lines_dlg_popup;
                    }

#endif
                    if (fullScreen == DLG_USE_RECTANGLE)
                    {
                        //see if we can display as a pop-up
                        if (SCREEN_SIZE_X < 128)
                            scrWidth = SCREEN_SIZE_X-6;
                        else
                            scrWidth = (SCREEN_SIZE_X*7)/8;
                        if ( strLen[DLG_LINE2] > (scrWidth-charWidth)*nLines)
                        {
                            //Cannot fit in as a pop-up - use full screen
                            fullScreen = DLG_USE_FULL_SCREEN;
                            scrWidth = SCREEN_SIZE_X;
                        }
                    else
                    {
                            //We can fit it in - but we may want to reduce the width for a nicer look.
                        }
                    }

                    /*
                     * Wrap second text line (e.g. for long phone numbers.)
                     */
                                  if (strLen[DLG_LINE2] > scrWidth-charWidth)
                                  {
                                      //If we can fit the string on 2 lines - do it.
                                      if (data->WrapStrings & WRAP_STRING_2)
                                      {
                                          if (str[DLG_LINE2][0] != (char)0x80) //not unicode /* x0039928 -Lint warning removal */
                                          {
                                               wrapLine = 0;
                                               lineLen = strlen(str[DLG_LINE2]);
                                              // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
                                              // memset is not required any more .
                                              //Now the last element of the str[] will point to the second string of the dialog
                                             str[MAX_DLG_LINES] = str[DLG_LINE2];  // Now move the second  line of text to the last element of the arrya
                                             strLen[MAX_DLG_LINES] = strLen[DLG_LINE2];// put the right value for the length of the string
                                             str[DLG_LINE2] = NULL ;  // Assign NULL to the second element of the array.
                                             while ((wrapLine < MAX_WRAP_LINES) && (linePos<lineLen))
                                             {
                                                 // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
                                                 // Instead of DLG_LINE2 use MAX_DLG_LINES
                                                 nChar = dspl_GetNcharToFit (&str[MAX_DLG_LINES][linePos], (USHORT)scrWidth);
                                                 if (nChar > MAX_WRAP_CHAR)
                                                     nChar = MAX_WRAP_CHAR;
                                                 // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
                                                 // Allocate MAX_WRAP_CHAR no of bytes
                                                 temp_ptr = (char*)mfwAlloc(MAX_WRAP_CHAR);
                                                 if(NULL == temp_ptr)
                                                     return 0;
                                                 // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
                                                 // Now the destination of memcpy is temp_ptr instead of str2[wrapLine] and the source is str[MAX_DLG_LINES] instead of str[DLG_LINE2]
                                                 memcpy(temp_ptr,&str[MAX_DLG_LINES][linePos],nChar);  // Now the source data is from the last element of the array.
                                                 linePos = linePos+nChar;
                                                 ////GW - even if we cannot display the entire string - it is better than what we would have otherwise
                                                 // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
                                                // Assign the value of pointer temp_ptr to str[]
                                                str[DLG_LINE2+wrapLine] = temp_ptr;
                                                temp_ptr = NULL;
                                                strLen[DLG_LINE2 + wrapLine] = dspl_GetTextExtent(str[DLG_LINE2+wrapLine],0);
                                                wrapLine++;
                                             }

                                }
                        else
                            {
                                //Unicode is more problematic - we need the 0x80 at the front of the string
                                //for the call to 'dspl_GetNcharToFit'. This will involve copying the entire remainder
                                //of 'str2' into a temporary buffer. At the moment, we only wrap numbers so this
                                //code will wait until it is required.
                            //  str[3] = "Code not written!!";  //issue warning
                            //  strLen[3] = dspl_GetTextExtent(str[3],0);
                                fullScreen = DLG_USE_FULL_SCREEN; //error - use full screen
                            }
                        }
                    }

                    //Calculate longest line of text (including softkeys - sx already set to the softkey width)
                    for (i=0;i< MAX_DLG_LINES;i++)
                    {
                        if (strLen[i]>sx)
                            sx = strLen[i];
                    }
                    if (sx > SCREEN_SIZE_X-charWidth)
                        sx = SCREEN_SIZE_X;
                    else
                    {
                        if (sx > SCREEN_SIZE_X/2)
                            sx = sx + charWidth;
                        else
                            sx = sx + charWidth*2;
                    }
                    if (sy> sx)
                        sx = sy;
                    wx = (SCREEN_SIZE_X-sx)/2;
                    if (wx<0)
                        wx=0;
                }

                if (sy > SCREEN_SIZE_Y)
                    wy = 0;
                else if (SCREEN_SIZE_Y > 2*sy)
                    wy = (SCREEN_SIZE_Y*2/3-sy)/2; //display in middle of top 2/3 of screen
                else
                    wy = (SCREEN_SIZE_Y-sy)/2; //display in middle of screen
                if (wy < 10)
                    wy = wy/2;

                if ((wx == 0) || (wy==0))
                {   //not enough room to display as a window - use whole screen
                    fullScreen = DLG_USE_FULL_SCREEN;
             }

#ifdef COLOURDISPLAY
                    if ((data->icon_array != NULL) && (fullScreen != DLG_USE_BITMAP))
                    {   //The dialog has an animation - we must make the pop-up large enough to support this
                        if (sx < data->icon_array[0].area.sx)
                            sx = data->icon_array[0].area.sx;
                        yBmpOfs = data->icon_array[0].area.py + data->icon_array[0].area.sy;
                        wy = data->icon_array[0].area.py;
                        sy = sy + data->icon_array[0].area.sy;
                    }
#endif
            }
            else
            {
                //We have no strings to display - clear entire screen
                fullScreen = DLG_USE_FULL_SCREEN;
            }


            /******************************
             * Draw window (full screen/pop-up)
             *****************************/
            if (fullScreen != DLG_USE_FULL_SCREEN)
                dspl_unfocusDisplay();
            area.px = 0;
            area.py = 0;
            area.sx = sx;
            area.sy = sy;
            resources_setColour(data->dlgCol);
            drawWinType = DSPL_WIN_CENTRE;

             if (fullScreen!=DLG_USE_FULL_SCREEN)
             {
                t_font_bitmap bmp;
                t_font_bitmap* bmpPtr = NULL;

                for (i=0;i<MAX_DLG_LINES;i++)
                {
                    //centre text
                    xPos[i] = wx+(sx-strLen[i])/2;
                    yPos[i] = wy+yOfs+yBmpOfs+Mmi_layout_line_height()*i;
                }

#ifdef COLOURDISPLAY
                if ((data->dlgBgdBitmap != NULL) && (fullScreen==DLG_USE_BITMAP))
                {
                    bmp.format = data->dlgBgdBitmap->icnType;
                    bmp.height = data->dlgBgdBitmap->area.sy;
                    bmp.width = data->dlgBgdBitmap->area.sx;
                    bmp.bitmap = data->dlgBgdBitmap->icons;
                    bmpPtr = &bmp;
                    area = calcLayout(data->dlgType, sx, sy, bmp.width, bmp.height);

                    //Adjust size of available area depending on bitmap properties/dlgType.
                    //dlgType== 0 =>display info in centre of bitmap
                    if (data->dlgType == 0)
                    {
                        //If the bmp is bigger than the data we will move the bmp to
                        //lie over the centre of the data
                        area.px = area.px - (bmp.width - sx)/2;
                        area.py = area.py - (bmp.height- sy)/2;
                    }
                    for (i=0;i<MAX_DLG_LINES;i++)
                    {
                        xPos[i] = xPos[i]  + area.px;
                        yPos[i] = yPos[i]  + area.py;
                    }

                    TRACE_EVENT_P3("wy = %d, yOfs = %d, area.py = %d",wy,yOfs,area.py);
                    if( data->dlgBgdBitmap->icnType != ICON_TYPE_1BIT_UNPACKED )
                        dspl_SetBgdColour( COL_TRANSPARENT );


                }
                else
                {
                       // x0066814 06 Dec 2006, OMAPS00106825
                    //The window height calculation related to wrapping should be skipped when no
                    //string wrapping is done
                    if(wrapLine>0)
                       {
                        sy = sy + (wrapLine-1)*Mmi_layout_line_height();
                    }
                    area.sy = sy;
                }
#else
                if (wrapLine>1)
                {
                    sy = sy + (wrapLine-1)*Mmi_layout_line_height();
                    area.sy = sy;
                }
#endif
                    // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
                    //If  length of the dialog is bigger than screen then start the dialog from the top corner.
                   if(sy+wy >= SCREEN_SIZE_Y && sy < SCREEN_SIZE_Y)
                       if(wy>0 && wy < sy)
                       {
                            wy = (SCREEN_SIZE_Y - sy ) /2 ;// centre  the dialog
                            if(wy < 0)
                                wy=0;
                            for (i=0;i<MAX_DLG_LINES;i++)
                                yPos[i] = wy+yOfs+yBmpOfs+Mmi_layout_line_height()*i;
                       }
                  dspl_DrawWin( wx,wy,sx,sy, drawWinType , bmpPtr);
             }
             else
             {
                dspl_ClearAll();
                sx = 84;
                for (i=0;i<MAX_DLG_LINES;i++)
                {
                    xPos[i] = 0;
                    yPos[i] = Mmi_layout_line(i+1);
                }
             }
            /******************************
             * Print softkeys
             *****************************/
            icnShow(data->icon);
            if ((lskStr != NULL) || (rskStr != NULL))
            {
                if (fullScreen==DLG_USE_FULL_SCREEN)
                    Mmi_layout_softkeyArea( &skArea );
                else
                {
                    skArea.px = area.px+wx;
                    skArea.sx = area.sx;
                    skArea.py = area.py+wy+area.sy-Mmi_layout_softkeyHeight()-1;
                    skArea.sy = Mmi_layout_softkeyHeight();
                }
                softKeys_displayStrXY(lskStr, rskStr, data->dlgSkFormat, data->dlgCol, &skArea);
             }

            /******************************
             * Print dialog text
             *****************************/
            for (i=0;i<MAX_DLG_LINES;i++)
            {    /* GW#2294 No need to draw zero length strings .*/
                if ((str[i] != NULL) && (strLen[i] > 0))
                    {
               //x0035544 Feb 15, 2006. DR:OMAPS00061467
               #ifdef FF_MMI_SAT_ICON
                          if(data->IconData.selfExplanatory == FALSE)
                    dspl_TextOut(xPos[i] + titleIconWidth, yPos[i], DSPL_TXTATTR_NORMAL, str[i] );
               #else
                    dspl_TextOut(xPos[i] , yPos[i], DSPL_TXTATTR_NORMAL, str[i] );
               #endif
                         }
            }
          //x0035544 Feb 15, 2006. DR:OMAPS00061467
         #ifdef FF_MMI_SAT_ICON
         if(data->IconData.dst != NULL)
         {
          if(str[DLG_LINE2] == NULL)
            {
             if ((data->IconData.width > TITLE_ICON_WIDTH) ||
                (data->IconData.height > TITLE_ICON_HEIGHT))
                  {
                dspl_BitBlt2(xPos[0], yPos[0], 8,
                        10, (void*)SATIconQuestionMark, 0, BMP_FORMAT_256_COLOUR);
               }

                 else
                dspl_BitBlt2(xPos[0], yPos[0], data->IconData.width,
                         data->IconData.height, (void*)data->IconData.dst, 0, BMP_FORMAT_256_COLOUR);
            }
         else
            {
            if ((data->IconData.width > TITLE_ICON_WIDTH) ||
                (data->IconData.height > TITLE_ICON_HEIGHT))
                  {
               dspl_BitBlt2(xPos[DLG_LINE2], yPos[DLG_LINE2], 8,
                        10, (void*)SATIconQuestionMark, 0, BMP_FORMAT_256_COLOUR);
                }
            else
                dspl_BitBlt2(xPos[DLG_LINE2], yPos[DLG_LINE2],data->IconData.width,
                         data->IconData.height, (void*)data->IconData.dst, 0, BMP_FORMAT_256_COLOUR);
            }

         }
         #endif


             resources_restoreColour();
        }
     // Sep 06 2005  REF:  MMI-SPR-33548  x0012849
     // Now free the allocated memory
     /* x0039928 - Lint warning removal */
    if (strLen[MAX_DLG_LINES] > scrWidth-charWidth)
        if (data->WrapStrings & WRAP_STRING_2)
            if (str[MAX_DLG_LINES][0] != (char)0x80)  /* x0039928 - lint warning removal */
            {
                 for(i=DLG_LINE2;i<MAX_DLG_LINES;i++)
                 {
                      if(NULL != str[i] && strLen[i] > 0)
                       mfwFree((U8*)str[i],MAX_WRAP_CHAR);
                   }
               str[MAX_DLG_LINES]=NULL;
          }

        break;
    default:
        return 0;
    }

    return 1;
}

/*******************************************************************************

 $Function:     dialog_info_tim_cb

 $Description:  Callback function for the dialog info timer.


 $Returns:      MFW event handler

 $Arguments:    window handle event, timer control block

*******************************************************************************/
static T_MFW_CB dialog_info_tim_cb (T_MFW_EVENT event, T_MFW_TIM *tc)
{
  T_MFW_HND       win  = mfw_parent (mfw_header());
  T_MFW_WIN     * win_data = ((T_MFW_HDR *)win)->data;
  T_dialog_info * data = (T_dialog_info *)win_data->user;

  T_MFW_HND       parent_win = data->parent_win;
  USHORT          Identifier = data->Identifier;
  void (* Callback)() = data->Callback;

    TRACE_FUNCTION("dialog_info_tim_cb()");
#if defined (WIN32)
      {
          /***************************Go-lite Optimization changes Start***********************/

        //Aug 16, 2004    REF: CRR 24323   Deepa M.D
        TRACE_EVENT_P1 ("Identifier %d", data->Identifier);
        /***************************Go-lite Optimization changes end***********************/

      }
#endif

  /*
  ** SPR#1744 NDH
  ** Move the dialog destory in front of the Callback to make the processing consistent
  ** with the Right Keypress and Hangup Processing. Also to ensure that the dialog is
  ** removed when the screen is redrawn.
  */
  dialog_info_destroy (win);

//TISH modified for MSIM
//  if (Callback)
  if (Callback && parent_win)
     (Callback) (parent_win, Identifier, INFO_TIMEOUT);

  return 0;
}


/*******************************************************************************

 $Function:     dialog_info_kbd_cb

 $Description:  Keyboard event handler

 $Returns:      status int

 $Arguments:    window handle event, keyboard control block

*******************************************************************************/

static int dialog_info_kbd_cb (T_MFW_EVENT event, T_MFW_KBD *keyboard)
{
  T_MFW_HND       win  = mfw_parent (mfw_header());
  T_MFW_WIN     * win_data = ((T_MFW_HDR *)win)->data;
  T_dialog_info * data = (T_dialog_info *)win_data->user;
  T_MFW_HND       parent_win = data->parent_win;
  USHORT          Identifier = data->Identifier;
  void (* Callback)() = data->Callback;

  TRACE_FUNCTION("dialog_info_kbd_cb");
  switch (keyboard->code)
  {
    case KCD_LEFT:
        if (data->KeyEvents & KEY_LEFT )
        {
        TRACE_EVENT("dialog_info_kbd_cb: KEY_LEFT");

            dialog_info_destroy (win);
            if (Callback)
            (Callback) (parent_win, Identifier, INFO_KCD_LEFT);
        }
        break;

    case KCD_RIGHT:
        if (data->KeyEvents & KEY_RIGHT)
        {
            dialog_info_destroy (win);
           if (Callback)
             (Callback) (parent_win, Identifier, INFO_KCD_RIGHT);
        }
        break;

    case KCD_HUP:
        if (data->KeyEvents & KEY_HUP  || data->KeyEvents & INFO_KCD_ALL)
        {
           dialog_info_destroy (win);
           if (Callback)
             (Callback) (parent_win, Identifier, INFO_KCD_HUP);
        }
        break;

    case KCD_MNUUP:
        if (data->KeyEvents & KEY_MNUUP)
        {
           if (Callback)
             (Callback) (parent_win, Identifier, INFO_KCD_UP);
        }
        break;

    case KCD_MNUDOWN:
        if (data->KeyEvents & KEY_MNUDOWN)
        {
          if (Callback)
             (Callback) (parent_win, Identifier, INFO_KCD_DOWN);
        }
        break;

       //MZ 7/3/01 used to start a call.
    case KCD_CALL:
        if (data->KeyEvents & KEY_CALL )
        {
           dialog_info_destroy (win);
           if (Callback)
              (Callback) (parent_win, Identifier, INFO_KCD_OFFHOOK);
        }
        break;

    default:
        if (data->KeyEvents & INFO_KCD_ALL)
        {
                TRACE_EVENT("dialog_info_kbd_cb: INFO_KCD_ALL");

        /*
        Note: The variable Identifier is overwritten with the
        keycode of the dialog;
        we need it only for the Multicall Control !!
        */
           Identifier = keyboard->code;
           dialog_info_destroy (win);
           if (Callback)
             (Callback) (parent_win, Identifier, INFO_KCD_ALL);
        }
       break;

  }
  return MFW_EVENT_CONSUMED;
}

static int dialog_info_kbd_long_cb(T_MFW_EVENT event, T_MFW_KBD *keyboard){
    return MFW_EVENT_CONSUMED;
}


/*******************************************************************************

 $Function:     mmi_dialog_information_screen

 $Description:

 $Returns:

 $Arguments:

*******************************************************************************/

T_MFW_HND mmi_dialog_information_screen(T_MFW_HND parent_win, int TxtId, char* text, T_VOID_FUNC call_back, USHORT identifier)
{
    T_DISPLAY_DATA display_info;
    dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtId, TxtNull, COLOUR_STATUS);
    dlg_initDisplayData_events( &display_info, call_back, THREE_SECS, KEY_ALL );
    //Sep 01, 2004    REF: CRR 21380  Deepa M.D
    //Assigning TextId and TextString will not display both the messages.
    //Hence we need to use TextId and TextString2 or TextId2 and TextString
    display_info.TextString2   = text;
    display_info.Identifier   = identifier;
    return info_dialog(parent_win,&display_info); //information screen
}

T_MFW_HND mmi_dialog_information_screen_forever(MfwHnd win,int TextId, char* TextStr, int colour)
{
    T_DISPLAY_DATA DisplayInfo;
    dlg_initDisplayData_TextId( &DisplayInfo, TxtNull, TxtNull, TextId,  TxtNull, colour);
    dlg_initDisplayData_events( &DisplayInfo, NULL, FOREVER, KEY_HUP );
    DisplayInfo.TextString  = TextStr;
    return info_dialog(win, &DisplayInfo);
}

/*******************************************************************************

 $Function:     mmi_dialogs_insert_icon

 $Description:  Displays one icon in a dialog

 $Returns:      none

 $Arguments:    win, pointer to an icon

*******************************************************************************/
void mmi_dialogs_insert_icon (T_MFW_HND win_dialog ,MfwIcnAttr *icon)
{
    T_MFW_WIN      * win_data     = ((T_MFW_HDR *)win_dialog)->data;
    T_dialog_info  * data         = (T_dialog_info *)win_data->user;

    data->icon = icnCreate(win_dialog,icon,E_ICN_VISIBLE,NULL);
    icnUnhide(data->icon);
    winShow(win_dialog);
}

/*******************************************************************************

 $Function:     mmi_dialogs_insert_animation

 $Description:  starts an animation in a dialog

 $Returns:      none

 $Arguments:    win, animation time, pointer to an icon, number of frames

*******************************************************************************/
void mmi_dialogs_insert_animation (T_MFW_HND win_dialog , S32 anim_time ,MfwIcnAttr *icon ,UBYTE number_of_frames)
{
    T_MFW_WIN      * win_data     = ((T_MFW_HDR *)win_dialog)->data;
    T_dialog_info  * data         = (T_dialog_info *)win_data->user;

    data->number_of_frames = number_of_frames;
    data->current_frame = 0;
    data->icon_array = icon;
    data->current_icon = data->icon_array;
    data->icon = icnCreate(win_dialog,data->current_icon,E_ICN_VISIBLE,NULL);
    icnUnhide(data->icon);

    data->animation_timer = timCreate(win_dialog,anim_time,(MfwCb)mmi_dialogs_insert_animation_CB);
    timStart(data->animation_timer);
    winShow(win_dialog);
}

/*******************************************************************************

 $Function:     mmi_dialogs_insert_animation_CB

 $Description:  destroys the current icon and starts the next icon

 $Returns:      none

 $Arguments:    timer event, timer control block

*******************************************************************************/
void mmi_dialogs_insert_animation_CB (T_MFW_EVENT event, T_MFW_TIM *tc)
{
    T_MFW_HND       win  = mfw_parent (mfw_header());
    T_MFW_WIN     * win_data = ((T_MFW_HDR *)win)->data;
    T_dialog_info * data = (T_dialog_info *)win_data->user;

    icnDelete(data->icon);
    if (data->current_frame < (data->number_of_frames-1))
    {
	data->current_frame++;
	data->current_icon++;
    }
    else
    {
	data->current_frame = 0;
	data->current_icon = data->icon_array;
    }
    data->icon = icnCreate(win,data->current_icon,E_ICN_VISIBLE,NULL);
    icnUnhide(data->icon);
    timStart(data->animation_timer);
    winShow(win);
}
/***************************Go-lite Optimization changes Start***********************/

//Aug 25, 2004    REF: CRR 24904   Deepa M.D
//This function is used only for the Color build.Hence it is put under the
//COLOURDISPLAY compiler switch
#ifdef COLOURDISPLAY
void mmi_dialogs_insert_animation_new (T_DISPLAY_DATA *animateInfo , S32 anim_time ,MfwIcnAttr* icon ,UBYTE number_of_frames)
{
    TRACE_EVENT("mmi_dialogs_insert_animation_new()");

    animateInfo->number_of_frames = number_of_frames;
    animateInfo->current_frame = 0;
    animateInfo->icon_array = icon;
    animateInfo->anim_time = anim_time;
}
#endif
/***************************Go-lite Optimization changes end***********************/

void mmi_dialogs_animation_new_CB (T_MFW_EVENT event, T_MFW_TIM *tc)
{
  T_MFW_HND win = mfw_parent (mfw_header());
  T_MFW_WIN     *   win_data = ((T_MFW_HDR *)win)->data;
  T_dialog_info *   data = (T_dialog_info *)win_data->user;
  char * idData;
  int px, py, sx, sy;
  MfwIcnAttr* icn_array;
  MfwIcnAttr* icn;

  TRACE_EVENT("mmi_dialogs_insert_animation_new_CB()");

  data->current_frame = (data->current_frame +1) % data->number_of_frames;
  TRACE_EVENT_P1("data->current_frame = %d", data->current_frame);
  TRACE_EVENT_P1("number_of_frames = %d", data->number_of_frames);

  icn_array = (MfwIcnAttr*)data->icon_array;
  TRACE_EVENT_P1("data->icon_array = %x", (int)data->icon_array);

  icn = &icn_array[data->current_frame];

  px = icn->area.px;
  py = icn->area.py;
  sx = icn->area.sx;
  sy = icn->area.sy;

  TRACE_EVENT_P4("px = %d, py = %d, sx = %d, sy = %d", icn->area.px,icn->area.py,icn->area.sx,icn->area.sy);

  idData = icn->icons;

  dspl_BitBlt2(px,py,sx,sy,(void*)idData,0,0x02);
  timStart(data->animation_timer);
}
//Jun 04,2004 CRR:13601 xpradipg - SASKEN
/*******************************************************************************

 $Function:     InfoDialogTimRestart

 $Description:  restarts the information dialog timer

 $Returns:      none

 $Arguments:    window handler

*******************************************************************************/

void InfoDialogTimRestart(T_MFW_HND win)
{
    T_MFW_WIN * win_data;
    T_dialog_info * data;

    win_data = ((T_MFW_HDR *)win)->data;
    data     = (T_dialog_info *)win_data->user;

    tim_stop(data->info_tim);
    tim_start(data->info_tim);
}

// Feb 24, 2005 CRR:29102 xnkulkar - SASKEN
// As the user has already confirmed that all SMS messages are to be deleted, KEY_HUP is not
// registered.
/*******************************************************************************

 $Function:     mmi_dialog_information_screen_delete_all

 $Description:  Displays the information screen during "Delete All" operation

 $Returns:  Handle of information dialog

 $Arguments:    window handle, text id, text string and generic status window

*******************************************************************************/
T_MFW_HND mmi_dialog_information_screen_delete_all(MfwHnd win,int TextId, char* TextStr, int colour)
{
    T_DISPLAY_DATA DisplayInfo;

    dlg_initDisplayData_TextId( &DisplayInfo, TxtNull, TxtNull, TextId,  TxtNull, colour);
    dlg_initDisplayData_events( &DisplayInfo, NULL, FOREVER, NULL );
    DisplayInfo.TextString  = TextStr;

    return info_dialog(win, &DisplayInfo);
}